Programando em

ASSEMBLY
Uma introdução à programação em Assembly

Arthur Xavier Gomes Ribeiro

 Índice
Introdução ............................................. 4
Registradores .......................................... 4
Instrução MOV .......................................... 5
Instrução LEA .......................................... 5
Interrupções ........................................... 5
Instruções ADD, SUB, MUL e DIV ......................... 6
Instrução JMP .......................................... 7
O Comando CMP .......................................... 7
A Pilha, o PUSH e o POP ................................ 8
O DEBUG do DOS ......................................... 8
Primeiro Programa ...................................... 9

A Estrutura de um programa .EXE ........................ 10

Hello World ............................................ 11
Turbo Assembler ........................................ 11
Apêndice: Primeiro Programa ............................ 12
 Introdução
Assembly é uma linguagem de baixo nível, ou seja, ela se
comunica diretamente com o processador, sem nenhum tipo de
intermediário, apenas o Sistema Operacional.
A linguagem Assembly é uma notação que pode ser compreendida
para os opcodes (códigos operacionais da máquina). As instruções dadas
ao processador na linguagem Assembly são chamadas de Mnemônicos, pois
representam palavras para auxiliar a memorização dos comandos.
Assembly não é uma linguagem compilada, e sim montada usando-se
um montador ou Assembler. Isso acontece pois as instruções Assembly
correspondem às instruções de máquina de uma forma de 1 para 1, o que
acontece no processo de montagem, é simplesmente uma pequena
transformação ou tradução do código Assembly diretamente para o código
de máquina.

Registradores
A linguagem Assembly, como vimos, é constituída de pequenas
instruções chamadas de mnemônicos. Estas instruções servem para mover
dados, somar dados, subtrair, dividir, multiplicar, comparar, saltar
para um ponto do programa, etc.
Para armazenar valores, são necessários os registradores, que
são endereços de memória encarregados de guardar ou receber dados. Os
principais registradores de Assembly 16-bits são: AX, BX, CX, DX, DS,
ES, SS, CS,SI, DI, BP e SP. Cada um deles (exceto DS, ES, SS, CS, SI,
DI, BP e SP) podem guardar 2 bytes, sendo o primeiro byte, ou byte
mais alto: AH, BH, CH e DH. E o último byte, ou byte mais baixo: AL,
BL, CL, e DL.

Registrador Byte Alto Byte Baixo

16-bits
AX AH AL
BX BH BL
CX CH CL
DX DH DL

Cada registrador em Assembly tem uma função específica. Vejamos

a função de cada um:

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/Stack
CS – Registrador de Segmento de Código
SI – Registrador de Índice da Fonte/Source dos Dados
DI – Registrador de Índice do Destino dos Dados
BP – Registrador de Ponteiro de Base
SP – Registrador de Ponteiro da Pilha/Stack
 Instrução MOV
A instrução MOV serve para MOVER dados de um lugar para o
outro. Sua sintaxe é a seguinte:

MOV destino,fonte

Os seguintes movimentos de dados são permitidos por esta

instrução:

MOV memória,acumulador
MOV acumulador,memória
MOV registrador de segmento,memória/registrador
MOV memória/registrador,registrador de segmento
MOV registrador,registrador
MOV registrador,memória
MOV memória,registrador
MOV registrador,dado
MOV memória,dado

Exemplo:

MOV AX,0241h ;mov registrador,dado

MOV AX,AX ;mov registrador,registrador
MOV DS,AX ;mov reg. De segmento,registrador
MOV ES,AX ;mov reg. De segmento,registrador
MOV DL,41h ;mov registrador,dado
MOV [BX],DL ;mov memória,registrador

Instrução LEA
A Instrução LEA (Load Effective Address) carrega o endereço do
operador fonte para o destino. Sua sintaxe é a seguinte:

LEA destino,fonte

O uso desta instrução é similar ao uso de MOV destino,offset

fonte, mas é mais simplificada.

Interrupções
Interrupções são pausas geradas pelo programa para que a BIOS se
dedique ao programa executando suas funções de entrada/saída. Em
Assembly, o comando para se usar uma interrupção é INT. Sua sintaxe é:

INT numero_da_interrupção

As Interrupções tem várias funções específicas, que podem ser

escolhidas através do valor contido no registrador AH.
 A tabela a seguir mostra as principais funções da INT 21h do
DOS:

AH Descrição Retorno/Parâmetro
00h Termina o Programa (DOS 2.0 ou anterior) -
01h Leitura do teclado com eco na tela AL = caracter
02h Escreve caracter na tela DL = caracter
07h Leitura do teclado sem eco
AL = caracter
Ignora CTRL-Break
08h Leitura do teclado sem eco
AL = caracter
Reconhece e executa CTRL-Break
09h Escreve string na tela DS = ponteiro para
string com fim $
0Ah* Leitura do teclado em buffer DS = ponteiro para
buffer de leitura
4Ch Termina o Programa (mais recomendada) -
• O buffer para leitura do teclado deve ter o formato:
|numero maximo de caracteres | numero de caracteres lidos | string

Exemplo:

mov ah,02h
mov dl,41h ;caracter = A
int 21h ;escreve caracter na tela
mov ah,4ch
int 21h ;finaliza o programa

Instruções
ADD, SUB, MUL e DIV
A instrução ADD é usada para somar dois registradores, ou um
registrador e um dado. Sua sintaxe é a seguinte:

ADD registrador,registrador
ADD registrador,dado

A instrução SUB é usada para, ao contrario da instrução ADD,

subtrair dois registradores, ou um registrador e um dado. Sua sintaxe
é a mesma da instrução ADD.
A instrução MUL é usada para multiplicar o registrador
acumulador (AX) por um outro registrador. O resultado da multiplicação
é armazenado em AX, e o resto em DX. Sua sintaxe é a seguinte:

MOV AX,3
MOV BX,2
MUL BX ;multiplica o valor de AX pelo valor de BX

A instrução DIV é usada para, ao contrário da instrução MUL,

dividir o registrador acumulador por um outro registrador. Sua sintaxe
é a seguinte:

MOV AX,6
MOV BX,3
DIV BX ;divide o valor de AX pelo valor de BX
 Instrução JMP
A instrução JMP é usada para fazer um salto incondicional de um
ponto do programa para outro, isto é, alterar a execução do programa.
Sua sintaxe é a seguinte:

JMP segmento ;no TASM, MASM ou NASM

JMP endereço ;no DEBUG do DOS

O Comando CMP
O comando CMP compara dois registradores, ou um registrador e um
valor e permite fazer um salto condicional usando as seguintes
instruções:

JG – Jump if Greater
JGE – Jump if Greater or Equal
JNG – Jump if Not Greater
JNGE – Jump if Not Greater or Equal
JE – Jump if Equal
JZ – Jump if Zero
JNE – Jump if Not Equal
JNZ – Jump if Not Zero
JL – Jump if Lower
JLE – Jump if Lower or Equal
JNL – Jump if Not Lower
JNLE – Jump if Not Lower or Equal

Exemplo:

MOV AX,0005h
MOV BX,0000h
CMP AX,BX ;compara AX com BX
JGE 0100 ;salta para o endereço 0100 se maior ou igual
---------------------------------------------------------------
MOV AH,01h
INT 21h
CMP AL,2 ;compara AL com 2
JE 0104 ;salta para o endereço 0104 se igual
 A Pilha, o PUSH e o POP
A Pilha de Dados é uma estrutura muito importante em assembly,
pois ela nos permite armazenar inúmeros dados de forma simples e
eficiente. Podemos imaginar a Pilha como uma pilha de pratos, o
primeiro a ser colocado, é o último a ser tirado, senão os pratos
caem.
A instrução PUSH armazena um WORD (2 bytes ou 16-bits) na Pilha.
Sua sintaxe é a seguinte:

PUSH registrador/word

A instrução POP retira um WORD da Pilha e o armazena em um

registrador ou em outro WORD. Sua sintaxe é a seguinte:

POP registrador/word

Exemplos:

MOV AH,01h
INT 21h
MOV AH,00h ;zera-se o valor de AH pois AX contém AH e
queremos apenas o valor de AL
PUSH AX
ADD CX,1
CMP CX,5
JL 0100 ;0100 é o endereço do início do programa no
DEBUG do DOS
POP AX
MOV AH,02h
INT 21h
SUB CX,1
CMP CX,0
JG 0114 ;a cada linha o endereço aumenta em 2

MOV AH,4Ch
INT 21h

O DEBUG do DOS
O DEBUG é uma ferramenta interessante do DOS pois ele apresenta
um Assembler, isto é, um montador sequencial de instruções Assembly.
Para se iniciar o Assembler do DEBUG, a linha de comando é:

C:\>debug
-A
0CFF:0100

Assim que iniciado o Assembler, basta digitar as instruções.

Para terminar de editar o código, deve-se apertar ENTER duas vezes.
Para executar o código, deve-se digitar –G. Para salvar seu programa
em formato .COM, deve-se digitar –W. E, para sair do debug, deve-se
digitar –Q.
 Primeiro Programa
O nosso primeiro programa no DEBUG deverá pedir o usuário para
apertar uma tecla sem escrevê-la na tela. O programa deverá então
checar se o usuário apertou a tecla ENTER. Se não, ele deve escrever a
letra A na tela. Se sim, deve terminar o programa sem escrever nada.
Tente fazer este programa. A resposta está no final desta
apostila.
 A Estrutura de um programa
.EXE
A estrutura de um programa .EXE é diferente da estrutura de um
programa no DEBUG do MS-DOS. Isto, porque, o programa .EXE é dividido
em segmentos.
Para criar programas .EXE, usaremos o montador Turbo Assembler
ou TASM, da Borland (vide pág. 12)

A diretiva .MODEL
A diretiva .model define o modelo de memória de um programa
.EXE, e deve ser incluída no início do código.
Os modelos de memória são os seguintes:

.model tiny
.model small ;usaremos small para nossos programas
.model medium
.model compact
.model large
.model huge
.model flat ;usado em aplicativos Win32

A diretiva .STACK
A diretiva .stack define o tamanho da pilha. Pode ser usada da
seguinte maneira:

.stack tamanho_da_pilha

A diretiva .DATA
A diretiva .data é usada para declaração de variáveis. Pode ser
usada da seguinte maneira:

.data
var1 db 10 ;db = define byte. Valor inicial = 10
var2 db ? ;Valor inicial = não definido
var3 db 10 dup(‘$’) ;cria um vetor de tamanho 10
e o preenche com $
var4 dw 32767 ;dw = define word. Tamanho 2 bytes
var5 dd 65536 ;dd = define double word. 4 bytes
string db ‘String,’$’ ;cria uma string. Terminador $

A diretiva .CODE
A diretiva .code é usada para demarcar o início do código. O
código deve começar a ser executado a partir de um segmento:

.code
main: ;segmento de inicio. Pode ter qualquer nome
end main ;termina o segmento main
 Hello World
O programa a seguir escreve a mensagem “Hello World” na tela e
executa uma pequena pausa ao final:

.model small
.stack 100h
.data
msg db 'Hello World','$'
.code
main:
mov ax,@data
mov ds,ax
mov es,ax

mov ah,09
lea dx,msg ;mov dx,offset msg
int 21h

mov ah,08h
int 21h
mov ah,4ch
int 21h
end main

Salve o como hello.asm e compile-o usando o TASM.

Turbo Assembler
O Turbo Assembler da Borland (TASM) é um montador Assembly. Para
montar programas usando esta ferramenta, deve-se usar a linha de
comando do DOS.
Para montar um arquivo .obj deve-se usar a seguinte linha de
comando:

C:\TASM\BIN>TASM hello.asm

Para linkar o arquivo .obj, isto é, transforma-lo em .exe, deve-

se usar a seguinte linha de comando:

C:\TASM\BIN>TLINK hello.obj

Como este processo é trabalhoso, é mais fácil usar um arquivo de

Script do DOS, um arquivo .bat como este:

@echo off
set program=hello
cls
echo ---------------------------
echo Backup...
copy /v %program%.asm /a %program%.bak /a
echo ---------------------------
..\..\bin\TASM %program%.asm
 echo ---------------------------
..\..\bin\TLINK %program%.obj
echo ---------------------------
pause
cls
%program%.exe
exit

O Script acima faz uma cópia de segurança do arquivo .asm,

monta-o usando o TASM, linka-o usando o TLINK e em seguida executa-o,
facilitando o uso das linhas de comando.
Apêndice: Primeiro Programa
O código do Primeiro Programa é o descrito abaixo:

0D03:0100 mov ah,08

0D03:0102 int 21
0D03:0104 cmp al,0d
0D03:0106 jne 010A
0D03:0108 je 0112
0D03:010A mov ah,02
0D03:010C mov dl,41
0D03:010E int 21
0D03:0110 jmp 0100
0D03:0112 mov ah,00h
0D03:0114 int 21
0D03:0116