Professor: Jeferson Knop

Introdução básica a linguagem Assembler

Assembler é uma linguagem de baixo nível, que basicamente consiste em um

conjunto de sentenças que representam instruções em linguagem de máquina.
Assembler permite acesso direto do usuário ao nível de hardware, e lhe dá muito maior
controle e flexibilidade sobre o PC.

• Registradores

Quando se trabalha com Assembler, faz-se muito o uso de registradores, imagine-os

como sendo variáveis já definidas. Os mais comuns estão listados abaixo:

* AX - o acumulador. Compreende AH e AL, os bytes alto e baixo de AX. Comumente

usado em operações matemáticas e de E/S.

* BX - a base. Compreende BH e BL. Comumente usado como uma base ou

registrador apontador.

* CX - o contador. Compreende CH e CL. Usado freqüentemente em loops.

* DX - o deslocamento, similar ao registrador de base. Compreende DH e DL.

Estes registradores são definidos como registradores de uso geral, pois podemos
realmente armazenar qualquer coisa que quisermos neles. São também registradores de
16 bits, o que significa que podemos armazenar um inteiro positivo de 0 a 65535, ou um
inteiro com sinal de -32768 to 32768.
Entendendo a parte alta e baixa do byte. AX tem um intervalo de 0 até FFFFh. Isto
significa que existe um intervalo de 0 até FFh para AH e AL. Se tivermos de armazenar
A61Dh em AX, AH conterá A6h, e AL conterá 1Dh.

o Os registradores de segmento

Eles são imensamente úteis,mas podem ser também perigosos.

 * CS - o segmento de código. O bloco de memória onde o código é armazenado. NÃO
brinque com esse, a menos que saiba o que está fazendo.

* DS - o segmento de dados. A área na memória onde os dados são armazenados.

Durante operações de bloco, quando grandes blocos de dados são movidos, este é o
segmento a que a CPU comumente se refere.

* ES - o segmento extra. Apenas outro segmento de dados, mas este é comumente

usado quando se quer acessar o vídeo.

* SS - É o segmento de pilha, em que a CPU armazena endereços de retorno de sub-

rotinas. Tome cuidado com ele.

* SI - O índice de fonte. Freqüentemente usado para movimentações de blocos de

instruções. Este é um ponteiro que, com um segmento, geralmente DS, é usado pela CPU
para leitura.

* DI - o índice de destino. Novamente, você o usará muito. Um outro ponteiro que, com
um segmento, geralmente ES, é usado para escrita pela CPU.

* BP - o apontador da base, usado em conjunto com o segmento de pilha. Nós não

vamos usá-lo muito.

* SP - o apontador da pilha, comumente usado com o segmento de pilha. NÃO brinque

com isso de jeito nenhum. Tá show, não tá???

Ainda há outros registradores e flags mas não se faz necessário trabalhar com estes por
enquanto.

• O conjunto de instruções do 8086

Entendido o que são registradores, agora vamos ver como usá-los, e como se codifica
em Assembler? Bem, primeiro você precisa de algumas instruções. As seguintes
instruções podem ser usadas em todas as CPU's do 8086 para cima.

* MOV <dest>, <valor> - MOVE. Esta instrução permite MOVER um valor para uma
posição na memória.

Ex.: MOV AX, 13h

Ex.: (Em Pascal) AX := $13;

* INT <número> - INTERRUPÇÃO. Esta instrução gera uma interupção.Você pode

pensar nisso como sendo quase uma procedure.

Ex.: INT 10h

 * ADD <dest> <valor> - ADICIONA. Esta instrução soma um número ao valor
armazenado em “dest” ou soma dois registradores.

Ex: MOV AX, 0h ; AX agora é igual a 0h

ADD AX, 5h ; AX agora é igual a 5h
ADD AX, 10h ; AX agora é igual a 15h

* SUB <dest> <valor> - SUBTRAI. Esta instrução subtrai um número a partir do valor
armazenado em “dest” ou subtrai um registrador do outro.

Ex: MOV AX, 13h ; AX agora é igual a 13h (19 dec)

SUB AX, 5h ; AX agora é igual a 0Eh (14 dec)

* MUL <dest> <valor> - MULTIPLICA. Esta instrução multiplica um número pelo valor
armazenado em “dest” ou multiplica dois registradores.

Ex: MOV AX, 0h ; AX agora é igual a 0h

MUL AX, 5h ; AX agora é igual a 0h
MUL AX, 10h; AX agora é igual a 0h

* DIV <dest> <valor> - DIVIDE. Esta instrução divide valor armazenado em “dest” por
um número ou divide um registrador do outro.

Ex: MOV AX, 10h ; AX agora é igual a 10h (10 dec)

MOV BX, 02h ; BX agora é igual a 02h (02 dec)
DIV AX, BX ; AX agora é igual a 05h (05 dec)

* DEC <registrador> - DECREMENTA algo.

Ex: MOV AX, 13h ; AX agora é igual a 13h

DEC AX ; AX agora é igual a 12h

* INC <registrador> - INCREMENTA algo.

Ex: MOV AX, 13h ; Adivinha...

INC AX ; AX = AX + 1

* JMP <posição> - PULA para uma posição.

Ex: JMP 020Ah ; Pula para a instrução em 020Ah

JMP @MyLabel ; Pula para @MyLabel.

TEMOS OUTRAS 28 INTRUÇÕES DE JUMP PARA ENTENDER DEPOIS...

* CALL <procedimento> - CHAMA uma subfunção.

Ex: Procedure MyProc;

Begin { MyProc }
{ ... }
End; { MyProc }

Begin { Main }
 Asm
CALL MyProc ; Chamada de procedimento
End;
End.

Ou: CALL F6E0h ; Chama subfunção em F6E0h

* PUSH <registrador> - PUSH (coloca algo na pilha)

* POP <registrador> - POP (retira ele de volta)

Ex: MOV AX, 03h ; AX = 03h

PUSH AX ; PUSH AX na pilha (coloca no topo)
MOV AX, 04Eh ; AX = 04Eh
.
.
.
POP AX ; AX = 03h ou POP BX ; BX = 03h

• Flags

Funcionam como sinalizadores.

As flags são apenas um bit de memória e se localizam dentro do processador. Como cada
flag é apenas um bit, num dado momento elas só podem ser 1 ou 0 ("setada" ou
"zerada"). Existem seis flags usadas para indicar o resultado de certas instruções.
Um uso comum das flags é o de desviar a execução para um ponto em particular do
código usando instruções de salto condicinal. Estas instruções farão o salto ou não
dependendo do estado de uma ou mais flags. Apenas cinco das flags podem ser usadas
deste modo - zero, sinal, carry, overflow e paridade. A sexta flag (carry auxiliar) e a
sétima flag (flag de direção) são lidas por outro tipo de instrução.

Legenda:

SF - Flag de Sinal;
ZF - Flag de Zero;
AF - Flag Auxiliar;
PF - Flag de Paridade.
CF - Flag de Carry (vai um).

CMP - (COMPARE) compara dois números e reflete a comparação nos FLAGS. Para usá-
la você faria algo desse tipo:

* CMP AX, BX então seguir com uma instrução como essas abaixo:

Ex:
Volta: DEC AX ; Decrementa AX
MOV CX, AX ; Move o conteúdo de AX para CX
CMP AX, BX ; Compara AX com BX
JNE Volta ; Se AX for diferente de BX ele pula caso contrário “Volta”
Comparação sem sinal:

* JA - pula (jump) se AX foi MAIOR que BX;

* JAE - pula se AX foi MAIOR ou IGUAL a BX;
* JB - pula se AX foi MENOR que BX;
* JBE - pula se AX foi MENOR ou IGUAL a BX;
* JNA - pula se AX foi NÃO MAIOR que BX;
* JNAE - pula se AX foi NÃO MAIOR ou IGUAL a BX;
* JNB - pula se AX foi NÃO MENOR que BX;
* JNBE - pula se AX foi NÃO MENOR ou IGUAL a BX;
* JZ - pula se o flag de ZERO está setado - o mesmo que JE;
* JE - pula se AX for IGUAL a BX;
* JNZ - pula se o flag de ZERO NÃO está setado - o mesmo que JNE;
* JNE - pula se AX NÃO for IGUAL a BX;

Comparação com sinal:

* JG - pula (jump) se AX foi MAIOR que BX;

* JGE - pula se AX foi MAIOR ou IGUAL a BX;
* JL - pula se AX foi MENOR que BX;
* JLE - pula se AX foi MENOR ou IGUAL a BX
* JNG - pula se AX foi NÃO MAIOR que BX
* JNGE - pula se AX foi NÃO MAIOR ou IGUAL a BX;
* JNL - pula se AX foi NÃO MENOR que BX;
* JNLE - pula se AX foi NÃO MENOR ou IGUAL a BX;
* JZ - pula se o flag de ZERO está setado - o mesmo que JE;
* JE - pula se AX for IGUAL a BX;
* JNZ - pula se o flag de ZERO NÃO está setado - o mesmo que JNE;
* JNE - pula se AX NÃO for IGUAL a BX;

Pouco Comuns:

* JC - pula se o flag de CARRY está setado;

* JNC - pula se o flag de CARRY NÃO está setado;
* JO - pula se o flag de OVERFLOW está setado;
* JNO - pula se o flag de OVERFLOW NÃO está setado;
* JP - pula se o flag de PARIDADE está setado;
* JNP - pula se o flag de PARIDADE NÃO está setado;
* JPE - pula se a PARIDADE for PAR - o mesmo que JP;
* JPO - pula se a PARIDADE for ÍMPAR - o mesmo que JNP;
* JS - pula se o flag de SINAL NÃO está setado;
* JNS - pula se o flag de SINAL está setado.
 • Interrupções

o Solicitação de interrupção à nível de Sistema Operacional (S.O.)

Int 21h
Função 02h
Uso: Mostra um caracter na tela
Registradores de chamada: AH = 02h e DL valor do caracter a ser exibido

Ex: MOV AH, 02h

MOV DL, 61h ou MOV DL, ‘a’
INT 21h
INT 20h

Int 21h
Função 01h
Uso: Ler um caracter do teclado
Registrador de chamada: AH = 01h
Registrador de retorno: AL onde fica o caracter lido

Ex: MOV AH, 01h

INT 21h
INT 20h

o Solicitação de interrupção à nível da Bios

Int 16h
Função 00h
Uso: Ler um caracter do teclado
Registrador de chamada: AH = 00h
Registrador de retorno: AL onde fica o caracter lido

Ex: MOV AH,00h

INT 16h
INT 20h
Int 10h
Função 0Ah
Uso: Imprimir caracteres na tela
Registrador de chamada: AH = 0Ah e AL caracter que será impresso

Ex: MOV AH, 0Ah

MOV AL, ‘a’
INT 10h
INT 20h

o Solicitação de interrupção à nível de Hardware

Função IN
Uso: Lê o dado que está na porta (definida pelo endereço)
Registradores de chamada: AX onde será armazenado o dado lido e DX endereço da
porta.

IN AX, DX

Ex: MOV DX, 379h

INT AX, DX
INT 20h

Função OUT
Uso: Enviar um dado para a saída da impressora
Registradores de chamada: AX dado à ser impresso e DX informa o destino do dado.

OUT DX, AX

Ex: MOV DX, 378h

MOV AX, 61h
OUT DX, AX
INT 20h