ASSEMBLY
Cleivson Arruda
csa3@cin.ufpe.br / cleivson.tb@gmail.com

Assembly é uma linguagem de baixo
nível, chamada freqüentemente de
“linguagem de montagem”

É uma linguagem considerada difícil,
principalmente porque o programador
precisa conhecer a estrutura da máquina
para usá-la
Assembly

A linguagem Assembly é atrelada à
arquitetura de uma certa CPU, ou seja,
ela depende completamente do hardware

Cada família de processador tem sua
própria linguagem assembly (Ex. X86,
ARM, SPARC, MIPS)

Por essa razão Assembly não é uma
linguagem portável, ao contrário da
maioria das linguagens de alto nível
Assembly

Antes do assembly:
◦ adição do microprocessador de sinal digital
(DSP) TMS-320C54x da Texas Instruments
 0000000SIAAAAAAA
◦ instrução de adição dos computadores B-200,
B-300 e B-500 da Burroughs Corporation:
 Campo: O M N AAA BBB CCC
 Código: 1 2 3 100 200 300
Assembly

As primeiras linguagens Assembly
surgiram na década de 50, na chamada
segunda geração das linguagens de
programação

A segunda geração visou libertar os
programadores de dificuldades como
lembrar códigos numéricos e calcular
endereços
Assembly - História

Assembly foi muito usada para várias
aplicações até os anos 80, quando foi
substituída pelas linguagens de alto nível

Isso aconteceu principalmente pela
necessidade de aumento da produtividade
de software
Assembly - História

Atualmente Assembly é usada para
manipulação direta de hardware e para
sistemas que necessitem de performance
crítica

Device drivers, sistemas embarcados de
baixo nível e sistemas de tempo real são
exemplos de aplicações que usam
Assembly
Assembly - História

A linguagem Assembly é de baixo nível,
porém ainda precisa ser transformada na
linguagem que a máquina entende

Quem faz isso é o Assembler. O
Assembler é um utilitário que traduz o
código Assembly para a máquina
Assembly - Assembler

Exemplo:
Antes -> mov al, 061h (x86/IA-32)
Depois -> 10110000 01100001
Assembly - Assembler

Byte, Word e Dword são blocos de dados
básicos. O processador trabalha com o
tamanho de dados adequados para
executar as instruções

Um byte possui 8 bits, um word possui 16
bits ou 2 bytes e um dword possui 32 bits
ou 4 bytes
Assembly - Fundamentos

Em Assembly é comum representar os
números na forma hexadecimal. Isso
acontece porque é interessante visualizar
o número na forma de dados

A representação hexadecimal facilita o
tratamento de números muito grandes e
permite saber quais bits estão “ligados”
ou “desligados”
Assembly - Fundamentos

Um algarismo hexadecimal pode ser
representado por quatro algarismos
binários

Logo um byte pode ser representado
como dois números hexa, um word como
quatro números hexa e um dword como
oito números hexa
Assembly - Fundamentos
Binário
Hexa
Decimal
Tipo
10000000
80
128
byte
8001
32.769
word
11111111111111
11
FFFF
65.535
word
11111111111111
11111111111111
1111
FFFFFFFF
4.294.967.2 dword
95
10000000000000
01
Assembly - Fundamentos

Registradores são áreas especiais dentro
do processador que são mais rápidas que
operandos de memória.

Como vamos trabalhar com o processador
Intel, existem apenas 8 registradores de
uso geral
Assembly - Registradores
São eles:
EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP


Os registradores ESP e EBP só devem ser
usados preferencialmente para trabalhar
com a pilha
Assembly - Registradores
Assembly - Registradores

Nos registradores de uso geral (Exceto
ESI e EDI) é permitido usar três
modos de acesso diferentes, ilustrados
pela figura abaixo:

EAX -> Chamado de “Acumulador”,
geralmente é usado para operações
aritméticas e para guardar resultados

EBX -> Chamado de “Base”, geralmente é
usado para armazenar dados em geral e
para endereços de memória
Assembly - Registradores

ECX -> Chamado de “Contador”, como o
nome já diz é usado como contador,
principalmente para controlar loops

EDX -> Chamado de registrador de
dados, é usado geralmente para guardar
o endereço de uma variável na memória
Assembly - Registradores

ESI e EDI -> Respectivamente “Source
Index” e “Destination Index”, são menos
usados do que os registradores descritos
anteriormente. Geralmente usa-se ESI e
EDI para movimentação de dados, com
ESI guardando o endereço fonte de uma
variável e EDI guardando o endereço
destino. Não podem ser acessados em
nível de Byte.
Assembly - Registradores

ESP e EBP -> Respectivamente “Stack
Pointer” e “Base Pointer”, só devem ser
usados para manipulação da pilha. O
Registrador ESP guarda a referência para
o topo da pilha, enquanto o registrador
EBP é usado para “andar” pela pilha
Assembly - Registradores

Entre os registradores que não são de uso
geral, existe um registrador muito
relevante para o programador, o
registrador flags

Através do registrador flags podemos
saber se dois valores são iguais, se um é
maior que outro ou se um valor é
negativo, além de outras informações
Assembly - Registradores
Assembly - Registradores





O => Overflow
D => Direction
I => Interrupt Enable
T => Trap
S => Signal
Assembly - Registradores




Z => Zero
A => Auxiliar Carry
P => Parity
C => Carry

Todos os programas fazem uso da pilha
em tempo de execução, porém nas
linguagens de alto nível não é preciso se
preocupar com o funcionamento da pilha

Já em Assembly, o programador precisa
saber trabalhar com a pilha, pois ela é
uma ferramenta importante
Assembly - Pilha

A pilha é uma área de dados existente na
memória em tempo de execução, na qual
seu programa pode armazenar dados
temporariamente
 O processador é rápido no acesso à pilha,
tanto para escrever quanto para ler
Assembly - Pilha

As principais funcionalidades da pilha são:
- Preservar valores de registradores em
funções
- Preservar dados da memória
- Transferir dados sem usar registradores
- Reverter a ordem de dados
- Chamar outras funções e depois retornar
- Passar parâmetros para funções
Assembly - Pilha
push
push
push
push
push
push
push
push
ax
bx
cx
dx
ds
es
di
si
pusha
push es, ds
popa
pop es, ds
Assembly – Exemplo Pilha

Movimentação de dados:
- mov destino, fonte (Sintaxe Intel)
- mov fonte, destino (Sintaxe AT&T)

Obs: Nas instruções AT&T, é necessário
informar o tamanho do dado com que se
está trabalhando
Assembly - Instruções
Intel
AT&T
mov eax, 1
movl $1, %eax
mov ebx, 0ffh
movl $0xff, %ebx
mov eax, [ebx]
movl (%ebx), %eax
mov eax, [ebx+3]
movl 3(%ebx), %eax
Assembly - Instruções

Instrução de soma:
- add destino, fonte (Sintaxe Intel)
Exemplo: add eax,[ebx+ecx]
- add fonte, destino (Sintaxe AT&T)
Exemplo: addl (%ebx,%ecx),%eax
Assembly - Instruções

Instrução de subtração:
- sub destino, fonte (Sintaxe Intel)
Exemplo: sub eax,ebx
- sub fonte, destino (Sintaxe AT&T)
Exemplo: subl %ebx,%eax
Assembly - Instruções

Instruções de operações lógicas:
- and/or/xor destino, fonte (Sintaxe Intel)
Exemplo: and ax,bx
- and/or/xor fonte, destino (Sintaxe AT&T)
Exemplo: andw %bx,%ax
Assembly - Instruções

Instrução de comparação:
- cmp operando1, operando2 (Sintaxe
Intel)
Exemplo: cmp 08h, eax
- cmp operando1, operando2 (Sintaxe
AT&T)
Exemplo: cmp $0x8, %eax
Assembly - Instruções

Instruções de jump:
“Pulo” incondicional:
- jmp [100] (Sintaxe Intel)
- jmp eax (Sintaxe Intel)
- jmp *100 (Sintaxe AT&T)
- jmp *%eax (Sintaxe AT&T)
Assembly - Instruções
“Pulo” condicional:
- je [100] (Sintaxe Intel)
- jne eax (Sintaxe Intel)
- je *100 (Sintaxe AT&T)
- jne *%eax (Sintaxe AT&T)
Assembly - Instruções

Instruções de manipulação da pilha:
- push eax (Sintaxe Intel)
- push %eax (Sintaxe AT&T)
- pop eax (Sintaxe Intel)
- Pop %eax (Sintaxe AT&T)
Assembly - Instruções

O código Assembly é dividido em seções.
As principais seções no Linux são:
- section .data -> A seção .data é usada
para declarar variáveis inicializadas.
Porém essas “variáveis” não mudam no
decorrer do programa. Essa seção é
usada geralmente para definir nomes de
arquivos, constantes, entre outros.
Assembly - Seções
- Exemplo:
section .data
mensagem: db 'Hello world!'
msglength: equ 12
Assembly - Seções
- section .bss -> É a seção usada para
declarar as variáveis do programa
- Exemplo:
section .bss
nomearq: resb 230 ;Reserva 230
bytes
numero: resb 1 ;Reserva 1 byte
array: resw 10 ;Reserva 10 words
Assembly - Seções
- section .text -> Essa é a seção onde o código do
programa é escrito
- Exemplo:
section .text
global _start
_start:
.
.
.
.
.
.
.
.
.
Assembly - Seções

Interrupções são chamadas ao
processador requisitando um serviço

O nome interrupção vem do fato de que o
processador tem sua atividade atual
interrompida quando recebe um sinal de
chamada
Assembly - Interrupções

Quando isso acontece, o processador
salva o processo atual e executa a rotina
daquela interrupção

Após a execução da rotina, que
geralmente está armazenada em uma
tabela na memória RAM, o processador
retorna ao processo em que estava
anteriormente
Assembly - Interrupções
Para se chamar uma interrupção no Linux,
é feito o seguinte processo:
- Coloca-se o número da interrupção no
registrador EAX
- Coloca-se os argumentos requeridos
pela interrupção nos devidos registradores
- Chama-se a interrupção
 O resultado geralmente será retornado
em EAX

Assembly - Interrupções
- Exemplo (Sintaxe Intel):
mov eax,1 ; Interrupção Exit
mov ebx,0 ; Argumento em EBX
int 80h ; Chamada da interrupção
- Exemplo (Sintaxe AT&T):
movl $1,%eax
movl $0, %ebx
int $0x80
Assembly - Interrupções
Assembly - Interrupções

Um programa é constituido por várias
regiões de memória.
◦
◦
◦
◦
Pilha
Heap
Código
Dados
Assembly – Organização do
Programa

Hello World (Sintaxe Intel)
section .data
hello: db 'Hello world!',10 ; A string 'Hello World!‘ e um linefeed
helloLenght: equ $-hello ; Tamanho da string hello
section .text
global _start
_start:
mov eax,4 ; Interrupção de escrita (sys_write)
mov ebx,1 ; Argumento que indica modo de escrita
mov ecx,hello ; Argumento que indica o endereço da string
mov edx,helloLenght ; Argumento que indica o tamanho da string
int 80h ; Chamada da interrupção
mov eax,1 ; Interrupção exit (sys_exit)
mov ebx,0 ; Argumento da interrupção
int 80h ; Chamada da interrupção
Assembly - Exemplo

Hello World (Sintaxe AT&T)
.data hello:
.string "Hello World!\n"
.text
.globl main
main:
mov $4,%eax
mov $1,%ebx
mov $hello,%ecx
mov $13,%edx
int $0x80
mov $1,%eax
mov $0,%ebx
int $0x80
Assembly - Exemplo
.stack
.data
include arquivo1.asm
include arquivo2.asm
.code
start:
include arquivo3.asm
end start
Assembly - Include
.data
arquivo1
arquivo2
arquivo3
arquivo4
arquivo5
arquivo6
arquivo7
arquivo8
db
db
db
db
db
db
db
db
'dat/arquivo1'
'dat/arquivo2'
'dat/arquivo3'
'dat/arquivo4'
'dat/arquivo5'
'dat/arquivo6'
'dat/arquivo7'
'dat/arquivo8'
,
,
,
,
,
,
,
,
0
0
0
0
0
0
0
0
Assembly – Carregar Arquivos
.text
call NomeProcedimento
NomeProcedimento PROC NEAR
mov ax, 0x0F;
ret
NomeProcedimento ENDP
Assembly - Procedimentos
Exemplo
mov ah, 0
mov al, 13h
int 10h


; modo video 320*200
Video Display Area (RAM)
◦ A000 -> gráficos de alta resolução
◦ B000
◦ B800
Assembly – Interrupção de Vídeo







www.cin.ufpe.br/~clac/infra_de_software
http://www.wagemakers.be/english/doc/vga
http://www.scribd.com/doc/13290971/INTERRUPCOES
http://maven.smith.edu/~thiebaut/ArtOfAssembly/artof
asm.html
http://www.xs4all.nl/~smit/asm04001.htm#vga
http://arapaho.nsuok.edu/~kingw/CS3173/Chapter9.ht
m
http://burks.bton.ac.uk/burks/language/asm/asmtut/as
m8.htm
Assembly – Referências
Download

ASSEMBLY-Aula1