APOSTILA DE ASSEMBLY

(1ª PARTE)
INF 1091 − TPD − PUC-RIO
PROFESSOR: RODRIGO TOLEDO
email: rtoledo@openlink.com.br

-1-

ÍNDICE

Revisando Conceitos e Sistemas de Numeração
Números Hexadecimais, Notação Binária...

03 06 10

Arquitetura Interna do 8088
Registradores, Memória Segmentada e Pilha

O Programa Hello
Segment/Ends, Assume, Proc/Endp, Mov, Lea, Int, “Print String”, “Exit”, DB/DW, Dup, Stack, End

O Programa Hello2
Call, Ret, Push/Pop, Xor, Sub/Add, Shr/Shl, “Scroll Window”, “Get Current Video Mode”, “Cursor Position”, “Input Without Echo”

14

O Programa Tecla
Cmp, Jb/Ja, Jmp, Inc, Loop, Label, “Buffer Input”, “Char Output”

19 23 26

O Programa Impbin
Je, Or, Clc/Stc, Rcl/Rcr, Adc

Mul, Div e Exercícios

-2-

unidade de informação representável em Byte . Como já é sabido.É a menor computadores.Conjunto de 8 bits. os computadores são máquinas binárias e portanto trabalham na base 2. SISTEMAS DE NUMERAÇÃO: Existem diversos sistemas de numeração. Portanto. pois é uma forma mais compacta para representar os números binários. Word . os seres humanos utilizam muitas vezes a base 16 (ou hexadecimal). onde os números são representados com apenas dois algarismos. byte é a menor unidade de memória endereçável.REVISANDO CONCEITOS: Bit . Os algarismos utilizados para representar os números hexadecimais e seus respectivos equivalentes 3 -3- . Existe uma relação direta de 4 dígitos binários para um dígito hexadecimal (24 = 16). sendo mais conhecido o decimal ou de base 10. é possível representar 1 byte (8 bits) com dois algarismos hexadecimais. Os bits dentro de um byte são numerados da direita para a esquerda começando com 0. Números Hexadecimais: São números expressos na base 16 e portanto dispõem de 16 algarismos para a sua representação. Uma word é composta de 2 bytes no caso dos IBM-PC. o 0 e o 1. Por ser muito difícil trabalhar com números expressos na base 2.É a quantidade de bits que pode ser processada em qualquer operação de transferência de dados entre a CPU e a memória principal em um dado instante.

onde Para evitar confusões futuras.decimais são: 0 1 2 3 4 5 6 7 8 A=10. D=13. C=12.Números binários.Números hexadecimais. terminarão com a letra "b". . nós adotaremos a seguinte convenção para a representação de números: . .Números hexadecimais que comecem com letra deverão ser precedidos de 0. F=15. E=14. EX: 0B000h Ex: 10h. 9 A B C D E F. Como Converter Números Hexadecimais em Decimais: Os números decimais são formados da seguinte forma: 273 = 7x 3x 273 Analogamente: D3h = 3 = D3h = D = 3x 13 x 16 = 1 = 211 3 208 2x 1 = = 100 = 70 3 273 200 10 = --------------------------------- ------------------------------------- Convertendo Decimal Para Hexa: Vejamos o que acontece quando dividimos um número decimal por 10: 235 / 10 = 23 resto 5 4 -4- . serão terminados pela letra "h". B=11.

A tabela abaixo permite converter qualquer número hexadecimal em binário e vice-versa: Binário (0000) (0001) (0010) (0011) (0100) (0101) (0110) (0111) (1000) (1001) (1010) Decimal 0 1 2 3 4 5 6 7 8 9 10 Hexadecimal 0 1 2 3 4 5 6 7 8 9 A 5 -5(1011) (1100) (1101) (1110) (1111) 11 12 13 14 15 B C D E F . para converter decimais para hexa. Portanto. existe uma relação simples entre os números binários e os números hexadecimais: um dígito hexadecimal corresponde a quatro dígitos binários (24 = 16). 1069 / 16 = 66 resto 13 66 / 16 = 4 resto 2 4 / 16 = 0 resto 4 ------------------------------------1069 = 42Dh Notação Binária: Como já foi dito. você deve dividir o número decimal por 16 e ir colhendo os restos da mesma maneira que foi feita para os números decimais.23 / 10 = 2 resto 3 2 / 10 = 0 resto 2 Os dígitos de 235 aparecem como restos em ordem contrária.

Exemplo: 0100 1101 0001 1100 4 D 1 C 6 -6- .

DX: Dados Uso geral. ⇒ Capaz de acessar 1Mb de memória.: índice de vetores). SS: Stack Segment 7 -7- .ARQUITETURA INTERNA DO 8088: ⇒ 14 registradores de 16 bits. ⇒ Capaz de acessar 65.535 portas de I/O Registradores de Uso Geral: AX AH/AL BX BH/BL CX CH/CL DX DH/DL (16 bits) (8 bits) AX: Acumulador Usado em operações aritméticas. BX: Base Usado para indexar tabelas de memória (ex. CX: Contador Usado como contador de repetições em loop e movimentação repetitiva de dados. Registradores de Segmento: São usados para a identificação de segmentos específicos de memória. DS: Data Segment Localiza o segmento de dados do programa. CS: Code Segment Localiza o segmento de código do programa que está sendo executado. O valor do CS não é atualizável.

SP: Stack Pointer Usado em conjunto com o SS para apontar o topo da pilha (stack). BP: Base Pointer Usado para indicar a base da pilha. Registradores de Deslocamento: Usados em conjunto com registradores de segmento.Localiza o segmento de pilha do programa. Não há acesso direto. IP: Instruction Pointer Usado em conjunto com o CS para apontar exatamente para o byte da próxima instrução a ser executada. ES: Extra Segment Usado para acessar um segmento de dados adicional. SI & DI: Source Index e Destination Index Particularmente usados como instruções de string. 8 -8- . Podem ser usados para indexar tarefas de memória. Particularmente importante para a passagem de parâmetros em linguagem de alto nível (como C).

Pode ser setada pelo sistema ou pelo usuário. Memória Segmentada: 9 -9- . OF: Overflow Flag Setada quando ocorre overflow aritmético. Também usada por instruções para tomadas de decisões.Registrador de Flags: Consiste em um grupo individual de bits de controle (flag). ZF: Zero Flag Setada quando um resultado for igual a zero. SF: Signal Flag Resetada (SF=0) quando um resultado for um número positivo ou zero e setada (SF=1) quando um resultado for negativo. AF: Auxiliar Flag Setada quando há “vai um” na metade inferior de um byte. PF: Parity Flag Setada quando o número de bits 1 de um resultado for par. Possui 16 bits como os demais registradores. TF: Trap Flag (debug) Usada por debugadores para executar programas passo a passo. além de poderem ser salvos ou recuperados como um grupo coordenado. DF: Direction Flag Setada para auto-incremento em instruções de string. IF: Interruption Flag Permite que ocorram interrupções quando setada. os quais podem ser inspecionados um a um como dados comuns. CF: Carry Flag Setada se houver “vai um” no bit de maior ordem do resultado.

⇒ A memória é dividida em um número arbitrário de segmentos. ⇒ É usada de baixo (endereço mais alto) para cima (endereço mais baixo). ⇒ Empilha e desempilha apenas words (16 bits). ⇒ O endereço segmentado é sempre composto por duas words (32 bits). ⇒ Serve para a passagem de parâmetros. ⇒ Controle quanto a “over flow” da pilha é responsabilidade do programador.10 - . ⇒ Cada segmento se inicia em uma posição perfeitamente divisível por 16. ⇒ Pode servir para o armazenamento temporário de dados. 10 . ⇒ A anotação usada para representar um endereço é: seg:desloc ⇒ Exemplo: 0041h : 0007h (CS = 0041h e IP = 0007h) endereço físico: 00410h + 0007h ====== 00417h A Pilha: ⇒ Toma conta do programa em execução. ⇒ O tamanho dos segmentos varia de 16 bytes a 64Kb.

respectivamente. Nome ENDS ⇒ Marcam o início e o fim de um segmento. ES. ⇒ A distância pode ser NEAR (default) para uma procedure contida no segmento. origem destino  endereço (origem) Lea Bx.11 - ... Nome ENDP ⇒ Marcam o início e o fim de uma procedure (função). memória16) 11 .. ASSUME Sintaxe: Assume Reg_Seg : Nome_Seg ⇒ Associa um segmento a um registrador ⇒ Reg_Seg pode ser: CS.. LEA (Load Effective Address) Sintaxe: Lógica: Exemplo: Lea destino. ou FAR para uma procedure contida em outro segmento.O PROGRAMA HELLO SEGMENT e ENDS Sintaxe: Nome SEGMENT comandos e procedures. ⇒ A procedure deve conter ao menos um RET. var (reg16. que efetua o retorno da função. ⇒ O nome indicado para a procedure deve ser único em todo o programa. DS. SS de segmento. PROC E ENDP Sintaxe: Nome PROC [distância] comandos. ⇒ Um programa pode ter mais do que um segmento com o mesmo nome. respectivamente.

Exit) 12 . var mov var. Ds mov var. Ds Operações e Exemplos: Operação registrador. registrador registrador. memória registrador. No final da Int as flags são desempilhadas. memória memória. 4Ch (Terminate a Process. INT 21h. imediato reg_seg. acumulador acumulador. reg_seg memória. registrador memória. Ax mov Ax.12 - .MOV Sintaxe: Lógica: Mov destino. Al mov Ax. Si mov Si. origem destino  origem Exemplo mov Bx. 12 mov Ds. reg_seg INT (Interrupt) Sintaxe: Int num_int Lógica: Empilha Flags Limpa Trap Flag Desabilita ints Callfar int (chama o procedimento da interrupção) Observação: A interrupção 21h contém os serviços do DOS. 09h (Print String) Entrada: Retorna: Observação: Ah = 09h Ds:Dx = Ponteiro para a string Nada A string deve ser terminada por um ‘$’ INT 21h. reg16 reg16. var mov var. A interrupção 10h contém os serviços da placa de vídeo. Cx mov var.

⇒ É a maneira correta de se encerrar um programa em DOS (2.. 100 bytes inicializados com 1 e 0 num Dup (valor..valor2. End [expressão] Sintaxe: expressão − indica o ponto de entrada do programa DB e DW (Define Byte e Define Word) ⇒ Aloca e inicializa um ou mais bytes de memória. END ⇒ Indica o fim de um módulo. DUP (Duplicate) Sintaxe: Lógica: Exemplo: Db 200 Dup (1) Db 50 Dup (1....13 - ..0 ou superior).) Repete os valores especificados num vezes 13 . Sintaxe: [nome] Db valor. liberando o espaço de memória usado para o DOS..0) .... ⇒ O Return Code pode ser testado através da variável de sistema errorlevel....Entrada: Ah = 4Ch Al = Return code Retorna: Nada ⇒ Fecha todos os arquivos e retorna o controle ao chamador. 200 bytes inicializados com 1 .. nome − cria uma variável quando especificado valor − pode ser: Tipo Exemplo Inteiro 5 String ‘mensagem’ Constante 2*5 Operador DUP 10 DUP (?) Interrogação ? Observação: Uma word não pode receber um byte e vice-versa.

atenção para a existência da pilha quando usar Int. Data_Seg Mov Ds.14 - . portanto. ⇒ Define um segmento de pilha. Hello. ⇒ As tabelas de exemplo sempre mostram todos os tipos aceitos pela instrução. ⇒ O caracter ‘. DS:Data_Seg Proc Far Mov Ax. ⇒ Os endereços neste segmento estão Observações: ⇒ Chamadas à uma interrupção usam pilha.4Ch Int 21h Endp Ends Segment Db 'Hello Assembly !$' Ends SEGMENT STACK 10 Dup('Pilha Ends Hello Hello Code_Seg Data_Seg Msg Data_Seg Stack_Seg db Stack_Seg End ') 14 .’ indica ao compilador que a partir daí a linha é apenas comentário. Msg Mov Ah.asm Code_Seg Hello Segment Assume CS:Code_Seg.STACK (Segment Stack) Sintaxe: nome_seg Segment Stack associados ao registrador SS. Ax Lea Dx.09 Int 21h Mov Ah.

Sintaxe: Ret [valor] Lógica: Desempilha IP Se RET Far { Desempilha CS } [SP  SP + valor] PUSH ⇒ Empilha POP uma word Push origem ⇒ Desempilha uma word Pop destino Sintaxe: Sintaxe: Lógica: SP  SP − 2 (SP)  origem Operações Reg Memória Reg_Seg (exceto IP) Exemplo PUSH BX PUSH Var PUSH ES Lógica: destino  (SP) SP  SP + 2 Operações Reg Memória Reg_Seg (exceto CS e IP) Exemplo POP SI POP Var POP DS 15 . Sintaxe: Call nome_procedure Lógica: Se Far Call { Empilha CS CS  segmento destino } Empilha IP IP  deslocamento destino RET (Return) ⇒ Retorna de uma chamada de uma procedure.15 - . ⇒ Comando obrigatório para retorno em Assembly.O PROGRAMA HELLO 2 CALL ⇒ Chama uma procedure.

imediato registrador. 0Fh Operações e Exemplos: Operação registrador. 5 Add Dx. imediato registrador. origem destino  destino + origem O D I T S Z A P C * * * * * * Operações e Exemplos: Operação registrador. imediato memória. Cx).16 - . registrador acumulador. registrador acumulador. imediato registrador. 5 Sub Dx. SUB (Subtract) Sintaxe: Lógica: Flags: Sub destino. origem destino  destino − origem O D I T S Z A P C * * * * * * ADD Sintaxe: Lógica: Flags: Add destino. registrador acumulador. registrador registrador. registrador registrador. Cx Xor Cl. memória memória. Si Add Al. com menos ciclos de máquina. imediato memória.XOR (Ou Exclusivo) Sintaxe: Lógica: Flags: Xor destino. var Sub var. var Add var. Dx Xor Al. 3 Observação: ⇒ Pode ser usado para zerar um registrador ou uma variável (exemplo: Xor Cx. 10101111b Xor Si. imediato Exemplo Add Dx. 3 Sub var. memória memória. 3 Add var. 0Fh 16 . 0CAh Xor var. Bx Sub Bx. origem destino  destino xor origem (bit a bit) O D I T S Z A P C 0 Tabela Verdade: Destino Origem 0 0 0 1 1 0 1 1 * * * * 0 Resultado 0 1 1 0 Operações e Exemplos: Operação registrador. imediato memória. memória memória. Bx Add Bx. Si Sub Al. imediato Exemplo Xor Bx. var Xor var. imediato Exemplo Sub Dx. tendo o mesmo efeito que mover zero. registrador registrador. porém.

⇒ Usados para multiplicação e divisão por potências de 2. 0  destino  CF os bits do destino para a esquerda. 06h (Scroll Window Up) Entrada: Ah 06h Al Número de linhas a rolar ou 0 para limpar a região Bh Atributo para novas linhas Retorna: Observações: ⇒ Int Ch Cl Dh Dl Linha superior Coluna esquerda Linha inferior Coluna direita nada 10h. ou seja. CL SHR Var. CL SHL Var. CL Observações: ⇒O O D I T S Z A P C * * * ? * * Operações e Exemplos: Operação registrador.17 - . quantidade Shl destino. CL Exemplo SHL SI. 1 memória. CL único valor imediato que pode ser usado é 1. o registrador CF recebe o bit de menor ordem e o bit de maior ordem recebe valor 0. 1 SHR BX. ⇒ Pode INT 10h. o registrador CF recebe o bit de maior ordem e o bit de menor ordem recebe valor 0. CF  destino  0 Lógica: Flags: Lógica: Flags: O D I T S Z A P C * * * ? * * Operações e Exemplos: Operação registrador. 1 memória. ⇒ Em ambos a OF (overflow flag) é setada se houver uma troca de sinal. quantidade os bits do destino para a direita. CL memória. se o bit de mais alta ordem trocou pois números com sinal são guardados em complemento a 2. CF fica com o valor do último rotacionado. CL Exemplo SHR SI. 1 registrador. CL memória.SHR (Shift Right) Sintaxe: ⇒ Desloca SHL (Shift Left) Sintaxe: ⇒ Desloca Shr destino. 07h (Scroll Window Down) tem as mesmas entradas. 1 SHR Var. 1 SHL BX. ser usada para limpar toda a tela. 0Fh (Get Current Video Mode) 17 . 1 registrador. ⇒ No caso de rotação de mais de um bit. INT 10h. Para deslocar mais de um bit de uma única vez é necessário usar o registrador Cl com o total de bits a serem deslocados. 1 SHL Var.

18 . ⇒ Se você pretende fazer com que sua rotina salve no início os registradores usados e os restaure no final. por 2 e Shl para multiplicar por 2 são maneiras de se programar economizando ciclos de máquina.Entrada: Ah 0Fh Retorna: Al Ah Bh Modo de vídeo Número de caracteres por linha Página de vídeo ativa INT 10h. ⇒ Int 10h é a interrupção de vídeo (pertence ao grupo de interrupções da Bios). 08h (Console Input Without Echo) Entrada: Ah 08h Observação: ⇒ TECLA Retorna: Al char ESPECIAL: Se a tecla for especial (exemplo: F1) Al retornará 0. Shr para dividir deverá estar sempre no Ah. Para pegar o código da tecla especial tem que ser chamada uma nova int 21h.18 - . 08h. ⇒ A rotina Encontra_Pos do programa Hello2 pode ser otimizada! ⇒ Push é mais rápido que salvar usando Mov. Observações: ⇒ O número dos serviços de interrupção ⇒ Usar Xor para zerar. lembre-se de que existem registradores que são usados como retorno de valores de uma interrupção. 02h (Set Cursor Position) Entrada: Ah 02h Bh Página de vídeo Retorna: nada Dh Dl linha coluna INT 21h.

Y Dl.4Ch Al.1 Bx 19 Espera_Tecla Proc Push Mov Int Pop Ret Espera_Tecla Endp Code_Seg Ends Near Ax Ah.02 Dh.Bh Ah.07 Cx.Msg 21h Dx Ax Hello2 SetCursor Limpa_Tela Proc Push Push Push Push Mov Mov Xor Mov Mov Int Pop Pop Pop Pop Ret Limpa_Tela EndP Near Ax Bx Cx Dx Ax.08 21h Ax Data_Seg Segment Msg Db 'Hello Assembler ! $' X Db ? .Cx Dh. Ax Limpa_Tela Encontra_Pos Say_Hello Espera_Tecla Limpa_Tela Ah.19 - .0600h Bh.Ah X.17 X.79 10h Dx Cx Bx Ax SetCursor Proc Push Push Push Xor Mov Mov Mov Int Pop Pop Pop Ret Endp Near Ax Bx Dx Bh.09 Dx. Data_Seg Ds. Ds:Data_Seg Encontra_Pos Say_hello Hello2 Proc Mov Mov Call Call Call Call Call Mov Mov Int Endp Near Ax.asm Code_Seg Segment Assume Cs:Code_Seg.X 10h Dx Bx Ax Encontra_Pos Proc Push Push Mov Int Mov Sub Shr Pop Near Ax Bx Ah.Hello2.0Fh 10h X.00 21h Pop Ret Endp Ax Say_hello Proc Push Push Call Mov Lea Int Pop Pop Ret EndP Near Ax Dx SetCursor Ah.24 Dl.

vez que o compilador encontrar o nome do rótulo ele irá substituir pelo endereço onde se encontra o rótulo (deslocamento). origem Operações e Exemplos: Operação Registrador. memória Memória.Y Db 12 Data_Seg Ends Stack_Seg SEGMENT STACK db Stack_Seg End 10 Dup(' ') Ends Hello2 O PROGRAMA TECLA Rótulo: Sintaxe: ⇒ Diretiva ⇒ Toda nome_rotulo: de compilação que marca uma posição dentro do código. Bx Cmp Si. var Cmp var.20 - . registrador Registrador. imediato Acumulador. registrador Memória. Cx Cmp var. 8 JB (Jump if Below) Sintaxe: Jb rótulo Lógica: Se CF (carry flag) = 1 Salta para rótulo Observação: JB = JC (Jump if Carry) = JNAE (Jump if Not Above or Equal) JA (Jump if Above) Sintaxe: Ja rótulo Lógica: Se CF (carry flag) = 0 && ZF (zero flag) = 0 Salta para rótulo Observação: JA = JNBE (Jump if Not Below or Equal) JMP (Jump) ⇒ Salto incondicional Sintaxe: Jmp rótulo Lógica: Salta para rótulo 20 . imediato Registrador. 3 Cmp Al. CMP (Compare) Sintaxe: Lógica: Flags setadas de acordo com o resultado de: destino − origem Flags: O D I T S Z A P C * * * * * * Cmp destino. 0Fh Cmp Bx. imediato Exemplo Cmp Cx.

far Exemplo: Byte_buffer label byte Word_buffer dw 512 dup (?) INT 21h. 0Ah (Buffer Input) ⇒ Lê os caracteres. dword.Observação: ⇒ O Salto pode ser longo. • near. ecoando-os na tela se o tamanho máximo ainda não tiver estourado. word. inclusive para outros segmentos. etc. ⇒ Edição rudimentar. LABEL ⇒ Cria um rótulo ou var Sintaxe: nome label tipo Observação: ⇒ tipo pode ser: • byte. 21 . até que <Enter> seja pressionado.21 - . Entrada: Ah 0Ah Ds:Dx  ponteiro para buffer offset 0 do buffer  tamanho máximo do buffer + 1 Retorna: offset 1 do buffer  número de caracteres efetivamente lidos (sem contar o <Enter>) offset 2 do buffer em diante  caracteres lidos incluindo o CR (Carriage Return = <Enter>) Observação: ⇒ Não lê teclas de função. cuja sintaxe é a mesma de INC. INC (Increment) Sintaxe: Lógica: Flags: Inc destino destino  destino + 1 O D I T S Z A P C * * * * * Operações e Exemplos: Operação registrador 16 bits Registrador 8 bits Memória Exemplo Inc Bx Inc Cl Inc var Observação: ⇒ Para decrementar use o comando DEC.536 loops. LOOP Sintaxe: Loop rótulo Lógica: Cx  Cx − 1 Se ( Cx != 0 ) Jmp rótulo Observação: ⇒ Se Cx = 0 no início serão feitos 65. ⇒ Dados só podem ser criticados ao final.

Exemplo: var[Bx] ⇒ O assembly permite que você faça jumps para uma procedure. ao fazer jumps para procedures você estará perdendo a estruturação do seu programa e portanto sua qualidade. se for do tipo beep. ⇒ O camando “for” de C em Assembly é o comando Loop que repete um bloco Cx vezes.22 - . para números com sinal use JG (Jump if Greater) e JL (Jump if Less). 22 . ⇒ Os jumps condicionais devem estar imediatamente após o Cmp. line feed ou assemelhados. 2) Mesmo que você resolva o problema anterior. ⇒ O comando “if” de C em Assembly é a junção do CMP com um “jump” condicional. Entrada: Ah 02h Dl caracter Observações: ⇒ Os “jumps” condicionais (Jb.) têm um limite de 127 bytes de distância até o rótulo. Si e Di. portanto para dar um salto condicional maior que 127 bytes usa-se comumente um recurso denominado trampolim. no entanto não se deve fazer uso deste recurso por dois motivos: 1) O Ret não irá funcionar. etc. o beep toca.⇒ Quando o limite de caracteres a serem lidos estoura. Para chamar uma procedure use apenas o comando Call. ⇒ Os únicos registradores que podem ser usados como indexadores de memória são: Bx. Exemplo: var[3] ⇒ Ja e Jb são usados para números positivos. INT 21h. O Jmp não tem limite (pode ser inclusive em outro segmento). Deslocamento também pode ser representado em assembly pela presença de colchetes. ⇒ Offset = deslocamento. porque outras instruções podem alterar o resultado das flags. Jae. pois ele espera encontrar na pilha o endereço de retorno que é empilhado pelo Call. ⇒ Ao usar o Loop devemos estar atentos quanto a alterações em Cx para não atrapalhar o controle de repetição. os jumps não empilham endereço. que é o uso de um “jump” condicional apontando para um Jmp (incondicional) para que a distância do rótulo seja vencida. 02h (Char Output) ⇒ Imprime o caracter ou o executa.

'z' Prox_Byte Al. Data_Seg Ds.23 - . Ds:Data_Seg Tecla Proc Mov Mov Call Call Mov Int Endp Near Ax.4Ch 21h Prox_Byte: Inc Loop Loop_Conversao Pop Pop Pop Ret Conv_Maiuscula Code_Seg Ends Bx Cx Bx Ax EndP Tecla Le_Texto Data_Seg Proc Push Push Lea Mov Int Pop Pop Ret Endp Near Ax DX Dx.0Ah 21h Dx Ax Segment Texto Label Byte Tam_String Db 31 Car_Lidos Db 0 String Db 31 Dup(' ') Data_Seg Ends Le_Texto Conv_Maiuscula Push Push Push Xor Mov Lea Loop_Conversao: Mov Cmp Jb Cmp Ja Sub Mov Proc Near Ax Bx Cx Ch. Ax Le_Texto Conv_Maiuscula Ah.asm Code_Seg Segment Assume Cs:Code_Seg.[Bx] Al.Al Stack_Seg db Stack_Seg End SEGMENT STACK 10 Dup('Pilha Ends Tecla ') 23 .'a' Prox_Byte Al.String Al.Car_Lidos Bx.Tecla. Texto Ah.20h [Bx].Ch Cl.

é usado para comparar com 0: Or x. cuja tabela verdade é: Destino Origem Resultado 0 0 0 0 1 0 1 0 0 1 1 1 ⇒ Existe ainda a operação NOT. ⇒ JNE (Jump if Not Equal) teste para o salto é inverso do JE. cuja sintaxe só tem destino (sem origem). origem destino  destino or origem (bit a bit) O D I T S Z A P C 0 * * ? * 0 Resultado 0 1 1 1 Operações e Exemplos: Vide Xor na página 15.x ⇒ Existe também a operação lógica AND. origem destino  destino + origem + CF 24 .O PROGRAMA IMPBIN JE (Jump if Equal) Sintaxe: Je rótulo Lógica: Se ZF (Zero flag) = 1 Salta para rótulo Observações: ⇒ JE = JZ (Jump if Zero).24 - . Tabela Verdade: Destino Origem 0 0 0 1 1 0 1 1 ADC (Add With Carry) Sintaxe: Lógica: Adc destino. OR ⇒ Ou lógico Sintaxe: Lógica: Flags: Or destino. Observações: ⇒ Por gastar menos ciclos de máquina que o Cmp.

CL Exemplo RCL AX. também existe o RCR (Rotate Through Carry Right). 1 memória. respectivamente. 1 RCL Var. Bx. respectivamente. quantidade CF  destino  O D I T S Z A P C * * Operações e Exemplos: Operação registrador. CL Observação: ⇒ Assim como existem o SHR e o SHL. 1 RCL BX. CL RCL Var. 25 . Observação: ⇒O comando Push não pode ser usado para empilhar vários registradores ao mesmo tempo. (Ex: CLD − Clear Direction Flag) Observação: ⇒ As flags DF e IF também podem ser setadas (receberem valor 1) através das instruções: STD e STI. Cx.25 - . (Ex: STI − Set Interruption Flag) RCL (Rotate Through Carry Left) Sintaxe: Lógica: Flags: RCL destino. CL memória. Apenas por uma questão de melhor visualização e aproveitamento do espaço usaremos em algumas das listagens dos programas: Push Ax.CLC (Clear Carry Flag) Sintaxe: Lógica: Flags: CLC CF  0 O D I T S Z A P C 0 STC (Set Carry Flag) Sintaxe: Lógica: Flags: STC CF  1 O D I T S Z A P C 1 Observação: ⇒ As flags DF e IF também podem ser zeradas através das instruções: CLD e CLI. 1 registrador.

asm Conv_Maiuscula EndP Valida_Texto Proc Near Push Ax.'F' Ja Erro_Digito Sub Al.Bx.Impbin.0Ah Int 21h Cmp Car_Lidos.'0' Mov Ah.1 Adc Dl.'0' Jmp Acerta_Num Tenta_Letra2: Cmp Al. Texto Loop_Leitura: Mov Ah.String[1] Cmp Al.Ax Ret Imp_Bin Endp Code_Seg Ends Data_Seg Segment Texto Label Byte Tam_String Db 3 Car_Lidos Db 0 String Db 3 Dup(' ') Dig_Hexa Db ? Data_Seg Ends Stack_Seg SEGMENT STACK db 10 Dup('Pilha ') Stack_Seg Ends End Hexa_Bin .8 Loop_ImpBin: Mov Dl.Ah Clc Jmp Fim_Valida Erro_Digito: Stc Jmp Fim_Valida Fim_Digitos: Clc Mov Dig_Hexa.'A'-10 Acerta_Num: Mov Cx.'0' Jb Erro_Digito Cmp Al.Dx Mov Ah.02 Mov Bl. Data_Seg Mov Ds.Dig_Hexa Mov Cx.Bx.'A' Jb Erro_Digito Cmp Al.'0' Int 21h Loop Loop_ImpBin Pop Dx.idem tecla.'9' Ja Tenta_Letra2 Sub Al.Al Segundo_Digito: Cmp Car_Lidos.4Ch Int 21h Hexa_Bin Endp Le_Texto Proc Near Push Ax.Cx Mov Al. Ax Loop_Texto: Call Le_Texto Call Conv_Maiuscula Call Valida_Texto Jc Loop_Texto Call Imp_Bin Mov Ah.'9' Ja Tenta_Letra Sub Al.Ax Ret Le_Texto Endp Conv_Maiuscula Proc Near .2 Jb Fim_Digitos Mov Al.Ax Ret Valida_Texto Endp Imp_Bin Proc Near Push Ax.Al Mov Dig_Hexa.Cl Or Ah. Ds:Data_Seg Hexa_Bin Proc Near Mov Ax.0 Rcl Bl.0 Je Loop_Leitura Pop Dx.String[0] Cmp Al.Al Fim_Valida: Pop Cx.'A' Jb Erro_Digito Cmp Al.Dx Lea Dx.Al Jmp Segundo_Digito Tenta_Letra: Cmp Al.4 Shl Ah.asm Code_Seg Segment Assume Cs:Code_Seg.'A'-10 Mov Ah.'0' Jb Erro_Digito Cmp Al.'F' Ja Erro_Digito Sub Al.Cx.Cx.

27 - . DIV E EXERCÍCIOS MUL (Multiply) ⇒ Multiplicação DIV (Divide) ⇒ Divisão Sintaxe: sem sinal Mul origem Sintaxe: sem sinal Div origem Lógica: Se (origem == byte) AX = origem * AL Se (origem == word) DX:AX = origem * AX Lógica: Se (origem == byte) AL = AX / origem AH = resto Se (origem == 27ord) AX = DX:AX / origem DX = resto Flags: O D I T S Z A P C ? ? ? ? ? ? Flags: O D I T S Z A P C * ? ? ? ? * Operações e Exemplos: Operando imediato reg8 reg16 mem8 mem16 Exemplo MUL 20 MUL CH MUL BX MUL VarByte MUL VarWord Operações e Exemplos: Operando imediato reg8 reg16 mem8 mem16 Exemplo DIV 16 DIV BL DIV BX DIV VarByte DIV VarWord 27 .MUL.

... CLD................................Observações: ⇒ Para números com sinal use as instruções IMUL e IDIV............................................................. STI.......11 INT........ Exercícios: 1) Faça uma rotina em Assembly que troque o valor do registrador AH com o valor do registrador BH utilizando apenas instruções lógicas: AND..13 DEC.21 S Scroll Window Up............... 2) Faça uma rotina em Assembly que retorne em AX o maior valor de uma região na memória........21 DIV..............3................ ÍNDICE ALFABÉTICO: A ADC.............. 0Ah..................24 D DB / DW...................22 CLC..................................27 DUP............asm.....4..................................25 CMP...............................16 E END.................................... 200..........25 RET............................21 28 ...................... Para cada algarismo lido deve ser mostrado o caracter * ao invés do próprio algarismo................12 INT 10h....12 R RCL......................15 Print String.............11 Exit........................................27 N NOT..24 JMP......................................................................... 06h................ 09h...........................................................12 MUL.........11 PUSH.. A região deverá ser referenciada pela variável Tabela (tipo byte) que terá um tamanho fixo de 256 bytes............... 3) Faça um programa completo em Assembly que leia 5 algarismos......12 PROC.......................................................... OR ou XOR.........17 INT 10h........................................... 4Ch...........................28 - ................21 INT 21h............................11 Set Cursor Position..................................................17 SEGMENT..................15 Rótulo........ JZ...24 H Hello.............................25 RCR..............20 JNE...............17 O OR.................................. Ao final da digitação o programa mostrará então quais foram os algarismos inseridos.....................................18 INT 10h....................................18 J JA............22 INT 21h.asm.......... STD..........19 P POP......25 SUB...........255...................................0......................................12 INT 21h...............4...........26 INC..........................21 LEA.................14 STC........ Você pode utilizar outros registradores para guardar valores intermediários..............18 INT 21h.................... CLI...................15 I Impbin..........15 Char Output........................11 LOOP..............18 SHL...........................20 B Buffer Input.................... JC.....................21 T Tecla..... 0Fh.11 ENDS..... 02h.........16 C CALL...................................17 INT 21h.........asm................................................................................20 JB.............14 Hello2.. JNBE...................... 08h..............................16 AND.........13 ENDP..asm............20 Console Input Without Echo.......................24 ADD..............17 STACK.............20 JE........ Tabela estará definida da seguinte forma: Tabela db 0........... .....................................13 L LABEL............24 ASSUME..12 M MOV...17 SHR....................................................... 02h......... Caso o usuário digite algo diferente de algarismos o programa deve emitir um “bell”.7....................................................................12 X XOR.....................................24 G Get Current Video Mode......23 Terminate a Process...................................... JNAE............. ⇒ Se o resultado da divisão não couber é gerada a interrupção de divisão por 0.................

29 . O Carlos é na verdade o criador dos programas exemplos e das estruturas das aulas. me indicou como seu substituto na função de professor e hoje é meu afilhado de casamento. Ele me convidou para ser seu monitor (função que exerci por dois anos).29 - .AGRADECIMENTOS: Gostaria de agradecer ao professor Carlos Fersura. que foi meu professor de Assembly no segundo período de 1993.