ARQUITETURA DE COMPUTADORES prof.

Alexandre de Oliveira
A FAMLIA DE MICROPROCESSADORES 8088/86/188/186/286 O microprocessador 8086 foi desenvolvido pela INTEL Corporation, firma que j havia sido responsvel pelo primeiro microprocessador , o 4004, e pelo processador de 8 bits mais difundido, o 8080. Caracterizado por: ter internamente registradores de 16 bits, ter um conjunto completo de instrues aritmticas de 16 bits, inclusive multiplicao e diviso e ter uma via de dados externa (de comunicao com memria e perifricos) tambm de 16 bits. Posteriormente a INTEL lanou o 8088, que idntico ao 8086 exceto pela via de dados externa que de 8 bits. O 8088 transforma os acessos a um WORD (nmero de 16 bits) em dois acessos a BYTEs (nmeros de 8 bits). Do ponto de vista de hardware, o 8088 permite uma forte simplificao, sem grande impacto no desempenho. 80188 / 80186 - incluem em uma nica pastilha o microprocessador e circuitos de apoio como controladores de DMA e interrupo 80286 - amplia a capacidade de endereamento, atravs da incorporao de um gerenciador de memria que fornece recursos de proteo de memria e memria virtual.

CONCEITOS BSICOS 2.1 COMO O 8088 ENDEREA MEMRIA O 8088 capaz de enderear at 1 Mbyte de memria (1024x1024 bytes), o que corresponde a 20 bits de endereo, embora os seus registradores se limitem a 16 bits. Para obter estes 20 bits os endereos so normalmente tratados como duas partes: o SEGMENTO e o DESLOCAMENTO ("offset"). O endereo final obtido multiplicando-se o segmento por 16 e somando-se o deslocamento, ignorando o "vai um" do bit mais significativo. Exemplo:

A mesma posio pode ser acessada atravs de: 0000H:0100H ou 0010H:000H ou FF00H:1100H (neste caso, o "vai um" do resultado ignorado).

O valor 1234H armazenado na posio de endereo "fsico" 300H da seguinte forma: 300H -> 34H 301H -> 12H

O valor de 32 bits 1234H:5678H armazenado em quatro bytes na seguinte ordem, do menos significativo para o mais: 78H, 56H, 34H, 12H

OS REGISTRADORES DO 8088 O 8086/8 possui um conjunto de 14 registradores internos, classificados em quatro categorias: de uso geral, de base e ndice, de segmento e de controle. Registradores de uso geral

Composta por 4 registradores de 16 bits, referenciados pelos nomes:

AX, BX, CX e DX.

Podem ser acessados como 8 registradores de 8 bits:

AH, AL, BH, BL, CH, CL, DH e DL. Os registradores "H" contm a parte mais significativa dos correspondentes "X" e os "L" a parte menos significativa.

Peculiaridades e usos mais comuns: AX - o "acumulador" usado nas instrues de entrada e sada, multiplicao, diviso, e manipulao de cadeia. De forma geral, as movimentaes entre registradores e memria e as instrues aritmticas e lgicas com operando imediato possuem variantes mais curtas (e rpidas) quando o registrador utilizado o acumulador. BX - o registrador de "base", usado para acesso indireto da memria, principalmente tabelas. CX - o "contador". Tem uso especial nas instrues repetitivas - "LOOP" e de manipulao de cadeias. DX - um registrador auxiliar. Tem uso especial nas operaes de entrada e sada e serve de "extenso" do acumulador nas instrues de multiplicao e diviso. Registradores de Base e ndice Normalmente utilizados para apontar dados. Ao contrrio dos de uso geral, no possvel acessar independentemente as partes mais e menos significativas destes registradores. Os registradores deste grupo so denominados:

SP - ("stack pointer") o ponteiro para a pilha do processador, indicando sempre o ltimo dado nela colocado. utilizado pelas instrues "PUSH", "POP", "CALL", "RET", "INT" e "IRET". BP - ("base pointer") utilizado normalmente como ponteiro para acessar dados armazenados na pilha. SI - ("source index") e DI - ("destination index") podem conter o deslocamento de uma posio de memria que se deseja acessar ou um valor ("ndice") a ser somado a um registrador base (BX ou BP) para se obter o deslocamento de uma posio de memria. Tem tambm uso especial nas instrues de manipulao de cadeias.

Registradores de Segmento Os deslocamentos so obtidos a partir das instrues, dos registradores de base e ndice (BX, BP, SP, SI e DI) ou de uma combinao destes elementos. Os segmentos so sempre obtidos de um dos quatro registradores de segmento:

CS - aponta para o segmento de cdigo, no qual so acessadas as instrues; SS - aponta para o segmento da pilha, utilizado pelas instrues PUSH / POP / CALL / RET / INT e IRET; DS - aponta para o segmento de dados, utilizado preferivelmente no acesso a dados na memria e ES - aponta para o segmento extra, que uma alternativa para o acesso a dados na memria e utilizado nas instrues de manipulao de cadeias.

Registradores de Controle Dois registradores:

IP - ponteiro de instrues que contm o deslocamento (em relao ao segmento de cdigo apontado por CS) da prxima instruo a executar. Este registrador no acessvel diretamente, sendo manipulado pelas instrues de desvio. "F" - este registrador ("flags") contm vrios bits que so utilizados pelo 8088 para indicar resultados ou controlar operaes:

Indicadores de resultado AF "vai um" auxiliar, utilizado em operaes sobre nmeros no formato "BCD compactado". CF "vai um" ("carry"), indica que o resultado de uma operao no coube na rea destinada. Usado tambm nas instrues de deslocamento e rotao. OF "overflow", indica que o resultado de uma operao aritmtica com sinal no coube na rea destinada. PF paridade, contm "1" quando o resultado da ltima operao continha um nmero par de "1"s. SF sinal, corresponde ao bit mais significativo do resultado da ltima operao. ZF zero, indica se o resultado da ltima operao foi zero. flags de controle DF controla as operaes de manipulao de cadeias, selecionando auto-incremento ("0") ou auto-decremento("1"). IF habilita ("1") ou desabilita ("0") interrupes externas TF quando em "1" coloca o processador no modo "passo a passo", usado para depurao.

Quando os flags so colocados na pilha (por uma instruo PUSHF ou uma interrupo) eles assumem a seguinte forma: bit 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Flag X X X X OF DF IF TF SF ZF X AF X PF X CF

INTRODUO AO PROGRAMA DEBUG

O Debug um programa includo no sistema operacional MS-DOS (e MS-WINDOWS) normalmente encontrado no diretrio C:\DOS, possibilitando que sejam criados e executados programas simples em Assembly 8086/8, alm de permitir a visualizao dos valores dos registradores internos do processador. Os principais comandos do Debug so: A(a): Montar (assembly) instrues simblicas em cdigo de mquina D(d): Mostrar (display) o contedo de uma rea da memria E(e): Entrar(enter) dados na memria, iniciando num endereo especfico G(g): Rodar (go) um programa executvel na memria N(n): Dar nome (name) a um programa Q(q): Sair (quit) do programa debug R(r): Mostrar (register)o contedo de um ou mais registradores T(t): Executar (trace)passo a passo as instrues U(u): Desmontar (unassembly) o cdigo de mquina em instrues simblicas W(w): Gravar (write) um programa em disco ? : Ajuda Registradores do processador 8086/88 (16 bits). O processador 8086/88 possui 4 (quatro) registradores internos de uso geral de 16 bits: AX, BX, CX e DX. Estes registradores podem tambm ser usados como registradores de 8 bits. Por exemplo: o registrador AX, subdividido em AH e AL, que so, respectivamente, o byte superior (high) e o inferior (low) do registrador AX. Esta nomenclatura tambm se aplica aos registradores BX, CX e DX. Estes registradores so tambm conhecidos pelos seguintes nomes: AX Registrador Acumulador BX Registrador Base CX Registrador Contador DX Registrador de Dados Os outros registradores so : DS Registrador de Segmento de Dados ES Registrador de Segmento Extra SS Registrador de Segmento de Pilha CS Registrador de Segmento de Cdigo BP Registrador Apontador da Base SI Registrador de ndice Fonte DI Registrador de ndice Destino SP Registrador Apontador de Pilha IP Registrador Apontador da Prxima Instruo F Registrador de Flag 3.3 Iniciar o uso do Debug. Para iniciar (ativar), basta digitar Debug na linha de comando, ou: C:/>temp\Debug [Enter] -

O programa ao ser ativado (iniciado) apresenta de um hfen - no canto inferior esquerdo da tela, correspondendo ao.prompt do programa. Para visualizar o contedo dos registradores, execute o comando r (register) : -r[Enter] AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000 DS=0D62 ES=0D62 SS=0D62 CS=0D62 IP=0100 NV UP EI PL NZ NA PO NC 0D62:0100 CF IRET mostrado o contedo de todos os registradores internos da CPU. Observe que todos os valores numricos que aparecem so na representados na base hexadecimal (base 16). Para visualizar um nico registrador usado o comando "r"seguido do parmetro que faz referncia ao nome do registrador. Exemplo: -rbx BX 0000 : Esta instruo mostrar o contedo do registrador BX e mudar o indicador do Debug de "-" para ":". Quando o prompt ficar deste modo :, possvel modificar o valor contido no registrador, bastando digitar o novo valor e pressionar [Enter]. Caso seja pressionado somente [Enter] o valor antigo ser mantido. 3.4 Estrutura dos programas em Assembly. Nas linhas do cdigo em Linguagem Assembly h duas partes: a primeira o nome da instruo a ser executada e a segunda so os parmetros do comando. A seguir so apresentados alguns exemplos, no para digitar no debug ainda, isto ser feito somente no item 3.5. a) add ah, bh (este apenas um exemplo no para digitar no debug ainda, o que ser feito no item 3.5) Na instruo acima "add" o comando a ser executado, neste caso a adio, "ah" e "bh" so os parmetros. b) mov al, 25 Neste exemplo, a instruo mov significa mover o valor 25 hexadecimal (base 16) para o registrador al. Observe que todos os valores numricos que aparecem nas instrues e endereos so representados na base hexadecimal (base 16). O nome das instrues na linguagem Assembly constitudo de 2, 3 ou 4 letras. Estas instrues so chamadas de mnemnicos ou cdigos de operao e representam as funes(operaes) que o processador pode executar. s vezes algumas instrues aparecem do seguinte modo : add al,[170] Os colchetes no segundo parmetro indicam que a instruo usa como operador o contedo da clula de memria de endereo 170, ou seja, com o valor contido no endereo 170 da memria e no com o valor 170 ("endereamento direto").

Exemplo de um programa simples em Assembly. Ser apresentado agora um exemplo de carter didtico para adicionar dois valores: O primeiro passo iniciar o Debug, o que j foi visto nos itens anteriores. Para montar (codificar em assembly) um programa no Debug, usado o comando "a" (assembly); quando usado este comando, pode-se especificar um endereo inicial para o programa como o parmetro, mas opcional. No caso de omisso, o endereo inicial o especificado pelos registradores CS:IP, geralmente 0100h, o local em que programas com extenso .COM devem iniciar. E ser este o local que ser sempre usado, uma vez que o Debug s pode criar este tipo de programa. Embora neste momento no seja necessrio dar um parmetro ao comando "a", isso recomendvel para evitar futuros problemas, logo: a 100[enter] mov ax,0002[enter] mov bx,0004[enter] add ax,bx[enter] nop[enter][enter] O que o programa faz? Move o valor 0002 para o registrador ax, move o valor 0004 para o registrador bx, adiciona o contedo dos registradores ax e bx, guardando o resultado em ax e finalmente a instruo nop (nenhuma operao) finaliza o programa. No programa debug, na tela aparecer : C:\>\temp\debug -a 100 0D62:0100 mov ax,0002 0D62:0103 mov bx,0004 0D62:0106 add ax,bx 0D62:0108 nop 0D62:0109 Utilize o comando "t"(trace) para executar passo a passo as instrues: -t AX=0002 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000 DS=0D62 ES=0D62 SS=0D62 CS=0D62 IP=0103 NV UP EI PL NZ NA PO NC 0D62:0103 BB0400 MOV BX,0004 Verifica-se o valor 0002 no registrador AX. Tecla-se "t" para executar a segunda instruo: -t AX=0002 BX=0004 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000 DS=0D62 ES=0D62 SS=0D62 CS=0D62 IP=0106 NV UP EI PL NZ NA PO NC 0D62:0106 01D8 ADD AX,BX Teclando-se "t" novamente para ver o resultado da instruo add: -t AX=0006 BX=0004 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000

DS=0D62 ES=0D62 SS=0D62 CS=0D62 IP=0108 NV UP EI PL NZ NA PE NC 0D62:0108 90 NOP possvel que os registradores contenham valores diferentes, mas AX e BX devem conter os mesmos valores apresentados acima. Para sair do Debug usado o comando "q" (quit). 3.6.Armazenar e carregar os programas. Para se evitar a digitao do programa cada vez que se inicia o Debug, .pode-se armazen-lo no disco. Para tal usado o comando de salvar (write) que cria um arquivo com a extenso .COM (executvel), sem a necessidade de se efetuar os processos de montagem e ligao (necessrios quando so usados os programas montadores como o Borland TASM (MS-DOS)e o GNU as (LINUX)). Os passos para salvar um programa que j esteja na memria so : 1) Obter o tamanho do programa subtraindo o endereo final do endereo inicial (no sistema hexadecimal). 2) Dar um nome ao programa. 3) Colocar o tamanho do programa no registrador CX. 4) Gravar o programa no disco. Usando como exemplo, o programa a seguir, observe os passos acima descritos: 0C1B:0100 mov ax,0002 0C1B:0103 mov bx,0004 0C1B:0106 add ax,bx 0C1B:0108 int 20 0C1B:010A Para se obter o tamanho de um programa usado o comando "h" (mostra a adio e a subtrao de dois nmeros em hexadecimal). O tamanho do programa em questo obtido fornecendo como parmetros o valor do endereo final do programa exemplo (10A), e o endereo inicial (100). O primeiro resultado mostra a soma dos endereos, o segundo, a subtrao. -h 10a 100 020a 000a O comando "n" (name) permite nomear o programa: -n test.com O comando "rcx" permite mudar o contedo do registrador CX para o valor obtido como tamanho do arquivo com o comando "h", neste caso 000a. -rcx CX 0000 :000a Finalmente, o comando "w" grava o programa no disco, indicando quantos bytes gravou. -w Writing 000A bytes Para carregar um arquivo j existente, dois passos so necessrios:

Dar o nome do arquivo a ser carregado. Carreg-lo usando o comando "l" (load). Supondo que o arquivo teste.com j exista, dentro do Debug, escrevemos o seguinte: -n test.com -l -u 100 109 0C3D:0100 B80200 MOV AX,0002 0C3D:0103 BB0400 MOV BX,0004 0C3D:0106 01D8 ADD AX,BX 0C3D:0108 CD20 INT 20 O ltimo comando "u" (unassembly) usado para verificar que o programa foi carregado na memria. O que ele faz desmontar o cdigo e mostr-lo em assembly. Os parmetros indicam ao Debug os endereos inicial e final a serem desmontados. O Debug sempre carrega os programas na memria no endereo 100h, conforme j foi mencionado.

O EXEMPLO DE PROGRAMAS COM O DEBUG

Nesta seo so apresentados alguns programas feitos no debug do MS-DOS. Para executar cada programa assembly pode-se usar o comando "g" (go) e verificar o que cada programa faz. Primeiro exemplo Procedimentos: 1) Passo 1 : iniciar o debug C:\>debug 2) Passo 2 :Dar nome ao programa -n ex1.com 3) Passo 3 :digitar o programa exemplo -a100 0D80:0100 MOV AX,0006 0D80:0103 MOV BX,0004 0D80:0106 ADD AX,BX 0D80:0108 INT 20 0D80:010a NOP [enter][enter] 4) Passo 4 : Desmontar o cdigo do endereo inicial ao final especificado e verificar a correo do programa. -u 100 10A 0D80:0100 B80600 0D80:0103 BB0400 0D80:0106 01D8 0D80:0108 CD20 MOV AX,0006 MOV BX,0004 ADD AX,BX INT 20

0D80:010a 90 ...... -

NOP

5) Passo 5: Obter o tamanho do programa subtraindo o endereo final do endereo inicial (no sistema hexadecimal) com o comando h.. -h 010a 0100 020a 000a 6) Passo 6 : Colocar o tamanho do programa no registrador CX (O comando "rcx" permite mudar o contedo do registrador CX para o valor obtido como tamanho do arquivo com o comando "h", neste caso 000a. -rcx CX 0000 :000a 7) Passo 7 : Gravar o programa nodisco com comando "w" (grava o programa no disco, indicando quantos bytes gravou). -w Writing 000A bytes 8) Passo 8: Executar o programa (digite o comando g): Por exemplo: -g = 100 10a Programa terminado normalmente 9) Passo 9:verificar os resultados com o comando r(register) examinando os registradores: AX=000a BX=0004 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000 DS=0D62 ES=0D62 SS=0D62 CS=0D62 IP=010a NV UP EI PL NZ NA PE NC 0D62:010A 90 NOP O mesmo exemplo comentado: -a0100 297D:0100 297D:0103 297D:0106 297D:0108 MOV AX,0006 ; Pe o valor 0006 no registrador AX MOV BX,0004 ; Pe o valor 0004 no registrador BX ADD AX,BX ; Adiciona BX ao contedo de AX INT 20 ; Finaliza o Programa

A nica coisa que este programa faz carregar os valores nos registradores AX e BX e adicion-los e colocar o resultado em AX, .finaliza o programa com a instruo INT 20. Outros exemplos de programas no Debug (comentados) Segundo exemplo

- a100 0C1B:0100 jmp 125 ;Salta para o endereo 125h 0C1B:0102 [Enter] - e 102 'Hello, How are you ?' 0d 0a '$' - a125 0C1B:0125 MOV DX,0102 ;Copia a string para registrador DX 0C1B:0128 MOV CX,000F ;Quantas vezes a string ser mostrada 0C1B:012B MOV AH,09 ;Copia o valor 09 para registrador AH 0C1B:012D INT 21 ;Mostra a string 0C1B:012F DEC CX ;Subtrai 1 de CX 0C1B:0130 JCXZ 0134 ;Se CX igual a 0 salta para o endereo 0134 0C1B:0132 JMP 012D ;Salta ao endereo 012D 0C1B:0134 INT 20 ;Finaliza o programa Este programa mostra 15 vezes na tela a string de caracteres. Terceiro exemplo -a100 297D:0100 297D:0102 297D:0105 297D:0107 MOV AH,01 MOV CX,0007 INT 10 INT 20 ;Funo para mudar o cursor ;Formata o cursor ;Chama interrupo do BIOS ;Finaliza o programa

Este programa muda o formato do cursor. Quarto exemplo -a100 297D:0100 297D:0102 297D:0104 297D:0106 297D:0108 297D:010A 297D:010C 297D:010E MOV INT CMP JNZ MOV MOV INT INT AH,01 21 AL,0D 0100 AH,02 DL,AL 21 20 ;Funo 1 (l caractere do teclado) ;Chama interrupo do DOS ;Compara se o caractere lido um ENTER ;Se no , l um outro caractere ;Funo 2 (escreve um caractere na tela) ;Character to write on AL ;Chama interrupo do DOS ;Finaliza o programa

Este programa usa a interrupo 21h do DOS. Usa duas funes da mesma: a primeira l um caractere do teclado (funo 1) e a segundo escreve um caractere na tela. O programa l caracteres do teclado at encontrar um ENTER. Quinto exemplo -a100 297D:0100 MOV AH,02 ;Funo 2 (escreve um caractere na tela) 297D:0102 MOV CX,0008 ;Pe o valor 0008 no registrador CX 297D:0105 MOV DL,00 ;Pe o valor 00 no registrador DL 297D:0107 RCL BL,1 ;Rotaciona o byte em BL um bit para a esquerda 297D:0109 ADC DL,30 ;Converte o registrador de flag para 1 297D:010C INT 21 ;Chama interrupo do DOS 297D:010E LOOP 0105 ;Salta se CX > 0 para o endereo 0105 297D:0110 INT 20 ;Finaliza o programa Este programa mostra na tela um nmero binrio atravs de um ciclo condicional (LOOP) usando a rotao do byte. Sexto exemplo

-a100 297D:0100 297D:0102 297D:0104 297D:0107 297D:010A 297D:010C 297D:010F 297D:0111

MOV MOV ADD CMP

AH,02 DL,BL DL,30 DL,3A

JL 010F ADD DL,07 INT 21 INT 20

; Funo 2 (escreve um caractere na tela) ; Pe o valor de BL em DL ; Adiciona o valor 30 a DL ; Compara o valor 3A com o contedo de DL sem afet-lo seu valor ; apenas modifica o estado do flag de carry ; salta ao endereo 010f, se for menor ; Adiciona o valor 07 a DL ; Chama interrupo do DOS ; Finaliza o programa

Este programa imprime um valor zero em dgitos hexadecimais. Stimo exemplo -a100 297D:0100 297D:0102 297D:0104 297D:0107 297D:010A 297D:010D 297D:010F 297D:0112 297D:0114 MOV AH,02 MOV DL,BL AND DL,0F ADD DL,30 CMP DL,3A JL 0112 ADD DL,07 INT 21 INT 20 ; Funo 2 (escreve um caractere na tela) ; Pe o valor de BL em DL ; Transporta fazendo AND dos nmeros bit a bit ; Adiciona 30 a Dl ; Compara Dl com 3A ; Salta ao endereo 0112, se menor ; Adiciona 07 a DL ; Chama interrupo do DOS ; Finaliza o programa

Este programa usado para imprimir dois dgitos hexadecimais. Oitavo exemplo -a100 297D:0100 297D:0102 297D:0104 297D:0106 297D:0108 297D:010B 297D:010E 297D:0110 297D:0113 297D:0115 MOV AH,02 ;Funo 2 (escreve um caractere na tela) MOV DL,BL ;Pe o valor de BL em DL MOV CL,04 ; Pe o valor 04 em CL SHR DL,CL ; Desloca os 4 bits mais altos do nmero ao nibble mais direita ADD DL,30 ;Adiciona 30 a DL CMP DL,3A ; Compara Dl com 3A JL 0113 ; Salta ao endereo 0113, se menor ADD DL,07 ; Adiciona 07 a DL INT 21 ; Chama interrupo do DOS INT 20 ; Finaliza o programa

Este programa imprime o primeiro de dois dgitos hexadecimais. Nono exemplo -a100 297D:0100 297D:0102 297D:0104 297D:0106 297D:0108 297D:010B 297D:010E 297D:0110 297D:0113 MOV AH,02 MOV DL,BL MOV CL,04 SHR DL,CL ADD DL,30 CMP DL,3A JL 0113 ADD DL,07 INT 21 ; Funo 2 (escreve um caractere na tela) ; Pe o valor de BL em DL ; Pe o valor 04 em CL ; Desloca os 4 bits mais altos do nmero ao nibble mais direita ; Adiciona 30 a DL ; Compara Dl com 3A ; Salta ao endereo 0113, se menor ; Adiciona 07 a DL ; Chama interrupo do DOS

297D:0115 297D:0117 297D:011A 297D:011D 297D:0120 297D:0122 297D:0125 297D:0127

MOV DL,BL AND DL,0F ADD DL,30 CMP DL,3A JL 0125 ADD DL,07 INT 21 INT 20

; Pe o valor de BL em DL ; Transporta fazendo AND dos nmeros bit a bit ; Adiciona 30 a DL ;Compara Dl com 3A ; Salta ao endereo 0125, se menor ; Adiciona 07 a DL ; Chama interrupo do DOS ; Finaliza o programa

Este programa imprime o segundo de dois dgitos hexadecimais. Dcimo exemplo -a100 297D:0100 MOV 297D:0102 INT 297D:0104 MOV 297D:0106 SUB 297D:0109 CMP 297D:010C JLE 297D:010E SUB 297D:0111 MOV 297D:0113 SHL 297D:0115 INT 297D:0117 SUB 297D:0119 CMP 297D:011B JLE 297D:011D SUB 297D:011F ADD 297D:0121 INT

AH,01 ; Funo 1 (l caractere do teclado) 21 ;Chama interrupo do DOS DL,AL ; Pe o valor de AL em DL DL,30 ; Subtrai 30 de DL DL,09 ; Compara DL com 09 0111 ; Salta ao endereo 0111, se menor ou igual DL,07 ; Subtrai 07 de DL CL,04 ; Pe o valor 04 em CL DL,CL ; Insere zeros direita 21 ; Chama interrupo do DOS AL,30 ; Subtrai 30 de AL AL,09 ; Compara AL com 09 011F ; Salta ao endereo 011f, se menor ou igual AL,07 ; Subtrai 07 de AL DL,AL ; Adiciona AL a DL 20 ; Finaliza o programa

Este programa pode ler dois dgitos hexadecimais. Dcimo primeiro exemplo -a100 297D:0100 CALL 0200 ; Chama um procedimento 297D:0103 INT 20 ; Finaliza o programa -a200 297D:0200 297D:0201 297D:0203 297D:0205 297D:0207 297D:0209 297D:020B 297D:020D 297D:020F 297D:0211 297D:0213 297D:0215 297D:0217 297D:0219 297D:021A 297D:021B 297D:021D 297D:021F PUSH DX ; Pe o valor de DX na pilha MOV AH,08 ; Funo 8 INT 21 ; Chama interrupo do DOS CMP AL,30 ; Compara AL com 30 JB 0203 ; Salta se CF ativado ao endereo 0203 CMP AL,46 ; Compara AL com 46 JA 0203 ; Salta ao endereo 0203, se diferente CMP AL,39 ; Compara AL com 39 JA 021B ; Salta para o endereo 021B, se diferente MOV AH,02 ; Funo 2 (escreve um caractere na tela) MOV DL,AL ; Pe o valor de AL em DL INT 21 ; Chama interrupo do DOS SUB AL,30 ; Subtrai 30 de AL POP DX ; Extrai o valor de DX da pilha RET ; Retorna o controle ao programa principal CMP AL,41 ; Compara AL com 41 JB 0203 ; Salta se CF ativado ao endereo 0203 MOV AH,02 ; Funo 2 (escreve um caractere na tela)

297D:022 297D:0223 297D:0225 297D:0227 297D:0228

MOV DL,AL INT 21 SUB AL,37 POP DX RET

; Pe o valor AL em DL ; Chama interrupo do DOS ; Subtrai 37 de AL ; Extrai o valor de DX da pilha ; Retorna o controle ao programa principal

Este programa se mantm lendo caracteres at receber um que possa ser convertido para um nmero hexadecimal.

DCIMO SEGUNDO EXEMPLO: PAGE ,132 TITLE TESTE.ASM .286P

CODE SEGMENT ASSUME CS:CODE,DS:CODE,ES:CODE ORG INICIO: JMP COMECO: MOV MOV MOV MOV MOV INT

100H
COMECO AX,CODE DS,AX ES,AX AH,09H

; CODE AREA ; DEFINE SEGMENTS ; DISPLAY MSG

DX,OFFSET MENS1 21H MOV AH,4CH INT 21H ; END PROG. ;=========================================================== ;AREA DE DADOS (DATA AREA) ;=========================================================== CAMPO DB 60 DUP (0) ; SOME DATA AREA DEFINED MENS1 DB "QUAL O SEU NOME? $" ; "WHAT IS YOUR NAME?" CODE END ENDS INICIO

COMPILE NORMALMENTE PARA .EXE

TASM TESTE TLINK TESTE TDEBUG TESTE.EXE

COMPILE PARA .COM TASM /LA TESTE TLINK /T TESTE DESCUBRA O MOTIVO DO ERRO: CANNOT GENERATE COM FILE : SEGMENT-RELOCATABLE ITEMS PRESENT CORRIJA, COMPILE E LINKEDIT. DESCUBRA A DIFERENA NO DEBUG ENTRE AS VERSES .EXE E .COM ;===========================================================

REFERNCIAS:
Este texto usou como ponto de partida um texto da Universidade de Guadalajara (Information Systems General Coordination.- Culture and Entertainment Web ; June 12th 1995). Copyright (C) 1995-1996, Hugo Perez Perez. Anyone may reproduce this document, in whole or in part, provided that: (1) any copy or republication of the entire document must show University of Guadalajara as the source, and must include this notice; and (2) any other use of this material must reference this manual and University of Guadalajara, and the fact that the material is copyright by Hugo Perez and is used by permission. (OBS: O texto completo foi traduzido para o Portugus por Jeferson Amaral (e-mail:amaral@inf.ufsm.br)). Adaptado pelo Prof. Alexandre de Oliveira (email: acmo@deinf.ufma.br), incluindo trechos do livro de Daniel Quadros, Programando em Assembly 8088.