Linguagem Assembly: História, Fundamentos e Registradores

Prévia do material em texto

A linguagem ASSEMBLY 
Assembly 
—  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 - História 
—  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 - Assembler 
—  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 - Fundamentos 
—  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 
 
10000000000000
01 
8001 32.769 word 
11111111111111
11 
FFFF 65.535 word 
11111111111111
11111111111111
1111 
FFFFFFFF 4.294.967.2
95 
dword 
Assembly - Registradores 
—  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 
—  Nos registradores de uso geral (Exceto 
ESI e EDI) é permitido usar três 
modos de acesso diferentes, ilustrados 
pela figura abaixo: 
Assembly - Registradores 
—  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 
—  O => Overflow 
—  D => Direction 
—  I => Interrupt Enable 
—  T => Trap 
—  S => Signal 
Assembly - Registradores 
—  Z => Zero 
—  A => Auxiliar Carry 
—  P => Parity 
—  C => Carry 
Assembly - Pilha 
—  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 – Exemplo Pilha 
push ax 
push bx 
push cx 
push dx 
push ds 
push es 
push di 
push si 
 
 
pusha 
push es, ds 
popa 
pop es, ds 
 
Assembly - Instruções 
—  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 - Seçõ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 - Interrupçõ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 – Organização do 
Programa 
—  Um programa é constituido por várias 
regiões de memória. 
◦  Pilha 
◦  Heap 
◦  Código 
◦  Dados 
Assembly - Exemplo 
—  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 - Include 
.stack 
.data 
 include arquivo1.asm 
 include arquivo2.asm 
.code 
start: 
 include arquivo3.asm 
end start 
Assembly – Carregar Arquivos 
.data 
arquivo1 db 'dat/arquivo1' , 0 
arquivo2 db 'dat/arquivo2' , 0 
arquivo3 db 'dat/arquivo3' , 0 
arquivo4 db 'dat/arquivo4' , 0 
arquivo5 db 'dat/arquivo5' , 0 
arquivo6 db 'dat/arquivo6' , 0 
arquivo7 db 'dat/arquivo7' , 0 
arquivo8 db 'dat/arquivo8' , 0 
 
 
Assembly - Procedimentos 
.text 
call NomeProcedimento 
 
NomeProcedimento PROC NEAR 
mov ax, 0x0F; 
ret 
NomeProcedimento ENDP 
 
Assembly – Interrupção de Vídeo 
—  Exemplo 
mov ah, 0 
mov al, 13h ; modo video 320*200 
int 10h 
 
—  Video Display Area (RAM) 
◦  A000 -> gráficos de alta resolução 
◦  B000 
◦  B800 
 
 
Assembly – Referências 
—  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/
artofasm.html 
—  http://www.xs4all.nl/~smit/asm04001.htm#vga 
—  http://arapaho.nsuok.edu/~kingw/CS3173/
Chapter9.htm 
—  http://burks.bton.ac.uk/burks/language/asm/asmtut/
asm8.htm