Escolar Documentos
Profissional Documentos
Cultura Documentos
Copyright(C)1995-1996
*****************************************************************************
* e-mail: amaral@inf.ufsm.br *
*****************************************************************************
provided that:
(1) any copy or republication of the entire document must show University
of
(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
****************************************************************************
TUTORIAL DE LINGUAGEM ASSEMBLY
Conteúdo:
1.Introdução
2.Conceitos Básicos
3.Programação Assembly
4.Instruções Assembly
6.Macros e procedimentos
7.Exemplos de programas
8.Bibliografia
*****************************************************************************
CAPÍTULO 1: INTRODUÇÃO
Conteúdo:
1.2.Apresentação
--------------- // ---------------
1.1.O que há de novo neste material:
opiniões recebidas por e-mail, resolvemos ter por disposição todos estes
nova versão.
Dennis Howe.
1.2.Apresentação:
Este tutorial destina-se àquelas pessoas que nunca tiveram contato com a
Linguagem Assembly.
acesso a cada tópico, bem como uma melhor navegação pelo tutorial.
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
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.
*****************************************************************************
Conteúdo:
--------------- // ---------------
tutorial.
Conteúdo:
2.1.1.Processador Central
2.1.2.Memória Principal
Sistema Computacional.
2.1.1.Processador Central.
dessa forma, são partes da CPU. Estas células são conhecidas com o nome
de
de 16 ou 32 bits.
2.1.2.Memória Principal.
Cada uma das células pode conter um valor numérico e é capaz de ser
interrompida, ou seja, ela é volátil. Este foi o motivo que levou à criação
Para que o computador possa ser útil para nós se faz necessário que o
econômicos.
informação ou programas.
--------------- // ---------------
2.2.CONCEITOS BÁSICOS
Conteúdo:
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.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
como ligado ou 1. Estes estados são geralmente conhecidos como bits, que
são
2.2.1.2.Sistemas numéricos
não é conveniente para máquinas, pois ali as informações têm que ser
este modo de código faz com que tenhamos que conhecer o cálculo
posicional
dele.
É possível representar um determinado número em qualquer base através
da
seguinte fórmula:
usada.
Binary: 1 1 0 0 1
multiplicação.
é muito mais fácil, mas nem sempre podemos contar com isso, logo o mais
dividido.
0,1,2,3,4,5,6,7,8,9,A,B,C,D,E, e F.
com zeros.
bits:
10;1011
0010;1011
0010=2;1011=11
Entretanto, observa-se que não podemos representar este número como
211,
isto seria um erro, uma vez que os números em hexa maiores que 9 e
menores
resultado:
--------------- // ---------------
2.2.2.1.Código ASCII
2.2.2.2.Método BCD
2.2.2.1.Código ASCII
0, ou seja, desligado.
do computador.
ineficiente no aspecto numérico, uma vez que no formato binário 1 byte não
é
representação de textos.
2.2.2.2.Método BCD
Neste método grupos de 4 bits são usados para representar cada dígito
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,
O expoente negativo, por outro lado, indica o número de casas que o ponto
--------------- // ---------------
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
DX. São registradores de uso geral e também podem ser usados como
CX e DX.
AX Registrador Acumulador
BX Registrador Base
CX Registrador Contador
DX Registrador de Dados
F Registrador de Flag
2.3.3.Programa Debug.
Debug pode apenas criar arquivos com a extensão .COM, e por causa das
C:/>Debug [Enter]
registradores, experimente:
-r[Enter]
0D62:0100 2E CS:
-rbx
BX 0000
2.3.4.Estrutura Assembly.
exemplo:
add ah bh
Aqui "add" é o comando a ser executado, neste caso uma adição, e "ah"
bem
Por exemplo:
mov al, 25
No exemplo acima, estamos usando a instrução mov, que significa mover o
add al,[170]
endereço 170 da memória e não com o valor 170, isto é conhecido como
"endereçamento direto".
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.
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
finaliza o programa.
-a 100
0D62:0108 nop
0D62:0109
-t
instrução:
-t
-t
0D62:0108 90 NOP
Não seria prático ter que digitar o programa cada vez que iniciássemos o
0C1B:0108 int 20
0C1B:010A
-h 10a 100
020a 000a
obtido como tamanho do arquivo com o comando "h", neste caso 000a.
-rcx
CX 0000
:000a
bytes gravou.
-w
-n test.com
-l
-u 100 109
O último comando "u" é usado para verificar que o programa foi carregado
na
desmontados.
comentamos.
*****************************************************************************
Conteúdo:
3.2.Processo 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
Nós devemos criar os programas fonte com a extensão .ASM para que o
TASM
e ligado.
3.1.2.PROGRAMAÇÃO ASSEMBLY
.MODEL SMALL
.CODE
.STACK
END
Vamos programar
Primeiro passo
Use qualquer editor para criar o programa fonte. Entre com as seguintes
linhas:
Primeiro exemplo
Segundo passo
Terceiro passo
Exemplo:
C:\>tasm exam1.asm
Passes: 1
O TASM só pode criar programas no formato .OBJ, que ainda não pode ser
executado...
Quarto passo
Exemplo:
C:\>tlink exam1.obj
Turbo Link Version 3.0 Copyright (c) 1987, 1990 Borland International
C:\>
C:\>exam1[enter]
--------------- // ---------------
3.2.Processo Assembly.
3.2.1.Segmentos
3.2.2.Tabela de equivalência
3.2.1.SEGMENTOS
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
Desta forma, para que o montador seja capaz de gerenciar os dados, se faz
Debug, observe:
3.2.2.TABELAS DE EQUIVALÊNCIA
Cada uma das partes numa linha de código assembly é conhecida como
token,
por exemplo:
MOV AX,Var
que o montador faz para gerar o código OBJ é ler cada um dos tokens e
correspondente, mas se não encontrou ele a insere na tabela para que ela
Há símbolos que o montador não consegue encontrar, uma vez que podem
ser
--------------- // ---------------
3.3.Mais programas.
Outro exemplo
Primeiro passo
.model small
.stack
.code
Segundo passo
Terceiro passo
C:\>tasm exam2.asm
Quarto passo
C:\>tlink exam2.obj
Turbo Link Version 3.0 Copyright (c) 1987, 1990 Borland International
C:\>
Quinto passo
Executar o programa:
C:\>exam2[enter]
C:\>
--------------- // ---------------
3.4.Tipos de instruções.
3.4.1.Movimento de dados
3.4.1.MOVIMENTO DE DADOS
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
PUSH AX
PUSH BX
PUSH CX
seguir-se a ordem:
POP CX
POP BX
POP AX
OUT DX,AX
Onde DX contém o valor da porta que será usada para a comunicação e AX
IN AX,DX
As instruções usadas para operações algébricas são: para adição add, para
para definir as operações sobre cadeias. Uma outro que pode também ser
desativar as interrupções.
3.4.3.SALTOS, LOOPS E PROCEDIMENTOS
endereço.
*****************************************************************************
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
MOV
INSTRUÇÃO MOV
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:
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
interrupção 21h.
INSTRUÇÕES MOVS (MOVSB) (MOVSW)
Sintaxe:
MOVS
Este comando não necessita de parâmetros uma vez que toma como
endereço
MOVS
Instruções de carga.
São instruções específicas para registradores, usadas para carregar bytes
ou
LAHF
LDS
LEA
LES
Sintaxe:
LODS
LODS
INSTRUÇÃO LAHF
Sintaxe:
LAHF
Esta instrução é útil para verificar o estado dos flags durante a execução
do nosso programa.
SF ZF ?? AF ?? PF ?? CF
INSTRUÇÃO LDS
Propósito: Carregar o registrador de segmento de dados.
Sintaxe:
LDS destino,fonte
destino.
INSTRUÇÃO LEA
Sintaxe:
LEA destino,fonte
Para ilustrar uma das facilidades que temos com este comando, vejamos:
MOV SI,OFFSET VAR1
É equivalente a:
LEA SI,VAR1
INSTRUÇÃO LES
Sintaxe:
LES destino,fonte
POP
POPF
PUSH
PUSHF
INSTRUÇÃO POP
Sintaxe:
POP destino
Este incremento é duplo pelo fato de que a pilha do mais alto endereço de
Sintaxe:
POPF
BIT FLAG
0 CF
2 PF
4 AF
6 ZF
7 SF
8 TF
9 IF
10 DF
11 OF
vimos anteriormente.
INSTRUÇÃO PUSH
Sintaxe:
PUSH fonte
recém modificado.
INSTRUÇÃO PUSHF
Propósito: Colocar os valores dos flags na pilha.
Sintaxe:
PUSHF
--------------- // ---------------
Conteúdo:
4.2.1.Instruções lógicas
4.2.2.Instruções aritméticas
4.2.1.Instruções lógicas
NEG
NOT
OR
TEST
XOR
INSTRUÇÃO AND
Sintaxe:
AND destino,fonte
como na tabela:
-----------------------------
1 1 | 1
1 0 | 0
0 1 | 0
0 0 | 0
Sintaxe:
NEG destino
NEG AX
Isto fará com o que o valor EDCCH fque armazenado no registrador AX.
INSTRUÇÃO NOT
Sintaxe:
NOT destino
Sintaxe:
OR destino,fonte
A instrução OR, faz uma disjunção lógica bit a bit dos dois operadores:
-----------------------------------
1 1 | 1
1 0 | 1
0 1 | 1
0 0 | 0
INSTRUÇÃO TEST
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
INSTRUÇÃO XOR
Sintaxe:
XOR destino,fonte
bit.
-----------------------------------
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.
ADC
ADD
DIV
IDIV
MUL
IMUL
SBB
SUB
INSTRUÇÃO ADC
Sintaxe:
ADC destino,fonte
Esta instrução efetua a soma entre dois operandos, mais o valor do flag CF,
afetados.
Sintaxe:
ADD destino,fonte
destino.
INSTRUÇÃO DIV
Sintaxe:
DIV fonte
instrução.
e o resto em DX.
INSTRUÇÃO IDIV
Sintaxe:
IDIV fonte
INSTRUÇÃO MUL
MUL fonte
INSTRUÇÃO IMUL
Sintaxe:
IMUL fonte
Esta instrução faz o mesmo que a anterior, difere apenas pela inclusão do
sinal.
MUL.
INSTRUÇÃO SBB
Sintaxe:
SBB destino,fonte
bits.
INSTRUÇÃO SUB
Propósito: Subtração.
Sintaxe:
SUB destino,fonte
Conteúdo:
4.3.1.Instruções de salto
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.
indicado.
JMP
JA (JNBE)
JAE (JNBE)
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
Sintaxe:
JMP destino
INSTRUÇÃO JA (JNBE)
JA símbolo
Sintaxe:
JAE símbolo
INSTRUÇÃO JB (JNAE)
Propósito: Salto condicional.
Sintaxe:
JB símbolo
Sintaxe:
JBE símbolo
INSTRUÇÃO JE (JZ)
Propósito: Salto condicional.
Sintaxe:
JE símbolo
Sintaxe:
JNE símbolo
INSTRUÇÃO JG (JNLE)
Propósito: Salto condicional, e o sinal é tomado.
Sintaxe:
JG símbolo
Sintaxe:
JGE símbolo
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.
Sintaxe:
JLE símbolo
A instrução salta se está less than, se está equal ou se está not larger.
INSTRUÇÃO JC
Propósito: Salto condicional, e os flags são tomados.
Sintaxe:
JC símbolo
O salto é feito se CF = 1.
INSTRUÇÃO JNC
Sintaxe:
JNC símbolo
O salto é feito se CF = 0.
INSTRUÇÃO JNO
Propósito: Salto condicional, e o estado dos flags é tomado.
Sintaxe:
JNO símbolo
O salto é feito se OF = 0.
Sintaxe:
JNP símbolo
O salto é feito se PF = 0.
INSTRUÇÃO JNS
Propósito: Salto condicional, e o estado dos flags é tomado.
Sintaxe:
JNP símbolo
O salto é feito se SF = 0.
INSTRUÇÃO JO
Sintaxe:
JO símbolo
O salto é feito se OF = 1.
INSTRUÇÃO JP (JPE)
Propósito: Salto condicional, e o estado dos flags é tomado.
Sintaxe:
JP símbolo
O salto é feito se PF = 1.
INSTRUÇÃO JS
Sintaxe:
JS símbolo
--------------- // ---------------
4.3.2.Instruções para laços: LOOP.
zero.
LOOP
LOOPE
LOOPNE
INSTRUÇÃO LOOP
Sintaxe:
LOOP símbolo
INSTRUÇÃO LOOPE
Propósito: Gerar um laço no programa, considerando o estado de ZF.
Sintaxe:
LOOPE símbolo
operador.
INSTRUÇÃO LOOPNE
Sintaxe:
LOOPNE símbolo
se ZF é diferente de 0.
--------------- // ---------------
4.3.3.Instruções contadoras.
contadores.
DEC
INC
DEC INSTRUCTION
Sintaxe:
DEC destino
mesmo operador.
INSTRUÇÃO INC
Sintaxe:
INC destino
operador.
--------------- // ---------------
4.3.4.Instruções de comparação.
CMP
INSTRUÇÃO CMP
Sintaxe:
CMP destino,fonte
Sintaxe:
CMP destino,fonte
operação.
4.3.5.Instruções de flag.
CLC
CLD
CLI
CMC
STC
STD
STI
INSTRUÇÃO CLC
Sintaxe:
CLC
Sintaxe:
CLD
INSTRUÇÃO CLI
Sintaxe:
CLI
interrupções mascaráveis.
IF=0.
INSTRUÇÃO CMC
Sintaxe:
CMC
INSTRUÇÃO STC
Sintaxe:
STC
Sintaxe:
STD
INSTRUÇÃO STI
Sintaxe:
STI
*****************************************************************************
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.3.Interrupções de software
Interrupções internas são geradas por certos eventos que ocorrem durante
a
execução de um programa.
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
--------------- // ---------------
Estas interrupções não são enviadas diretamente para a CPU, mas, de uma
5.1.3.Interrupções de software
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
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),
--------------- // ---------------
5.1.4.Interrupções mais comuns
Conteúdo
--------------- // ---------------
5.1.4.1.Interrupção 21H
Sintaxe:
Int 21H
Esta interrupção tem muitas funções, para acessar cada uma delas é
Nesta seção são apenas especificadas as tarefas de cada função, para uma
arquivos.
Método FCB
Handles
FUNÇÃO 02H
Uso:
Registradores de chamada:
AH = 02H
Registradores de retorno:
Nenhum.
FUNÇÃO 09H
Uso:
Registradores de chamada:
AH = 09H
Registradores de retorno:
Nenhum.
Esta função mostra os caracteres, um por um, a partir do endereço indicado
fim da cadeia.
FUNÇÃO 40H
Uso:
Registradores de chamada:
AH = 40H
BX = Número do handle
Registradores de retorno:
AX = Código de erro
Para usar esta função para mostrar a informação na tela, faça o registrador
FUNÇÃO 01H
Uso:
Registradores de chamada
AH = 01H
Registradores de retorno:
AL = Caracter lido
Uso:
Registradores de chamada:
AH = 0AH
Registradores de retorno:
Nenhum.
digitar [ENTER].
FUNÇÃO 3FH
Uso:
Registradores de chamada:
AH = 3FH
BX = Número do handle
Registradores de retorno:
FUNÇÃO 0FH
Uso:
Abrir um arquivo FCB.
Registradores de chamada:
AH = 0FH
Registradores de retorno:
FUNÇÃO 14H
Uso:
Registradores de chamada:
AH = 14H
Registradores de retorno:
FUNÇÃO 15H
Uso:
Registradores de chamada:
AH = 15H
Registradores de retorno:
bloco.
FUNÇÃO 16H
Uso:
AH = 16H
Registradores de retorno:
FUNÇÃO 21H
Uso:
Registradores de chamada:
AH = 21H
Transferência do Disco.
FUNÇÃO 22H
Uso:
Registradores de chamada:
AH = 22H
Registradores de retorno:
FUNÇÃO 3CH
Uso:
Registradores de chamada:
AH = 3CH
CH = Atributo do arquivo
Registradores de retorno:
e 5 acesso negado.
seguinte modo:
Valor Atributos
00H Normal
02H Hidden
04H System
FUNÇÃO 3DH
Uso:
Registradores de chamada:
AH = 3DH
AL = modo de acesso
01H se a função não é válida, 02H se o arquivo não foi encontrado, 03H se o
caminho não foi
BITS
7 6 5 4 3 2 1
. . . . 0 0 0 Apenas leitura
. . . . 0 0 1 Apenas escrita
. . . . 0 1 0 Leitura/Escrita
. . . x . . . RESERVADO
FUNÇÃO 3EH
Uso:
AH = 3EH
Registradores de retorno:
FUNÇÃO 3FH
Uso:
--------------- // ---------------
5.1.4.2.Interrupção 10h
Sintaxe:
Int 10H
Esta interrupção tem várias funções, todas para entrada e saída de vídeo.
Função 02h
Uso:
Registradores de chamada:
AH = 02H
DH = linha
DL = coluna
Registradores de retorno:
Nenhum.
Função 09h
Uso:
Registradores de chamada:
AH = 09H
AL = Caracter a exibir
BL = Atributo do caracter
CX = Número de repetições.
Registradores de retorno:
Nenhum
Função 0Ah
Uso:
Registradores de chamada:
AH = 0AH
AL = Caracter a exibir
CX = Número de repetições
Registradores de retorno:
Nenhum.
Função 0EH
Uso:
Registradores de chamada:
AH = 0EH
AL = Caracter a exibir
Registradores de retorno:
Nenhum
--------------- // ---------------
5.1.4.3.Interrupção 16H
Registradores de chamada:
AH = 00H
Registradores de retorno:
Quando se usa esta interrupção, os programas executam até que uma tecla
seja
Este valor de AL pode ser utilizado quando queremos detectar teclas que
não
estão diretamente representadas pelo seu valor ASCII, tais como
[ALT][CONTROL].
Função 01h
Uso:
Registradores de chamada:
AH = 01H
Registradores de retorno:
--------------- // ---------------
5.1.4.4.Interrupção 17H
Int 17H
uma impressora.
Função 00H
Uso:
Registradores de chamada:
AH = 00H
AL = Caracter a imprimir
DX = Porta de conexão
Registradores de retorno:
AH = Estado da impressora
Os valores da porta a colocar no registrador DX são:
----------------------------------------
0 1 Estado de time-out
1-
2-
4 1 Impressora selecionada
5 1 Fim de papel
6 1 Reconhecimento de comunicação
4.
Função 01h
Uso:
AH = 01H
DX = Porta
Registradores de retorno:
AH = Status da impressora
diante.
----------------------------------------
0 1 Estado de time-out
1-
2-
4 1 Impressora selecionada
5 1 Fim de papel
6 1 Reconhecimento de comunicação
Uso:
Registradores de chamada:
AH = 01H
DX = Porta
Registradores de retorno
AH = Status da impressora
diante.
----------------------------------------
0 1 Estado de time-out
1-
2-
4 1 Impressora selecionada
5 1 Fim de papel
6 1 Reconhecimento de comunicação
--------------- // ---------------
Conteúdo:
5.2.2.Método FCB
com muitos arquivos velhos do CPM bem como com a versão 1.0 do DOS,
além
Para uma melhor facilidade, daqui por diante nos referiremos aos Blocos de
--------------- // ---------------
5.2.2.Método FCB.
5.2.2.1.Introdução
5.2.2.2.Abertura de arquivo
5.2.2.4.Escrita seqüencial
5.2.2.5.Leitura seqüencial
5.2.2.7.Fechar um arquivo
--------------- // ---------------
5.2.2.1.INTRODUÇÃO
Há dois tipos de FCB, o normal, cujo comprimento é 37 bytes, e o extendido,
do DOS.
opção.
registro 0, logo o último registro do primeiro bloco deve ser o 127, uma vez
total.
--------------- // ---------------
5.2.2.2.ABERTURA DE ARQUIVO
abertura.
--------------- // ---------------
Caso ocorra problema, o valor FFH deve retornar em AL, de outra forma este
--------------- // ---------------
5.2.2.4.ESCRITA SEQÜENCIAL
interrupção 21h.
A função 1AH não retorna qualquer estado do disco nem da operação. Mas a
função 15H, que usaremos para escrever para o disco, faz isso no
registrador
AL. Se este for igual a zero, então não há erro e os campos de registro
5.2.2.5.LEITURA SEQÜENCIAL
significa que foi atingido o fim do arquivo. Um valor 2, por sua vez,
--------------- // ---------------
--------------- // ---------------
5.2.2.7.FECHAR UM ARQUIVO
a disco.
--------------- // ---------------
5.2.3.Canais de comunicação.
sistema operacional.
A facilidade dos handles consiste em que para operarmos sobre um arquivo
é
Quando usamos este método para trabalhar com arquivos, não há distinção
--------------- // ---------------
*****************************************************************************
Conteúdo
6.1.Procedimentos
6.2.Macros
6.1.Procedimentos
6.1.1.Definição de procedimento
6.1.2.Sintaxe de um procedimento
--------------- // ---------------
6.1.1.Definição de um procedimento
procedimento.
--------------- // ---------------
6.1.2.Sintaxe de um procedimento
código.
CALL NomedoProcedimento
Declaração do procedimento
Código do procedimento
Diretiva de retorno
Término do procedimento
Por exemplo, se quisermos uma rotina que soma dois bytes armazenados
em AH e
Mov BL, AH
Mov AH, 00
Add BX, AX
para FAR.
Call Soma
procedimentos.
--------------- // ---------------
6.2.Macros
6.2.3.Bibliotecas de Macros
6.2.1.Definição de uma Macro
outro lado, para chamada de macros é feita com se fosse uma instrução
normal
da linguagem assembly.
--------------- // ---------------
Declaração da macro
Código da macro
tela:
PUSH AX
PUSH BX
PUSH DX
MOV BH, 0
INT 10H
POP DX
POP BX
POP AX
ENDM
Para usar uma macro basta chamá-la pelo seu nome, tal como se fosse
qualquer
Pos 8, 6
--------------- // ---------------
6.2.3.Biblioteca de Macros
bibliotecas, que são grupo de macros, podendo ser incluídas num programa
modelo de memória.
Supondo que o arquivo de macros tenha sido salvo com o nome de
MACROS.TXT, a
;Início do programa
Include MACROS.TXT
.MODEL SMALL
.DATA
.CODE
Inicio:
.STACK
;A pilha é declarada
End Inicio
;Fim do programa
*****************************************************************************
Conteúdo:
--------------- // ---------------
7.1.Exemplos de Programas com Debug
Você pode executar cada programa assembly usando o comando "g" (go),
para
Procedimento
Primeiro passo
Por exemplo:
C:\>debug
-n one.com
-l
-u 100 109
Nota:
-n one.com
Dar nome ao programa a ser carregado
-l
Carregá-lo
-u 100 109
Segundo passo
Digite o comando g
Por exemplo:
-g
Primeiro exemplo
-a0100
297D:0100 MOV AX,0006 ;Põe o valor 0006 no registrador AX
A única coisa que este programa faz é salvar dois valores em dois
Segundo exemplo
- a100
0C1B:0102 [Enter]
- a125
Terceiro exemplo
-a100
Quarto exemplo
-a100
Este programa usa a interrupção 21h do DOS. Usa duas funções da mesma:
a
ENTER.
Quinto exemplo
-a100
297D:0100 MOV AH,02 ;Função 2 (escreve um caractere na tela)
Sexto exemplo
-a100
-a100
Oitavo exemplo
-a100
Nono exemplo
-a100
297D:0117 AND DL,0F ;Transporta fazendo AND dos números bit a bit
-a100
-a100
Este programa se mantém lendo caracteres até receber um que possa ser
Procedimento:
Primeiro passo
Montar o programa
Por exemplo:
C:\>tasm one.asm
Passes: 1
C:\>
Isto criará um programa objeto com o mesmo nome do fonte, neste caso:
one.obj
Segundo passo
Por exemplo:
C:\>tlink one.obj
Turbo Link Version 3.0 Copyright (c) 1987, 1990 Borland International
C:\>
diferente, one.exe
Terceiro passo
Primeiro exemplo
;
.model small
.stack
.code
sub DL,7h ;se falso, subtrai de 7h para converter a uma letra A-F
digit1:
shl DL,CL ;multiplica para converter dentro dos 4 bits mais altos
digit2:
Segundo exemplo
;nome do programa: two.asm
.model small
.stack
.code
PRINT_A_J PROC
PRINT_LOOP:
WRITE_CHAR PROC
Terceiro exemplo
.STACK
.code
TEST_WRITE_HEX PROC
PUBLIC WRITE_HEX
;........................................................;
;Use:WRITE_HEX_DIGIT ;
;........................................................;
WRITE_HEX PROC
SHR DL,CL
AND DL,0Fh
WRITE_HEX ENDP
PUBLIC WRITE_HEX_DIGIT
;......................................................................;
;Use: WRITE_CHAR ;
;......................................................................;
WRITE_HEX_DIGIT PROC
HEX_LETTER:
WRITE_DIGIT:
;para o registrador DL
WRITE_HEX_DIGIT ENDP
PUBLIC WRITE_CHAR
;......................................................................;
;......................................................................;
WRITE_CHAR PROC
WRITE_CHAR ENDP
Quarto exemplo
.model small
.stack
.code
TEST_WRITE_DECIMAL PROC
;.................................................................;
;Use: WRITE_HEX_DIGIT ;
;.................................................................;
WRITE_DECIMAL PROC
NON_ZERO:
INC CX ;incrementa CX
WRITE_DIGIT_LOOP:
END_DECIMAL:
PUBLIC WRITE_HEX_DIGIT
;......................................................................;
; ;
;Use: WRITE_CHAR ;
;......................................................................;
WRITE_HEX_DIGIT PROC
HEX_LETTER:
WRITE_DIGIT:
WRITE_HEX_DIGIT ENDP
PUBLIC WRITE_CHAR
;......................................................................;
;......................................................................;
WRITE_CHAR PROC
WRITE_CHAR ENDP
Quinto exemplo
.model small
.stack
.code
PRINT_ASCII PROC
WRITE_CHAR PROC
Este programa mostra na tela o valor dos 256 caracteres do código ASCII.
*****************************************************************************
CAPÍTULO 8: BIBLIOGRAFIA
Créditos:
Idéia Original
Desenvolvimento e Implementação da edição 1996
Versão Inglesa
Versão Portuguesa
Programadora Tcl/Tk
Designer Gráfico
Referências Bibliográficas:
J. Terry Godfrey
Mexico
Basic Assembler
A. Rojas
Mexico
Joshua Auerbach
Yale University
Andrew S. Tanenbaum
Richard F. Ferraro
McGraw-Hill
Alan R. Miller
John Socha
Editora Campus
C - Caixa de Ferramentas
Editora Érica
McGraw-Hill
Leland L. Beck
Editora Campus
Ross P. Nelson
McGraw-Hill