assembler 1

Prévia do material em texto

file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 University of Guadalajara 
 Information Sistems General Coordination.
 Culture and Entertainment Web
 
 June 12th 1995
Copyright(C)1995-1996
*****************************************************************************
* Este tutorial foi traduzido para o Portuguˆs por Jeferson Amaral. *
* e-mail: amaral@inf.ufsm.br *
*****************************************************************************
 Este tutorial tem o intuito de apenas introduzir o leitor ao mundo
da programacao em Linguagem Assembly, nao tem, portanto e de forma alguma,
plano de esgotar o assunto.
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.
****************************************************************************
 T U T O R I A L D E L I N G U A G E M A S S E M B L Y
 --------------- --- ----------------- ---------------
 Conte£do:
 1.Introdu‡Æo 
 2.Conceitos B sicos
 3.Programa‡Æo Assembly 
 4.Instru‡äes Assembly
 5.Interrup‡äes e gerˆncia de arquivos
 6.Macros e procedimentos 
 7.Exemplos de programas
 8.Bibliografia
 
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (1 of 95)28/09/2004 17:10:34
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 
*****************************************************************************
 CAPÖTULO 1: INTRODU€ÇO
Conte£do:
1.1.O que h de novo neste material
1.2.Apresenta‡Æo
1.3.Por que aprender Assembly?
1.4.N¢s precisamos da sua opiniÆo
 --------------- // ---------------
1.1.O que h de novo neste material:
Ap¢s um ano da realiza‡Æo da primeira versÆo do tutorial, e atrav‚s das
opiniäes recebidas por e-mail, resolvemos ter por disposi‡Æo todos estes
coment rios e sugestäes. Esperamos que atrav‚s deste novo material Assembly,
as pessoas que se mostrarem interessadas possam aprender mais sobre o seu
IBM PC. Esta nova edi‡Æo do tutorial inclui:
Uma se‡Æo completa sobre como usar o programa debug.
Mais exemplos de programas.
Um motor de pesquisa, para qualquer t¢pico ou item relacionado … esta
nova versÆo.
Consider vel reorganiza‡Æo e revisÆo do material Assembly.
Em cada se‡Æo, h um link para o Dicion rio On-line de Computa‡Æo de
Dennis Howe.
1.2.Apresenta‡Æo:
Este tutorial destina-se …quelas pessoas que nunca tiveram contato com a
Linguagem Assembly.
O tutorial est completamente focado em computadores com processadores 80x86
da fam¡lia Intel, e considerando que a base da linguagem ‚ o funcionamento
dos recursos internos do processador, os exemplos descritos nÆo sÆo
compat¡veis com qualquer outra arquitetura.
As informa‡äes estÆo dispostas em unidades ordenadas para permitir f cil
acesso a cada t¢pico, bem como uma melhor navega‡Æo pelo tutorial.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (2 of 95)28/09/2004 17:10:34
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
Na se‡Æo introdut¢ria sÆo mencionados alguns conceitos elementares sobre
computadores e a Linguagem Assembly em si.
1.3.Por que aprender Assembly?
A primeira razÆo para se trabalhar com o assembler ‚ a oportunidade de
conhecer melhor o funcionamento do seu PC, o que permite o desenvolvimento
de programas de forma mais consistente.
A segunda razÆo ‚ que vocˆ pode ter um controle total sobre o PC ao fazer
uso do assembler.
Uma outra razÆo ‚ que programas assembly sÆo mais r pidos, menores e mais
poderosos do que os criados com outras linguagens.
Ultimamente, o assembler (montador) permite uma otimiza‡Æo ideal nos
programas, seja no seu tamanho ou execu‡Æo.
 
1.4.N¢s precisamos da sua opiniÆo:
Nosso intuito ‚ oferecer um modo simples para que vocˆ consiga aprender
Assembly por si mesmo. Por tanto, qualquer coment rio ou sugestÆo ser 
bem-vinda.
 
*****************************************************************************
 CAPÖTULO 2: CONCEITOS BµSICOS
 Conte£do:
 2.1.Descri‡Æo b sica de um sistema computacional.
 2.2.Conceitos b sicos da Linguagem Assembly
 2.3.Usando o programa debug
 --------------- // ---------------
 
Esta se‡Æo tem o prop¢sito de fazer um breve coment rio a respeito dos
principais componentes de um sistema computacional, o que ir permitir ao
usu rio uma melhor compreensÆo dos conceitos propostos no decorrer do
tutorial.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (3 of 95)28/09/2004 17:10:34
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 
2.1.DESCRIۂO DE UM SISTEMA COMPUTACIONAL
 
Conte£do:
2.1.1.Processador Central
2.1.2.Mem¢ria Principal
2.1.3.Unidades de Entrada e Sa¡da
2.1.4.Unidades de Mem¢ria Auxiliar
 
Sistema Computacional.
Chamamos de Sistema Computacional a completa configura‡Æo de um computador,
incluindo os perif‚ricos e o sistema operacional.
 
2.1.1.Processador Central.
• tamb‚m conhecido por CPU ou Unidade Central de Processamento, que por sua
vez ‚ composta pela unidade de controle e unidade de l¢gica e aritm‚tica.
Sua fun‡Æo consiste na leitura e escrita do conte£do das c‚lulas de mem¢ria,
regular o tr fego de dados entre as c‚lulas de mem¢ria e registradores
especiais, e decodificar e executar as instru‡äes de um programa.
O processador tem uma s‚rie de c‚lulas de mem¢ria usadas com freq•ˆncia e,
dessa forma, sÆo partes da CPU. Estas c‚lulas sÆo conhecidas com o nome de
registradores. Um processador de um PC possui cerca de 14 registradores.
Como os PCs tem sofrido evolu‡Æo veremos que podemos manipular registradores
de 16 ou 32 bits.
A unidade de l¢gica e aritm‚tica da CPU realiza as opera‡äes relacionadas ao
c lculo simb¢lico e num‚rico. Tipicamente estas unidades apenas sÆo capazes
de realizar opera‡äes elementares, tais como: adi‡Æo e subtra‡Æo de dois
n£meros inteiros, multiplica‡Æo e divisÆo de n£mero inteiro, manuseio de
bits de registradores e compara‡Æo do conte£do de dois registradores.
Computadores pessoais podem ser classificados pelo que ‚ conhecido como
tamanho da palavra, isto ‚, a quantidade de bits que o processador ‚ capaz
de manusear de uma s¢ vez.
 
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (4 of 95)28/09/2004 17:10:34
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
2.1.2.Mem¢ria Principal.
• um grupo de c‚lulas, agora sendo fabricada com semi-condutores, usada para
processamentos gerais, tais como a execu‡Æo de programas e o armazenamento
de informa‡äes para opera‡äes.
Cada uma das c‚lulas pode conter um valor num‚rico e ‚ capaz de ser
endere‡ada, isto ‚, pode ser identificada de forma singular em rela‡Æo …s
outras c‚lulas pelo uso de um n£mero ou endere‡o.
O nome gen‚rico destas mem¢rias ‚ Random Access Memory ou RAM. A principal
desvantagem deste tipo de mem¢ria ‚ o fato de que seus circuitosintegrados
perdem a informa‡Æo que armazenavam quando a energia el‚trica for
interrompida, ou seja, ela ‚ vol til. Este foi o motivo que levou … cria‡Æo
de um outro tipo de mem¢ria cuja informa‡Æo nÆo ‚ perdida quando o sistema ‚
desligado. Estas mem¢rias receberam o nome de Read Only Memory ou ROM.
2.1.3.Unidades de Entrada e Sa¡da.
Para que o computador possa ser £til para n¢s se faz necess rio que o
processador se comunique com o exterior atrav‚s de interfaces que permitem a
entrada e a sa¡da de informa‡Æo entre ele e a mem¢ria. Atrav‚s do uso destas
comunica‡äes ‚ poss¡vel introduzir informa‡Æo a ser processada e mais tarde
visualizar os dados processados.
Algumas das mais comuns unidades de entrada sÆo o teclado e o mouse. As mais
comuns unidades de sa¡da sÆo a tela do monitor e a impressora.
 
2.1.4.Unidades de Mem¢ria Auxiliar.
Considerando o alto custo da mem¢ria principal e tamb‚m o tamanho das
aplica‡äes atualmente, vemos que ela ‚ muito limitada. Logo, surgiu a
necessidade da cria‡Æo de dispositivos de armazenamento pr ticos e
econ“micos.
Estes e outros inconvenientes deram lugar …s unidades de mem¢ria auxiliar,
perif‚ricos. As mais comuns sÆo as fitas e os discos magn‚ticos.
A informa‡Æo ali armazenada ser dividida em arquivos. Um arquivo ‚ feito de
um n£mero vari vel de registros, geralmente de tamanho fixo, podendo conter
informa‡Æo ou programas.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (5 of 95)28/09/2004 17:10:34
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 --------------- // ---------------
 
2.2.CONCEITOS BµSICOS
Conte£do:
2.2.1.Informa‡äes nos computadores
2.2.2.M‚todos de representa‡Æo de dados
 
2.2.1.Informa‡Æo no computador:
 2.2.1.1.Unidades de informa‡Æo
 2.2.1.2.Sistemas num‚ricos
 2.2.1.3.Convertendo n£meros bin rios para decimais
 2.2.1.4.Convertendo n£meros decimais para bin rios
 2.2.1.5.Sistema hexadecimal
 
2.2.1.1.Unidades de informa‡Æo
Para o PC processar a informa‡Æo, ‚ necess rio que ela esteja em c‚lulas
especiais, chamadas registradores.
Os registradores sÆo grupos de 8 ou 16 flip-flops.
Um flip-flop ‚ um dispositivo capaz de armazenar 2 n¡veis de voltagem, um
baixo, geralmente 0.5 volts, e outro comumente de 5 volts. O n¡vel baixo de
energia no flip-flop ‚ interpretado como desligado ou 0, e o n¡vel alto,
como ligado ou 1. Estes estados sÆo geralmente conhecidos como bits, que sÆo
a menor unidade de informa‡Æo num computador.
Um grupo de 16 bits ‚ conhecido como palavra; uma palavra pode ser dividida
em grupos de 8 bits chamados bytes, e grupos de 4 bits chamados nibbles.
2.2.1.2.Sistemas num‚ricos
O sistema num‚rico que n¢s usamos diariamente ‚ o decimal, mas este sistema
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (6 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
nÆo ‚ conveniente para m quinas, pois ali as informa‡äes tˆm que ser
codificadas de modo a interpretar os estados da corrente (ligado-desligado);
este modo de c¢digo faz com que tenhamos que conhecer o c lculo posicional
que nos permitir expressar um n£mero em qualquer base onde precisarmos
dele.
• poss¡vel representar um determinado n£mero em qualquer base atrav‚s da
seguinte f¢rmula:
 
Onde n ‚ a posi‡Æo do d¡gito, iniciando da direita para a esquerda e
numerando de 0. D ‚ o d¡gito sobre o qual n¢s operamos e B ‚ a base num‚rica
usada.
 
2.2.1.3.Convertendo n£meros bin rios para decimais
Quando trabalhamos com a Linguagem Assembly encontramos por acaso a
necessidade de converter n£meros de um sistema bin rio, que ‚ usado em
computadores, para o sistema decimal usado pelas pessoas.
O sistema bin rio ‚ baseado em apenas duas condi‡äes ou estados, estar
ligado(1), ou desligado(0), portanto sua base ‚ dois.
Para a conversÆo, podemos usar a f¢rmula de valor posicional:
Por exemplo, se tivermos o n£mero bin rio 10011, tomamos cada d¡gito da
direita para a esquerda e o multiplicamos pela base, elevando … potˆncia
correspondente … sua posi‡Æo relativa:
Binary: 1 1 0 0 1
Decimal: 1*2^0 + 1*2^1 + 0*2^2 + 0*2^3 + 1*2^4
 = 1 + 2 + 0 + 0 + 16 = 19 decimal.
O caracter ^ ‚ usado em computa‡Æo como s¡mbolo para potˆncia e * para a
multiplica‡Æo.
2.2.1.4.Convertendo n£meros decimais para bin rio
H v rios m‚todos para se converter n£meros decimais para bin rio; apenas um
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (7 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
ser analizado aqui. Naturalmente a conversÆo com uma calculadora cient¡fica
‚ muito mais f cil, mas nem sempre podemos contar com isso, logo o mais
conveniente ‚, ao menos, sabermos uma f¢rmula para fazˆ-la.
O m‚todo resume-se na aplica‡Æo de divisäes sucessivas por 2, mantendo o
resto como o d¡gito bin rio e o resultado como o pr¢ximo n£mero a ser
dividido.
Tomemos como exemplo o n£mero decimal 43.
43/2=21 e o resto ‚ 1; 21/2=10 e o resto ‚ 1; 10/2=5 e o resto ‚ 0;
5/2=2 e o resto ‚ 1; 2/2=1 e o resto ‚ 0; 1/2=0 e o resto ‚ 1.
Para construir o equivalente bin rio de 43, vamos pegar os restos obtidos de
baixo para cima, assim temos 101011.
2.2.1.5.Sistema hexadecimal
Na base hexadecimal temos 16 d¡gitos, que vÆo de 0 a 9 e da letra A at‚ a F,
estas letras representam os n£meros de 10 a 15. Portanto contamos:
0,1,2,3,4,5,6,7,8,9,A,B,C,D,E, e F.
A conversÆo entre n£meros bin rios e hexadecimais ‚ f cil. A primeira coisa
a fazer ‚ dividir o n£mero bin rio em grupos de 4 bits, come‡ando da direita
para a esquerda. Se no grupo mais … direita sobrarem d¡gitos, completamos
com zeros.
Tomando como exemplo o n£mero bin rio 101011, vamos dividi-lo em grupos de 4
bits:
10;1011
Preenchendo o £ltimo grupo com zeros (o um mais … esquerda):
0010;1011
A seguir, tomamos cada grupo como um n£mero independente e consideramos o
seu valor decimal:
0010=2;1011=11
Entretanto, observa-se que nÆo podemos representar este n£mero como 211,
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (8 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
isto seria um erro, uma vez que os n£meros em hexa maiores que 9 e menores
que 16 sÆo representados pelas letras A,B,...,F. Logo, obtemos como
resultado:
2Bh, onde o "h" representa a base hexadecimal.
Para a conversÆo de um n£mero hexadecimal em bin rio ‚ apenas necess rio
inverter os passos: tomamos o primeiro d¡gito hexadecimal e o convertemos
para bin rio, a seguir o segundo, e assim por diante.
 
 --------------- // ---------------
2.2.2.M‚todos de representa‡Æo de dados num computador.
 2.2.2.1.C¢digo ASCII
 2.2.2.2.M‚todo BCD
 2.2.2.3.Representa‡Æo de ponto flutuante
 
2.2.2.1.C¢digo ASCII
ASCII significa American Standard Code for Information Interchange. Este
c¢digo cont‚m as letras do alfabeto, d¡gitos decimais de 0 a 9 e alguns
s¡mbolos adicionais como um n£mero bin rio de 7 bits, tendo o oitavo bit em
0, ou seja, desligado.
Deste modo, cada letra, d¡gito ou caracter especial ocupa 1 byte na mem¢ria
do computador.
Podemos observar que este m‚todo de representa‡Æo de dados ‚ muito
ineficiente no aspecto num‚rico, uma vez que no formato bin rio 1 byte nÆo ‚
suficiente para representar n£meros de 0 a 255, com oASCII podemos
representar apenas um d¡gito.
Devido a esta ineficiˆncia, o c¢digo ASCII ‚ usado, principalmente, para a
representa‡Æo de textos.
 
2.2.2.2.M‚todo BCD
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (9 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
BCD significa Binary Coded Decimal.
Neste m‚todo grupos de 4 bits sÆo usados para representar cada d¡gito
decimal de 0 a 9. Com este m‚todo podemos representar 2 d¡gitos por byte de
informa‡Æo.
Vemos que este m‚todo vem a ser muito mais pr tico para representa‡Æo
num‚rica do que o c¢digo ASCII. Embora ainda menos pr tico do que o bin rio,
com o m‚todo BCD podemos representar d¡gitos de 0 a 99. Com o bin rio, vemos
que o alcance ‚ maior, de 0 a 255.
Este formato (BCD) ‚ principalmente usado na representa‡Æo de n£meros
grandes, aplica‡äes comerciais, devido …s suas facilidades de opera‡Æo.
 
2.2.2.3.Representa‡Æo de ponto flutuante
Esta representa‡Æo ‚ baseada em nota‡Æo cient¡fica, isto ‚, representar um
n£mero em 2 partes: sua base e seu expoente.
Por exemplo o n£mero decimal 1234000, ‚ representado como 1.234*10^6,
observamos que o expoente ir indicar o n£mero de casas que o ponto decimal
deve ser movido para a direita, a fim de obtermos o n£mero original.
O expoente negativo, por outro lado, indica o n£mero de casas que o ponto
decimal deve se locomover para a esquerda.
 
 --------------- // ---------------
2.3.PROGRAMA DEBUG
 
Conte£do:
2.3.1.Processo de cria‡Æo de programas
2.3.2.Registradores da CPU
2.3.3.Programa debug
2.3.4.Estrutura Assembly
2.3.5.Criando um programa assembly simples
2.3.6.Armazenando e carregando os programas
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (10 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 
2.3.1.Processo de cria‡Æo de programas.
Para a cria‡Æo de programas sÆo necess rios os seguintes passos:
 * Desenvolvimento do algoritmo, est gio em que o problema a ser
 solucionado ‚ estabelecido e a melhor solu‡Æo ‚ proposta, cria‡Æo de
 diagramas esquem ticos relativos … melhor solu‡Æo proposta.
 * Codifica‡Æo do algoritmo, o que consiste em escrever o programa
 em alguma linguagem de programa‡Æo; linguagem assembly neste caso
 espec¡fico, tomando como base a solu‡Æo proposta no passo anterior.
 * A transforma‡Æo para a linguagem de m quina, ou seja, a cria‡Æo
 do programa objeto, escrito como uma seq•ˆncia de zeros e uns que podem
 ser interpretados pelo processador.
 * O £ltimo est gio ‚ a elimina‡Æo de erros detectados no programa
 na fase de teste. A corre‡Æo normalmente requer a repeti‡Æo de todos os
 passos, com observa‡Æo atenta.
 
2.3.2.Registradores da CPU.
Para o prop¢sito did tico, vamos focar registradores de 16 bits. A CPU
possui 4 registradores internos, cada um de 16 bits. SÆo eles AX, BX, CX e
DX. SÆo registradores de uso geral e tamb‚m podem ser usados como
registradores de 8 bits. Para tanto devemos referenci -los como, por
exemplo, AH e AL, que sÆo, respectivamente, o byte high e o low do
registrador AX. Esta nomenclatura tamb‚m se aplica para os registradores BX,
CX e DX.
Os registradores, segundo seus respectivos nomes:
 AX Registrador Acumulador
 BX Registrador Base
 CX Registrador Contador
 DX Registrador de Dados
 DS Registrador de Segmento de Dados
 ES Registrador de Segmento Extra
 SS Registrador de Segmento de Pilha
 CS Registrador de Segmento de C¢digo
 BP Registrador Apontador da Base
 SI Registrador de Öndice Fonte
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (11 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 DI Registrador de Öndice Destino
 SP Registrador Apontador de Pilha
 IP Registrador Apontador da Pr¢xima Instru‡Æo
 F Registrador de Flag
 
2.3.3.Programa Debug.
Para a cria‡Æo de um programa em assembler existem 2 op‡äes: usar o TASM -
Turbo Assembler da Borland, ou o DEBUGGER. Nesta primeira se‡Æo vamos usar o
debug, uma vez que podemos encontr -lo em qualquer PC com o MS-DOS.
Debug pode apenas criar arquivos com a extensÆo .COM, e por causa das
caracter¡sticas deste tipo de programa, eles nÆo podem exceder os 64 Kb, e
tamb‚m devem iniciar no endere‡o de mem¢ria 0100H dentro do segmento
espec¡fico. • importante observar isso, pois deste modo os programas .COM
nÆo sÆo reloc veis.
Os principais comandos do programa debug sÆo:
A Montar instru‡äes simb¢licas em c¢digo de m quina
D Mostrar o conte£do de uma rea da mem¢ria
E Entrar dados na mem¢ria, iniciando num endere‡o espec¡fico
G Rodar um programa execut vel na mem¢ria
N Dar nome a um programa
P Proceder, ou executar um conjunto de instru‡äes relacionadas
Q Sair do programa debug
R Mostrar o conte£do de um ou mais registradores
T Executar passo a passo as instru‡äes
U Desmontar o c¢digo de m quina em instru‡äes simb¢licas
W Gravar um programa em disco
• poss¡vel visualizar os valores dos registradores internos da CPU usando o
programa Debug. Debug ‚ um programa que faz parte do pacote do DOS, e pode
ser encontrado normalmente no diret¢rio C:\DOS. Para inici -lo, basta
digitar Debug na linha de comando:
C:/>Debug [Enter]
-
Vocˆ notar entÆo a presen‡a de um h¡fen no canto inferior esquerdo da tela.
NÆo se espante, este ‚ o prompt do programa. Para visualizar o conte£do dos
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (12 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
registradores, experimente:
-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 2E CS:
0D62:0101 803ED3DF00 CMP BYTE PTR [DFD3],00 CS:DFD3=03
• mostrado o conte£do de todos os registradores internos da CPU; um modo
alternativo para visualizar um £nico registrador ‚ usar o camando "r"
seguido do parƒmetro que faz referˆncia ao nome do registrador:
-rbx
BX 0000
:
Esta instru‡Æo mostrar o conte£do do registrador BX e mudar o indicador do
Debug de "-" para ":"
Quando o prompt assim se tornar, significa que ‚ poss¡vel, embora nÆo
obrigat¢ria, a mudan‡a do valor contido no registrador, bastando digitar o
novo valor e pressionar [Enter]. Se vocˆ simplesmente pressionar [Enter] o
valor antigo se mant‚m.
2.3.4.Estrutura Assembly.
Nas linhas do c¢digo em Linguagem Assembly h duas partes: a primeira ‚ o
nome da instru‡Æo a ser executada; a segunda, os parƒmetros do comando. Por
exemplo:
add ah bh
Aqui "add" ‚ o comando a ser executado, neste caso uma adi‡Æo, e "ah" bem
como "bh" sÆo os parƒmetros.
Por exemplo:
mov al, 25
No exemplo acima, estamos usando a instru‡Æo mov, que significa mover o
valor 25 para o registrador al.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (13 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
O nome das instru‡äes nesta linguagem ‚ constitu¡do de 2, 3 ou 4 letras.
Estas instru‡äes sÆo chamadas mnem“nicos ou c¢digos de opera‡Æo,
representando a fun‡Æo que o processador executar .
·s vezes instru‡äes aparecem assim:
add al,[170]
Os colchetes no segundo parƒmetro indica-nos que vamos trabalhar com o
conte£do da c‚lula de mem¢ria de n£mero 170, ou seja, com o valor contido no
endere‡o 170 da mem¢ria e nÆo com o valor 170, isto ‚ conhecido como
"endere‡amento direto".2.3.5.Criando um programa simples em assembly.
NÆo nos responsabilizaremos pela m execu‡Æo ou poss¡veis danos causados por
quaisquer exemplos que de agora em diante aparecerÆo, uma vez que os mesmos,
apesar de testados, sÆo de car ter did tico. Vamos, entÆo, criar um programa
para ilustrar o que vimos at‚ agora. Adicionaremos dois valores:
O primeiro passo ‚ iniciar o Debug, o que j vimos como fazer anteriormente.
Para montar um programa no Debug, ‚ usado o comando "a" (assemble); quando
usamos este comando, podemos especificar um endere‡o inicial para o nosso
programa como o parƒmetro, mas ‚ opcional. No caso de omissÆo, o endere‡o
inicial ‚ o especificado pelos registradores CS:IP, geralmente 0100h, o
local em que programas com extensÆo .COM devem iniciar. E ser este o local
que usaremos, uma vez que o Debug s¢ pode criar este tipo de programa.
Embora neste momento nÆo seja necess rio darmos um parƒmetro ao comando "a",
isso ‚ recomend vel para evitar 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 conte£do dos registradores ax e bx,
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (14 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
guardando o resultado em ax e finalmente a instru‡Æo nop (nenhuma opera‡Æo)
finaliza o programa.
No programa debug, a tela se parecer com:
C:\>debug
-a 100
0D62:0100 mov ax,0002
0D62:0103 mov bx,0004
0D62:0106 add ax,bx
0D62:0108 nop
0D62:0109
Entramos com o comando "t" para executar passo a passo as instru‡äes:
-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
Vemos o valor 0002 no registrador AX. Teclamos "t" para executar a segunda
instru‡Æo:
-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 "t" novamente para ver o resultado da instru‡Æo 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
A possibilidade dos registradores conterem valores diferentes existe, mas AX
e BX devem conter os mesmos valores acima descritos.
Para sair do Debug usamos o comando "q" (quit).
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (15 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 
2.3.6.Armazenando e carregando os programas.
NÆo seria pr tico ter que digitar o programa cada vez que inici ssemos o
Debug. Ao inv‚s disso, podemos armazen -lo no disco. S¢ que o mais
interessante nisso ‚ que um simples comando de salvar cria um arquivo com a
extensÆo .COM, ou seja, execut vel - sem precisarmos efetuar os processos de
montagem e liga‡Æo, como veremos posteriormente com o TASM.
Eis os passos para salvar um programa que j esteja na mem¢ria:
 * Obter o tamnho do programa subtraindo o endere‡o final do
 endere‡o inicial, naturalmente que no sistema hexadecimal.
 * Dar um nome ao programa.
 * Colocar o tamanho do programa no registrador CX.
 * Mandar o debug gravar o programa em disco.
Usando como exemplo o seguinte programa, vamos clarear a id‚ia de como
realizar 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 obter o tamanho de um programa, o comando "h" ‚ usado, j que ele nos
mostra a adi‡Æo e subtra‡Æo de dois n£meros em hexadecimal. Para obter o
tamanho do programa em questÆo, damos como parƒmetro o valor do endere‡o
final do nosso programa (10A), e o endere‡o inicial (100). O primeiro
resultado mostra-nos a soma dos endere‡os, o segundo, a subtra‡Æo.
-h 10a 100
020a 000a
O comando "n" permite-nos nomear o programa.
-n test.com
O comando "rcx" permite-nos mudar o conte£do do registrador CX para o valor
obtido como tamanho do arquivo com o comando "h", neste caso 000a.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (16 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
-rcx
CX 0000
:000a
Finalmente, o comando "w" grava nosso programa no disco, indicando quantos
bytes gravou.
-w
Writing 000A bytes
Para j salvar um arquivo quando carreg -lo, 2 passos sÆo necess rios:
 Dar o nome do arquivo a ser carregado.
 Carreg -lo usando o comando "l" (load).
Para obter o resultado correto destes passos, ‚ necess rio que o programa
acima j esteja criado.
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" ‚ usado para verificar que o programa foi carregado na
mem¢ria. O que ele faz ‚ desmontar o c¢digo e mostr -lo em assembly. Os
parƒmetros indicam ao Debug os endere‡os inicial e final a serem
desmontados.
O Debug sempre carrega os programas na mem¢ria no endere‡o 100h, conforme j 
comentamos.
*****************************************************************************
 CAPÖTULO 3: PROGRAMA€ÇO ASSEMBLY
 
Conte£do:
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (17 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
3.1.Construindo programas em Assembly
3.2.Processo Assembly
3.3.Pequenos programas em Assembly
3.4.Tipos de instru‡äes
 --------------- // ---------------
 
3.1.Construindo programas em Assembly.
3.1.1.Software necess rio
3.1.2.Programa‡Æo Assembly
 
3.1.1.SOFTWARE NECESSµRIO
Para que possamos criar um programa, precisamos de algumas ferramentas:
Primeiro de um editor para criar o programa fonte. Segundo de um montador,
um programa que ir transformar nosso fonte num programa objeto. E,
terceiro, de um linker (ligador) que ir gerar o programa execut vel a
partir do programa objeto.
O editor pode ser qualquer um que dispusermos. O montador ser o TASM macro
assembler da Borland, e o linker ser o TLINK, tamb‚m da Borland.
N¢s devemos criar os programas fonte com a extensÆo .ASM para que o TASM
reconhe‡a e o transforme no programa objeto, um "formato intermedi rio" do
programa, assim chamado porque ainda nÆo ‚ um programa execut vel e tÆo
pouco um programa fonte. O linker gera a partir de um programa .OBJ, ou da
combina‡Æo de v rios deles, um programa execut vel, cuja extensÆo ‚
normalmente .EXE, embora possa ser .COM dependendo da forma como for montado
e ligado.
 
3.1.2.PROGRAMAۂO ASSEMBLY
Para construirmos os programas com o TASM, devemos estruturar o fonte de
forma diferenciada ao que faz¡amos com o programa debug.
• importante incluir as seguintes diretivas assembly:
.MODEL SMALL
Define o melo de mem¢ria a usar em nosso programa
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (18 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
.CODE
Define as instru‡äes do programa, relacionado ao segmento de c¢digo
.STACK
Reserva espa‡o de mem¢ria para as instru‡äes de programa na pilha
END
Finaliza um programa assembly
Vamos programar
Primeiro passo
Use qualquer editor para criaro programa fonte. Entre com as seguintes
linhas:
Primeiro exemplo
; use ; para fazer coment rios em programas assembly
.MODEL SMALL ;modelo de mem¢ria
.STACK ;espa‡o de mem¢ria para instru‡äes do programa na pilha
.CODE ;as linhas seguintes sÆo instru‡äes do programa
 mov ah,01h ;move o valor 01h para o registrador ah
 mov cx,07h ;move o valor 07h para o registrador cx
 int 10h ;interrup‡Æo 10h
 mov ah,4ch ;move o valor 4ch para o registrador ah
 int 21h ;interrup‡Æo 21h
END ;finaliza o c¢digo do programa
Este programa assembly muda o tamanho do cursor.
Segundo passo
Salvar o arquivo com o seguinte nome: exam1.asm
NÆo esquecer de salv -lo no formato ASCII.
Terceiro passo
Usar o programa TASM para construir o programa objeto.
Exemplo:
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (19 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
C:\>tasm exam1.asm
Turbo Assembler Version 2.0 Copyright (c) 1988, 1990 Borland International
Assembling file: exam1.asm
Error messages: None
Warning messages: None
Passes: 1
Remaining memory: 471k
O TASM s¢ pode criar programas no formato .OBJ, que ainda nÆo pode ser
executado...
Quarto passo
Usar o programa TLINK para criar o programa execut vel.
Exemplo:
C:\>tlink exam1.obj
Turbo Link Version 3.0 Copyright (c) 1987, 1990 Borland International
C:\>
Onde exam1.obj ‚ o nome do programa intermedi rio, .OBJ. O comando acima
gera diretamente o arquivo com o nome do programa intermedi rio e a extensÆo
.EXE. • opcional a coloca‡Æo da extensÆo .obj no comando.
Quinto passo
Executar o programa execut vel criado.
C:\>exam1[enter]
Lembre-se, este programa assembly muda o tamanho do cursor no DOS.
 --------------- // ---------------
 
3.2.Processo Assembly.
3.2.1.Segmentos
3.2.2.Tabela de equivalˆncia
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (20 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 
3.2.1.SEGMENTOS
A arquitetura dos processadores x86 for‡a-nos a usar segmentos de mem¢ria
para gerenciar a informa‡Æo, o tamanho destes segmentos ‚ de 64Kb.
A razÆo de ser destes segmentos ‚ que, considerando que o tamanho m ximo de
um n£mero que o processador pode gerenciar ‚ dado por uma palavra de 16 bits
ou registrador, assim nÆo seria poss¡vel acessar mais do que 65536 locais da
mem¢ria usando apenas um destes registradores. Mas agora, se a mem¢ria do PC
‚ dividida em grupos de segmentos, cada um com 65536 locais, e podemos usar
um endere‡o ou registrador exclusivo para encontrar cada segmento, e ainda
fazemos cada endere‡o de um espec¡fico slot com dois registradores, nos ‚
poss¡vel acessar a quantidade de 4294967296 bytes de mem¢ria, que ‚,
atualmente, a maior mem¢ria que podemos instalar num PC.
Desta forma, para que o montador seja capaz de gerenciar os dados, se faz
necess rio que cada informa‡Æo ou instru‡Æo se encontre na rea
correspondente ao seu segmento. O endere‡o do segmento ‚ fornecido ao
montador pelos registradores DS, ES, SS e CS. Lembrando um programa no
Debug, observe:
1CB0:0102 MOV AX,BX
O primeiro n£mero 1CB0, corresponde ao segmento de mem¢ria que est sendo
usado, o segundo ‚ uma referˆncia ao endere‡o dentro do segmento, ‚ um
deslocamento dentro do segmento offset.
O modo usado para indicar ao montador com quais segmentos vamos trabalhar ‚
fazendo uso das diretivas .CODE, .DATA e .STACK.
O montador ajusta o tamanho dos segmentos tomando como base o n£mero de
bytes que cada instru‡Æo assembly precisa, j que seria um desperd¡cio de
mem¢ria usar segmentos inteiros. Por exemplo, se um programa precisa de
apenas 10Kb para armazenar dados, o segmento de dados seria apenas de 10Kb e
nÆo de 64Kb, como poderia acontecer se feito manualmente.
 
3.2.2.TABELAS DE EQUIVALÒNCIA
Cada uma das partes numa linha de c¢digo assembly ‚ conhecida como token,
por exemplo:
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (21 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
MOV AX,Var
Aqui temos trˆs tokens, a instru‡Æo MOV, o operador AX e o operador VAR. O
que o montador faz para gerar o c¢digo OBJ ‚ ler cada um dos tokens e
procurar a equivalˆncia em c¢digo de m quina em tabelas correspondentes,
seja de palavras reservadas, tabela de c¢digos de opera‡Æo, tabela de
s¡mbolos, tabela de literais, onde o significado dos mnem“nicos e os
endere‡os dos s¡mbolos que usamos serÆo encontrados.
A maioria dos montadores sÆo de duas passagens. Em s¡ntese na primeira
passagem temos a defini‡Æo dos s¡mbolos, ou seja, sÆo associados endere‡os a
todas as instru‡äes do programa. Seguindo este processo, o assembler lˆ MOV
e procura-o na tabela de c¢digos de opera‡Æo para encontrar seu equivalente
na linguagem de m quina. Da mesma forma ele lˆ AX e encontra-o na tabela
correspondente como sendo um registrador. O processo para Var ‚ um pouco
diferenciado, o montador verifica que ela nÆo ‚ uma palavra reservada, entÆo
procura na tabela de s¡mbolos, l encontrando-a ele designa o endere‡o
correspondente, mas se nÆo encontrou ele a insere na tabela para que ela
possa receber um endere‡o na segunda passagem. Ainda na primeira passagem ‚
executado parte do processamento das diretivas, ‚ importante notar que as
diretivas nÆo criam c¢digo objeto. Na passagem dois sÆo montadas as
instru‡äes, traduzindo os c¢digos de opera‡Æo e procurando os endere‡os, e ‚
gerado o c¢digo objeto.
H s¡mbolos que o montador nÆo consegue encontrar, uma vez que podem ser
declara‡äes externas. Neste caso o linker entra em a‡Æo para criar a
estrutura necess ria a fim de ligar as diversas poss¡veis partes de c¢digo,
dizendo ao loader que o segmento e o token em questÆo sÆo definidos quando o
programa ‚ carregado e antes de ser executado.
 --------------- // ---------------
 
3.3.Mais programas.
Outro exemplo
Primeiro passo
Use qualquer editor e crie o seguinte:
;exemplo2
.model small
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (22 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
.stack
.code
 mov ah,2h ;move o valor 2h para o registrador ah
 mov dl,2ah ;move o valor 2ah para o registrador dl
 ;(‚ o valor ASCII do caractere *)
 int 21h ;interrup‡Æo 21h
 mov ah,4ch ;fun‡Æo 4ch, sai para o sistema operacional
 int 21h ;interrup‡Æo 21h
end ;finaliza o programa
Segundo passo
Salvar o arquivo com o nome: exam2.asm
NÆo esquecer de salvar em formato ASCII.
Terceiro passo
Usar o programa TASM para construir o programa objeto.
C:\>tasm exam2.asm
Turbo Assembler Version 2.0 Copyright (c) 1988, 1990 Borland International
Assembling file: exam2.asm
Error messages: None
Warning messages: None
Passes: 1
Remaining memory: 471k
Quarto passo
Usar o programa TLINK para criar o programa execut vel.
C:\>tlink exam2.obj
Turbo Link Version 3.0 Copyright (c) 1987, 1990 Borland International
C:\>
Quinto passo
Executar o programa:
C:\>exam2[enter]
*
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (23 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
C:\>
Este programa imprime o caracter * na tela.
Clique aqui para obter mais programas
 --------------- // ---------------
 
3.4.Tipos de instru‡äes.
3.4.1.Movimentode dados
3.4.2.Opera‡äes l¢gicas e aritm‚ticas
3.4.3.Saltos, la‡os e procedimentos
 
3.4.1.MOVIMENTO DE DADOS
Em qualquer programa h necessidade de se mover dados na mem¢ria e em
registradores da CPU; h v rios modos de se fazˆ-lo: pode-se copiar os dados
da mem¢ria para algum registrador, de registrador para registrador, de um
registrador para a pilha, da pilha para um registrador, transmitir dados
para um dispositivo externo e vice-versa.
Este movimento de dados ‚ sujeito a regras e restri‡äes, entre elas:
*NÆo ‚ poss¡vel mover dados de um local da mem¢ria para outro diretamente; ‚
necess rio primeiro mover o dado do local de origem para um registrador e
entÆo do registrador para o local de destino.
*NÆo ‚ poss¡vel mover uma constante diretamente para um registrador de
segmento; primeiro deve-se mover para um registrador.
• poss¡vel mover blocos de dados atrav‚s de instru‡äes movs, que copia uma
cadeia de bytes ou palavras; movsb copia n bytes de um local para outro; e
movsw copia n palavras. A £ltima das duas instru‡äes toma os valores dos
endere‡os definidos por DS:SI como o grupo de dados a mover e ES:DI como a
nova localiza‡Æo dos dados.
Para mover dados h tamb‚m estruturas chamadas pilhas, onde o dado ‚
introduzido com a instru‡Æo push e ‚ extra¡do com a instru‡Æo pop
Numa pilha o primeiro dado a entrar ‚ o £ltimo a sair, por exemplo:
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (24 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 PUSH AX
 PUSH BX
 PUSH CX
Para retornar os valores da pilha referentes … cada registrador ‚ necess rio
seguir-se a ordem:
 POP CX
 POP BX
 POP AX
Para a comunica‡Æo com dispositivos externos o comando de sa¡da ‚ usado para
o envio de informa‡äes a uma porta e o comando de entrada ‚ usado para
receber informa‡Æo de uma porta.
A sintaxe do comando de sa¡da:
OUT DX,AX
Onde DX cont‚m o valor da porta que ser usada para a comunica‡Æo e AX
cont‚m a informa‡Æo que ser enviada.
A sintaxe do comando de entrada:
IN AX,DX
Onde AX ‚ o registrador onde a informa‡Æo ser armazenada e DX cont‚m o
endere‡o da porta de onde chegar a informa‡Æo.
 
3.4.2.OPERA€åES LàGICAS E ARITM•TICAS
As instru‡äes de opera‡äes l¢gicas sÆo: and, not, or e xor. Elas trabalham a
n¡vel de bits em seus operadores.
Para verificar o resultado das opera‡äes usamos as instru‡äes cmp e test.
As instru‡äes usadas para opera‡äes alg‚bricas sÆo: para adi‡Æo add, para
subtra‡Æo sub, para multiplica‡Æo mul e para divisÆo div.
Quase todas as instru‡äes de compara‡Æo sÆo baseadas na informa‡Æo contida
no registrador de flag. Normalmente os flags do registrador que podem ser
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (25 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
manuseados diretamente pelo programador sÆo os da dire‡Æo de dados DF, usado
para definir as opera‡äes sobre cadeias. Uma outro que pode tamb‚m ser
manuseado ‚ o flag IF atrav‚s das instru‡äes sti e cli, para ativar e
desativar as interrup‡äes.
 
3.4.3.SALTOS, LOOPS E PROCEDIMENTOS
Saltos incondicionais na escrita de programas em linguagem assembly sÆo
dados pela instru‡Æo jmp; um salto ‚ usado para modificar a seq•ˆncia da
execu‡Æo das instru‡äes de um programa, enviando o controle ao endere‡o
indicado, ou seja, o registrador contador de programa recebe este novo
endere‡o.
Um loop, tamb‚m conhecido como intera‡Æo, ‚ a repeti‡Æo de um processo um
certo n£mero de vezes at‚ atingir a condi‡Æo de parada.
*****************************************************************************
 CAPÖTULO 4: INSTRU€åES ASSEMBLY
Conte£do:
4.1.Instru‡äes de opera‡Æo de dados
4.2.Instru‡äes l¢gicas e aritm‚ticas
4.3.Instru‡äes de controle de processos
 --------------- // ---------------
 
4.1. Instru‡äes de opera‡Æo de dados
Conte£do:
4.1.1.Instru‡äes de transferˆncia
4.1.2.Instru‡äes de carga
4.1.3.Instru‡äes de pilha
 
4.1.1.Instru‡äes de transferˆncia.
SÆo usadas para mover o conte£do dos operadores. Cada instru‡Æo pode ser
usada com diferentes modos de endere‡amento.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (26 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 MOV
 MOVS (MOVSB) (MOVSW)
 
INSTRUۂO MOV
Prop¢sito: Transferˆncia de dados entre c‚lulas de mem¢ria, registradores e
o acumulador.
Sintaxe:
MOV Destino,Fonte
Destino ‚ o lugar para onde o dado ser movido e Fonte ‚ o lugar onde o dado
est .
Os diferentes movimentos de dados permitidos para esta instru‡Æo sÆo:
*Destino: mem¢ria. Fonte: acumulador
*Destino: acumulador. Fonte: mem¢ria
*Destino: registrador de segmento. Fonte: mem¢ria/registrador
*Destino: mem¢ria/regitrador. Fonte: registrador de segmento
*Destino: registrador. Fonte: registrador
*Destino: registrador. Fonte: mem¢ria
*Destino: mem¢ria. Fonte: registrador
*Destino: registrador. Fonte: dado imediato
*Destino: mem¢ria. Fonte: dado imediato
Exemplo:
 MOV AX,0006h
 MOV BX,AX
 MOV AX,4C00h
 INT 21h
Este pequeno programa move o valor 0006h para o registrador AX, entÆo ele
move o conte£do de AX (0006h) para o registrador BX, e finalmente move o
valor 4C00h para o registrador AX para terminar a execu‡Æo com a op‡Æo 4C da
interrup‡Æo 21h.
 
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (27 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
INSTRUیES MOVS (MOVSB) (MOVSW)
Prop¢sito: Mover byte ou cadeias de palavra da fonte, endere‡ada por SI,
para o destino endere‡ado por DI.
Sintaxe:
MOVS
Este comando nÆo necessita de parƒmetros uma vez que toma como endere‡o
fonte o conte£do do registrador SI e como destino o conte£do de DI. A
seguinte seq•ˆncia de instru‡äes ilustra isso:
MOV SI, OFFSET VAR1
MOV DI, OFFSET VAR2
MOVS
Primeiro inicializamos os valores de SI e DI com os endere‡os das vari veis
VAR1 e VAR2 respectivamente, entÆo ap¢s a execu‡Æo de MOVS o conte£do de
VAR1 ‚ copiado para VAR2.
As instru‡äes MOVSB e MOVSW sÆo usadas do mesmo modo que MOVS, a primeira
move um byte e a segunda move uma palavra.
 
Instru‡äes de carga.
SÆo instru‡äes espec¡ficas para registradores, usadas para carregar bytes ou
cadeias de bytes num registrador.
 LODS (LODSB) (LODSW)
 LAHF
 LDS
 LEA
 LES
 
 INSTRUیES LODS (LODSB) (LODSW)
Prop¢sito: Carregar cadeias de um byte ou uma palavra para o acumulador.
Sintaxe:
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (28 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
LODS
Esta instru‡Æo toma a cadeia encontrada no endere‡o especificado por SI, a
carrega para o registrador AL (ou AX) e adiciona ou subtrai, dependendo do
estado de DF, para SI se ‚ uma transferˆncia de bytes ou de palavras.
MOV SI, OFFSET VAR1
LODS
Na primeira linha vemos a carga do endere‡o de VAR1 em SI e na segunda ‚
tomado o conte£do daquele local para o regiustrador AL.
Os comandos LODSB e LODSW sÆo usados do mesmo modo, o primeiro carrega um
byte e o segundo uma palavra (usa todo o registrador AX).
 
 INSTRUۂO LAHF
Prop¢sito: Transferiro conte£do dos flags para o registrador AH.
Sintaxe:
LAHF
Esta instru‡Æo ‚ £til para verificar o estado dos flags durante a execu‡Æo
do nosso programa.
Os flags sÆo deixados na seguinte ordem dentro do registrador:
SF ZF ?? AF ?? PF ?? CF
O "??" significa que haver um valor indefinido naqueles bits.
 
 INSTRUۂO LDS
Prop¢sito: Carregar o registrador de segmento de dados.
Sintaxe:
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (29 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
LDS destino,fonte
O operador fonte deve ser uma double word na mem¢ria. A palavra associada
com o maior endere‡o ‚ transferida para DS, em outras palavras isto ‚ tomado
como o endere‡o de segmento. A palavra associada com o menor endere‡o ‚ o
endere‡o de deslocamento e ‚ depositada no registrador indicado como
destino.
 
 INSTRUۂO LEA
Prop¢sito: Carregar o endere‡o do operador fonte.
Sintaxe:
LEA destino,fonte
O operador fonte deve estar localizado na mem¢ria, e seu deslocamento ‚
colocado no registrador de ¡ndice ou ponteiro especificado no destino.
Para ilustrar uma das facilidades que temos com este comando, vejamos:
MOV SI,OFFSET VAR1
• equivalente a:
LEA SI,VAR1
• muito prov vel que para o programador ‚ muito mais f cil criar programas
grandes usando este £ltimo formato.
 
 INSTRUۂO LES
Prop¢sito: Carregar o registrador de segmento extra
Sintaxe:
LES destino,fonte
O operador fonte deve ser uma palavra dupla na mem¢ria. O conte£do da
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (30 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
palavra com endere‡o maior ‚ interpretado como o endere‡o do segmento e ‚
colocado em ES. A palavra com endere‡o menor ‚ o endere‡o do deslocamento e
‚ colocada no registrador especificado no parƒmetro de destino.
 
 Instru‡äes de manipula‡Æo da pilha.
Estas instru‡äes permitem usar a pilha para armazenar ou recuperar dados.
 POP
 POPF
 PUSH
 PUSHF
 
 INSTRUۂO POP
Prop¢sito: Recuperar uma parte de informa‡Æo da pilha.
Sintaxe:
POP destino
Esta instru‡Æo transfere o £ltimo valor armazenado na pilha para o operador
de destino, e incrementa de 2 o registrador SP.
Este incremento ‚ duplo pelo fato de que a pilha do mais alto endere‡o de
mem¢ria para o mais baixo, e a pilha trabalha apenas com palavras, 2 bytes,
logo deve ser 2 o incremento de SP, na realidade 2 est sendo subtra¡do do
tamanho real da pilha.
 
 INSTRUۂO POPF
Prop¢sito: Extrair os flags armazenados na pilha.
Sintaxe:
POPF
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (31 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
Este comando transfere os bits da palavra armazenada na parte mais alta da
pilha para registrador de flag.
O modo da transferˆncia ‚ como se segue:
BIT FLAG
 0 CF
 2 PF
 4 AF
 6 ZF
 7 SF
 8 TF
 9 IF
 10 DF
 11 OF
Os locais dos bits sÆo os mesmos para o uso da instru‡Æo PUSHF.
Uma vez feita a transferˆncia o registrador SP ‚ incrementado de 2, conforme
vimos anteriormente.
 
 INSTRUۂO PUSH
Prop¢sito: Coloca uma palavra na pilha.
Sintaxe:
PUSH fonte
A instru‡Æo PUSH decrementa de dois o valor de SP e entÆo transfere o
conte£do do operador fonte para o novo endere‡o desultante no registrador
rec‚m modificado.
O decremento no endere‡o ‚ duplo pelo fato de que quando os valores sÆo
adicionados … pilha, que cresce do maior para o menor endere‡o, logo quando
subra¡mos de 2 o registrador SP o que fazemos ‚ incrementar o tamanho da
pilha em dois bytes, que ‚ a £nica quantidade de informa‡Æo que a pilha pode
manusear em cada entrada e sa¡da.
 
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (32 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 INSTRUۂO PUSHF
Prop¢sito: Colocar os valores dos flags na pilha.
Sintaxe:
PUSHF
Este comando decrementa de 2 o valor do registrador SP e entÆo o conte£do do
registrador de flag ‚ transferido para a pilha, no endere‡o indicado por SP.
Os flags sÆo armazenados na mem¢ria da mesma forma que o comando POPF.
 --------------- // ---------------
 
4.2. Instru‡äes l¢gicas e aritm‚ticas
Conte£do:
4.2.1.Instru‡äes l¢gicas
4.2.2.Instru‡äes aritm‚ticas
 
4.2.1.Instru‡äes l¢gicas
SÆo usadas para realizar opera‡äes l¢gicas nos operadores.
 AND
 NEG
 NOT
 OR
 TEST
 XOR
 
INSTRUۂO AND
Prop¢sito: Realiza a conjun‡Æo de operadores bit a bit.
Sintaxe:
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (33 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
AND destino,fonte
Com esta instru‡Æo a opera‡Æo l¢gica "y" para ambos os operadores ‚ usada
como na tabela:
Fonte Destino | Destino
-----------------------------
 1 1 | 1
 1 0 | 0
 0 1 | 0
 0 0 | 0
O resultado desta opera‡Æo ‚ armazenado no operador de destino.
 
INSTRUۂO NEG
Prop¢sito: Gera o complemento de 2.
Sintaxe:
NEG destino
Esta instru‡Æo gera o complemento de 2 do operador destino e o armazena no
mesmo operador. Por exemplo, if AX armazena o valor 1234H, entÆo:
NEG AX
Isto far com o que o valor EDCCH fque armazenado no registrador AX.
 
 INSTRUۂO NOT
Prop¢sito: Faz a nega‡Æo do operador de destino bit a bit.
Sintaxe:
NOT destino
O resultado ‚ armazenado no mesmo operador de destino.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (34 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 
 INSTRUۂO OR
Prop¢sito: Realiza um OU l¢gico.
Sintaxe:
OR destino,fonte
A instru‡Æo OR, faz uma disjun‡Æo l¢gica bit a bit dos dois operadores:
Fonte Destino | Destino
-----------------------------------
 1 1 | 1
 1 0 | 1
 0 1 | 1
 0 0 | 0
 
 INSTRUۂO TEST
Prop¢sito: Compara logicamente os operadores.
Sintaxe:
TEST destino,fonte
Realiza uma conjun‡Æo, bit a bit, dos operadores, mas difere da instru‡Æo
AND, uma vez que nÆo coloca o resultado no operador de destino. Tem efeito
sobre o registrador de flag.
 
 INSTRUۂO XOR
Prop¢sito: Realiza um OU exclusivo.
Sintaxe:
XOR destino,fonte
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (35 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
Esta instru‡Æo realizxa uma disjun‡Æo exclusiva de dois operadores bit a
bit.
Fonte Destino | Destino
-----------------------------------
 1 1 | 0
 0 0 | 1
 0 1 | 1
 0 0 | 0
 
4.2.2.Instru‡äes aritm‚ticas.
SÆo usadas para realizar opera‡äes aritm‚ticas nos operadores.
 ADCADD
 DIV
 IDIV
 MUL
 IMUL
 SBB
 SUB
 
INSTRUۂO ADC
Prop¢sito: Efetuar a soma entre dois operandos com carry.
Sintaxe:
ADC destino,fonte
Esta instru‡Æo efetua a soma entre dois operandos, mais o valor do flag CF,
existente antes da opera‡Æo. Apenas o operando destino e os flags sÆo
afetados.
O resultado ‚ armazenado no operador de destino.
 
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (36 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 INSTRUۂO ADD
Prop¢sito: Adi‡Æo de dois operadores.
Sintaxe:
ADD destino,fonte
Esta instru‡Æo adiciona dois operadores e armazena o resultado no operador
destino.
 
 INSTRUۂO DIV
Prop¢sito: DivisÆo sem sinal.
Sintaxe:
DIV fonte
O divisor pode ser um byte ou uma palavra e ‚ o operador que ‚ dado na
instru‡Æo.
Se o divisor ‚ de 8 bits, o registrador AX de 16 bits ‚ tomado como
dividendo e se o divisor ‚ de 16 bits, o par de registradores DX:AX ser 
tomado como dividendo, tomando a palavra alta de DX e a baixa de AX.
Se o divisor for um byte, entÆo o quociente ser armazenado no registrador
AL e o resto em AH. Se for uma palavra, entÆo o quociente ‚ armazenado em AX
e o resto em DX.
 
 INSTRUۂO IDIV
Prop¢sito: DivisÆo com sinal.
Sintaxe:
IDIV fonte
Consiste basicamente como a instru‡Æo DIV, diferencia-se apenas por realizar
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (37 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
a opera‡Æo com sinal.
Para os resultados sÆo usados os mesmos registradores da instru‡Æo DIV.
 
 INSTRUۂO MUL
Prop¢sito: Multiplica‡Æo com sinal.
Sintaxe:
MUL fonte
Esta instru‡Æo realiza uma multiplica‡Æo nÆo sinalizada entre o conte£do do
acumulador AL ou AX pelo operando-fonte, devolvendo o resultado no
acumulador AX caso a opera‡Æo tenha envolvido AL com um operando de 8 bits,
ou em DX e AX caso a opera‡Æo tenha envolvido AX e um operando de 16 bits.
 
 INSTRUۂO IMUL
Prop¢sito: Multiplic‡Æo de dois n£meros inteiros com sinal.
Sintaxe:
IMUL fonte
Esta instru‡Æo faz o mesmo que a anterior, difere apenas pela inclusÆo do
sinal.
Os resultados sÆo mantidos nos mesmos registradores usados pela instru‡Æo
MUL.
 
 INSTRUۂO SBB
Prop¢sito: Subtra‡Æo com carry.
Sintaxe:
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (38 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
SBB destino,fonte
Esta instru‡Æo subtrai os operadores e subtrai um do resultado se CF est 
ativado. O operador fonte ‚ sempre subtra¡do do destino.
Este tipo de subtra‡Æo ‚ usado quando se trabalha com quantidades de 32
bits.
 
 INSTRUۂO SUB
Prop¢sito: Subtra‡Æo.
Sintaxe:
SUB destino,fonte
Esta instru‡Æo subtrai o operador fonte do destino.
 
 --------------- // ---------------
4.3.Instru‡äes de controle de processos
 
Conte£do:
4.3.1.Instru‡äes de salto
4.3.2.Instru‡äes de la‡os: loop
4.3.3.Instru‡äes de contagem
4.3.4.Instru‡äes de compara‡Æo
4.3.5.Instru‡äes de flag
 
4.3.1.Instru‡äes de salto.
Usadas para transferir o processo de execu‡Æo do programa para o operador
indicado.
 JMP
 JA (JNBE)
 JAE (JNBE)
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (39 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 JB (JNAE)
 JBE (JNA)
 JE (JZ)
 JNE (JNZ)
 JG (JNLE)
 JGE (JNL)
 JL (JNGE)
 JLE (JNG)
 JC
 JNC
 JNO
 JNP (JPO)
 JNS
 JO
 JP (JPE)
 JS
 
 INSTRUۂO JMP
Prop¢sito: Salto incondicional.
Sintaxe:
JMP destino
Esta instru‡Æo ‚ usada par adesviar o curso do programa sem tomar em conta
as condi‡äes atuais dos flags ou dos dados.
 
 INSTRUۂO JA (JNBE)
Prop¢sito: Salto condicional.
Sintaxe:
JA s¡mbolo
Ap¢s uma compara‡Æo este comando salta se nÆo ‚ igual.
Isto quer dizer que o salto s¢ ‚ feito se o flag CF ou o flag ZF estÆo
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (40 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
desativados, ou seja, se um dos dois for zero.
 
 INSTRUۂO JAE (JNB)
Prop¢sito: Salto condicional.
Sintaxe:
JAE s¡mbolo
A instru‡Æo salta se est up, se est equal ou se est not down.
O salto ‚ feito se CF est desativado.
 
 INSTRUۂO JB (JNAE)
Prop¢sito: Salto condicional.
Sintaxe:
JB s¡mbolo
A instru‡Æo salta se est down, se est not up ou se est equal.
O salto ‚ feito se CF est ativado.
 
 INSTRUۂO JBE (JNA)
Prop¢sito: Salto condicional.
Sintaxe:
JBE s¡mbolo
A instru‡Æo salta se est down, se est equal ou se est not up.
O salto ‚ feito se CF ou ZF estÆo ativados, ou seja, se um deles for 1.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (41 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 
 INSTRUۂO JE (JZ)
Prop¢sito: Salto condicional.
Sintaxe:
JE s¡mbolo
A instru‡Æo salta se est equal ou se est zero.
O salto ‚ feito se ZF est ativado.
 
 INSTRUۂO JNE (JNZ)
Prop¢sito: Salto condicional.
Sintaxe:
JNE s¡mbolo
A instru‡Æo salta se est not equal ou se est zero.
O salto ‚ feito se ZF est desativado.
 
 INSTRUۂO JG (JNLE)
Prop¢sito: Salto condicional, e o sinal ‚ tomado.
Sintaxe:
JG s¡mbolo
A instru‡Æo salta se est larger, se est not larger ou se est equal.
O salto ocorre se ZF = 0 ou se OF = SF.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (42 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 
 INSTRUۂO JGE (JNL)
Prop¢sito: Salto condicional, e o sinal ‚ tomado.
Sintaxe:
JGE s¡mbolo
A instru‡Æo salta se est larger, se est less than ou se est equal.
O salto ‚ feito se SF = OF.
 
 INSTRUۂO JL (JNGE)
Prop¢sito: Salto condicional, e o sinal ‚ tomado.
Sintaxe:
JL s¡mbolo
A instru‡Æo salta se est less than, se est not larger than ou se est 
equal.
O salto ‚ feito se SF ‚ diferente de OF.
 
 INSTRUۂO JLE (JNG)
Prop¢sito: Salto condicional, e o sinal ‚ tomado.
Sintaxe:
JLE s¡mbolo
A instru‡Æo salta se est less than, se est equal ou se est not larger.
O salto ‚ feito se ZF = 1 ou se SF ‚ diferente de OF.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (43 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 
 INSTRUۂO JC
Prop¢sito: Salto condicional, e os flags sÆo tomados.
Sintaxe:
JC s¡mbolo
A instru‡Æo salta se h carry.
O salto ‚ feito se CF = 1.
 
 INSTRUۂO JNC
Prop¢sito: Salto condicional, e o estado dos flags ‚ tomado.
Sintaxe:
JNC s¡mbolo
A instru‡Æosalta se nÆo h carry.
O salto ‚ feito se CF = 0.
 
 INSTRUۂO JNO
Prop¢sito: Salto condicional, e o estado dos flags ‚ tomado.
Sintaxe:
JNO s¡mbolo
A instru‡Æo salta se nÆo h overflow
O salto ‚ feito se OF = 0.
 
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (44 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 INSTRUۂO JNP (JPO)
Prop¢sito: Salto condicional, e o estado dos flags ‚ tomado.
Sintaxe:
JNP s¡mbolo
A instru‡Æo salta se nÆo h paridade ou se a paridade ‚ ¡mpar.
O salto ‚ feito se PF = 0.
 
 INSTRUۂO JNS
Prop¢sito: Salto condicional, e o estado dos flags ‚ tomado.
Sintaxe:
JNP s¡mbolo
A instru‡Æo salta se o sinal est desativado.
O salto ‚ feito se SF = 0.
 
 INSTRUۂO JO
Prop¢sito: Salto condicional, e o estado dos flags ‚ tomado.
Sintaxe:
JO s¡mbolo
A instru‡Æo salta se h overflow.
O salto ‚ feito se OF = 1.
 
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (45 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 INSTRUۂO JP (JPE)
Prop¢sito: Salto condicional, e o estado dos flags ‚ tomado.
Sintaxe:
JP s¡mbolo
A instru‡Æo salta se h paridade ou se a paridade ‚ par.
O salto ‚ feito se PF = 1.
 
 INSTRUۂO JS
Prop¢sito: Salto condicional, e o estado dos flags ‚ tomado.
Sintaxe:
JS s¡mbolo
A instru‡Æo salta se o sinal est ativado.
O salto ‚ feito se SF =1.
 --------------- // ---------------
 
4.3.2.Instru‡äes para la‡os: LOOP.
Estas instru‡äes transferem a execu‡Æo do processo, condicional ou
incondicionalmente, para um destino, repetindo a a‡Æo at‚ o contador ser
zero.
 LOOP
 LOOPE
 LOOPNE
 
 INSTRUۂO LOOP
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (46 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
Prop¢sito: Gerar um la‡o no programa.
Sintaxe:
LOOP s¡mbolo
A instru‡Æo LOOP decrementa CX de 1 e transfere a execu‡Æo do programa para
o s¡mbolo que ‚ dado como operador, caso CX ainda nÆo seja 1.
 
 INSTRUۂO LOOPE
Prop¢sito: Gerar um la‡o no programa, considerando o estado de ZF.
Sintaxe:
LOOPE s¡mbolo
Esta instru‡Æo decrementa CX de 1. Se CX ‚ diferente de zero e ZF ‚ igual a
1, entÆo a execu‡Æo do programa ‚ transferida para o s¡mbolo indicado como
operador.
 
 INSTRUۂO LOOPNE
Prop¢sito: Gerar um la‡o no programa, considerando o estado de ZF.
Sintaxe:
LOOPNE s¡mbolo
Esta instru‡Æo decrementa CX de 1 e transfere a execu‡Æo do programa apenas
se ZF ‚ diferente de 0.
 
 --------------- // ---------------
4.3.3.Instru‡äes contadoras.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (47 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
Estas instru‡äes sÆo usadas para decrementar ou incrementar o conte£do de
contadores.
 DEC
 INC
 
 DEC INSTRUCTION
Prop¢sito: Decrementar o operador.
Sintaxe:
DEC destino
Esta instru‡Æo subtrai 1 do operador destino e armazena o novo valor no
mesmo operador.
 
 INSTRUۂO INC
Prop¢sito: Incrementar o operador.
Sintaxe:
INC destino
Esta instru‡Æo adiciona 1 ao operador destino e mant‚m o resultado no mesmo
operador.
 --------------- // ---------------
 
4.3.4.Instru‡äes de compara‡Æo.
Estas instru‡äes sÆo usadas para comparar os operadores, e elas afetam o
conte£do dos flags.
 CMP
 CMPS (CMPSB) (CMPSW)
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (48 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 
 INSTRUۂO CMP
Prop¢sito: Comparar os operadores.
Sintaxe:
CMP destino,fonte
Esta instru‡Æo subtrai o operador fonte do destino, mas nÆo armazena o
resultado da opera‡Æo, apenas afeta o estado dos flags.
 
 INSTRUۂO CMPS (CMPSB) (CMPSW)
Prop¢sito: Comparar cadeias de um byte ou uma palavra.
Sintaxe:
CMP destino,fonte
Esta instru‡Æo compara efetuando uma subtra‡Æo entre o byte ou palavra
endere‡ado por DI, dentro do segmento extra de dados, e o byte ou palavra
endere‡ado por SI dentro do segmento de dados, afetando o registrador de
flags, mas sem devolver o resultado da subtra‡Æo.
A instru‡Æo automaticamente incrementa ou decrementa os registradores de
¡ndice SI e DI, dependendo do valor do flag DF, de modo a indicar os
pr¢ximos dois elementos a serem comparados. O valor de incremento ou
decremento ‚ uma de uma ou duas unidades, dependendo da natureza da
opera‡Æo.
Diante desta instru‡Æo, pode-se usar um prefixo para repeti‡Æo, de modo a
comparar dois blocos de mem¢ria entre si, repetindo a instru‡Æo de
compara‡Æo at‚ que ambos se tornem iguais ou desiguais.
 
 --------------- // ---------------
4.3.5.Instru‡äes de flag.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (49 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
Estas instru‡äes afetam diretamente o conte£do dos flags.
 CLC
 CLD
 CLI
 CMC
 STC
 STD
 STI
 
 INSTRUۂO CLC
Prop¢sito: Limpar o flag de carry.
Sintaxe:
CLC
Esta instru‡Æo desliga o bit correspondente ao flag de carry. Em outras
palavras, ela o ajusta para zero.
 
 INSTRUۂO CLD
Prop¢sito: Limpar o flag de endere‡o.
Sintaxe:
CLD
Esta instru‡Æo desliga o bit correspondente ao flag de endere‡o.
 
 INSTRUۂO CLI
Prop¢sito: Limpar o flag de interrup‡Æo.
Sintaxe:
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (50 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
CLI
Esta instru‡Æo desliga o flag de interrup‡äes, desabilitando, deste modo,
interrup‡äes mascar veis.
Uma interrup‡Æo mascar vel ‚ aquela cujas fun‡äes sÆo desativadas quando
IF=0.
 
 INSTRUۂO CMC
Prop¢sito: Complementar o flag de carry.
Sintaxe:
CMC
Esta instru‡Æo complementa o estado do flag CF. Se CF = 0 a instru‡Æo o
iguala a 1. Se CF = 1, a instru‡Æo o iguala a 0.
Poder¡amos dizer que ela apenas inverte o valor do flag.
 
 INSTRUۂO STC
Prop¢sito: Ativar o flag de carry.
Sintaxe:
STC
Esta instru‡Æo ajusta para 1 o flag CF.
 
 INSTRUۂO STD
Prop¢sito: Ativar o flag de endere‡o.
Sintaxe:
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (51 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
STD
Esta instru‡Æo ajusta para 1 o flag DF.
 
 INSTRUۂO STI
Prop¢sito: Ativar o flag de insterrup‡Æo.
Sintaxe:
STI
Esta instru‡Æo ativa o flag IF, e habilita interrup‡äes externas mascar veis
(que s¢ funcionam quando IF = 1).*****************************************************************************
 CAPÖTULO 5: INTERRUP€åES E GERÒNCIA DE ARQUIVOS
 
 
Conte£do:
5.1.Interrup‡äes
5.2.Gerenciamento de arquivos
 --------------- // ---------------
 
Conte£do
5.1.1.Interrup‡äes de hardware interno
5.1.2.Interrup‡äes de hardware externo
5.1.3.Interrup‡äes de software
5.1.4.Interrup‡äes mais comuns
 
5.1.1.Interrup‡äes de hardware interno
Interrup‡äes internas sÆo geradas por certos eventos que ocorrem durante a
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (52 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
execu‡Æo de um programa.
Este tipo de interrup‡äes sÆo gerenciadas, na sua totalidade, pelo hardware
e nÆo ‚ poss¡vel modific -las.
Um exemplo claro deste tipo de interrup‡äes ‚ a que atualiza o contador do
clock interno do computador, o hardware chama esta interrup‡Æo muitas vezes
durante um segundo.
NÆo nos ‚ permitido gerenciar diretamente esta interrup‡Æo, uma vez que nÆo
se pode controlar a hora atualizada por software. Mas podemos usar seus
efeitos no computador para o nosso benef¡cio, por exemplo para criar um
virtual clock atualizado continuamente pelo contador interno de clock. Para
tanto, precisamos apenas ler o valor atual do contador e o transformar num
formato compreens¡vel pelo usu rio.
 --------------- // ---------------
 
5.1.2.Interrup‡äes de hardware externo
Interrup‡äes externas sÆo geradas atrav‚s de dispositivos perif‚ricos, tais
como teclados, impressoras, placas de comunica‡Æo, entre outros. SÆo tamb‚m
geradas por co-processadores.
NÆo ‚ poss¡vel desativar interrup‡äes externas.
Estas interrup‡äes nÆo sÆo enviadas diretamente para a CPU, mas, de uma
forma melhor, sÆo enviadas para um circuito integrado cuja fun‡Æo exclusiva
‚ manusear este tipo de interrup‡Æo. O circuito, chamado PIC8259A, ‚
controlado pela CPU atrav‚s de uma s‚rie de comunica‡Æo chamada paths.
 --------------- // ---------------
 
5.1.3.Interrup‡äes de software
Interrup‡äes de software podem ser ativadas diretamente por nossos programas
assembly, invocando o n£mero da interrup‡Æo desejada com a instru‡Æo INT.
O uso das interrup‡äes facilita muito a cria‡Æo dos programas, torna-os
menores. Al‚m disso, ‚ f cil compreendˆ-las e geram boa performance.
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (53 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
Este tipo de interrup‡äes podem ser separadas em duas categorias:
Interrup‡äes do Sistema Operacional DOS e interrup‡äes do BIOS.
A diferen‡a entre ambas ‚ que as interrup‡äes do sistema operacional sÆo
mais f ceis de usar, mas tamb‚m sÆo mais lentas, uma vez que acessam os
servi‡os do BIOS. Por outro lado, interrup‡äes do BIOS sÆo muito mais
r pidas, mas possuem a desvantagem de serem parte do hardware, o que
significa serem espec¡ficas … arquitetura do computador em questÆo.
A escolha sobre qual o tipo de interrup‡Æo usar ir depender somente das
caracter¡sticas que vocˆ deseja dar ao seu programa: velocidade (use BIOS),
portabilidade (use DOS).
 --------------- // ---------------
 
5.1.4.Interrup‡äes mais comuns
 
 
Conte£do
5.1.4.1.Int 21H (Interrup‡Æo do DOS)
 M£ltiplas chamadas … fun‡äes DOS.
5.1.4.2.Int 10H (Interrup‡Æo do BIOS)
 Entrada e Sa¡da de V¡deo.
5.1.4.3.Int 16H (Interrup‡Æo do BIOS)
 Entrada e Sa¡da do Teclado.
5.1.4.4.Int 17H (Interrup‡Æo do BIOS)
 Entrada e Sa¡da da Impressora.
 
 --------------- // ---------------
5.1.4.1.Interrup‡Æo 21H
Prop¢sito: Chamar uma diversidade de fun‡äes DOS.
Sintaxe:
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (54 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
Int 21H
Nota: Quando trabalhamos com o programa TASM ‚ necess rio especificar que o
valor que estamos usando est em hexadecimal.
Esta interrup‡Æo tem muitas fun‡äes, para acessar cada uma delas ‚
necess rio que o n£mero correspondente da fun‡Æo esteja no registrador AH no
momento da chamada da interrup‡Æo.
Fun‡äes para mostrar informa‡äes no v¡deo.
 02H Exibe um caracter
 09H Exibe uma cadeia de caracteres
 40H Escreve num dispositivo/arquivo
Fun‡äes para ler informa‡äes do teclado.
 01H Entrada do teclado
 0AH Entrada do teclado usando buffer
 3FH Leitura de um dispositivo/arquivo
Fun‡äes para trabalhar com arquivos.
Nesta se‡Æo sÆo apenas especificadas as tarefas de cada fun‡Æo, para uma
referˆncia acerca dos conceitos usados, veja Introdu‡Æo ao gerenciamento de
arquivos.
M‚todo FCB
 0FH Abertura de arquivo
 14H Leitura seq•encial
 15H Escrita seq•encial
 16H Cria‡Æo de arquivo
 21H Leitura rand“mica
 22H Escrita rand“mica
Handles
 3CH Cria‡Æo de arquivo
 3DH Abertura de arquivo
 3EH Fechamento de arquivo
 3FH Leitura de arquivo/dispositivo
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (55 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
 40H Escrita de arquivo/dispositivo
 42H Move ponteiro de leitura/escrita num arquivo
 
 FUNۂO 02H
Uso:
Mostra um caracter na tela.
Registradores de chamada:
AH = 02H
DL = Valor de caracter a ser mostrado.
Registradores de retorno:
Nenhum.
Esta fun‡Æo mostra o caracter cujo c¢digo hexadecimal corresponde ao valor
armazenado no registrador DL, e nÆo modifica nenhum registrador.
O uso da fun‡Æo 40H ‚ recomendado ao inv‚s desta fun‡Æo.
 
 FUNۂO 09H
Uso:
Mostra uma cadeia de caracteres na tela.
Registradores de chamada:
AH = 09H
DS:DX = Endere‡o de in¡cio da cadeia de caracteres.
Registradores de retorno:
Nenhum.
Esta fun‡Æo mostra os caracteres, um por um, a partir do endere‡o indicado
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (56 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
nos registradores DS:DX at‚ encontrar um caracter $, que ‚ interpretado como
fim da cadeia.
• recomendado usar a fun‡Æo 40H ao inv‚s desta.
 
 FUNۂO 40H
Uso:
Escrever num dispositivo ou num arquivo.
Registradores de chamada:
AH = 40H
BX = N£mero do handle
CX = Quantidade de bytes a gravar
DS:DX = µrea onde est o dado
Registradores de retorno:
CF = 0 se nÆo houve erro
 AX = N£mero de bytes escrito
CF = 1 se houve erro
 AX = C¢digo de erro
Para usar esta fun‡Æo para mostrar a informa‡Æo na tela, fa‡a o registrador
BX ser igual a 1, que ‚ o valor default para o v¡deo no DOS.
 
 FUNۂO 01H
Uso:
Ler um caracter do teclado e mostr -lo.
Registradores de chamada
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT (57 of 95)28/09/2004 17:10:35
file:///C|/cursos_e_livros_cd/informática/programação/assembler/ASMPOR.TXT
AH = 01H
Registradores de retorno:
AL = Caracter lido
• muito f cil ler um caracter do teclado com esta fun‡Æo, o c¢digo
hexadecimal do caracter