2. 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
3. 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
4. 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
5. 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
6. 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
7. 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
8. 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
9. Assembly - Assembler
— Exemplo:
Antes -> mov al, 061h (x86/IA-32)
Depois -> 10110000 01100001
10. 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
11. 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”
12. 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
13. 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
14. 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
15. 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
16. Assembly - Registradores
— Nos registradores de uso geral (Exceto
ESI e EDI) é permitido usar três
modos de acesso diferentes, ilustrados
pela figura abaixo:
17. 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
18. 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
19. 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.
20. 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
21. 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
22. Assembly - Registradores
— O => Overflow
— D => Direction
— I => Interrupt Enable
— T => Trap
— S => Signal
24. 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
25. 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
26. 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
27. 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
28. 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
35. Assembly - Instruções
“Pulo” condicional:
- je [100] (Sintaxe Intel)
- jne eax (Sintaxe Intel)
- je *100 (Sintaxe AT&T)
- jne *%eax (Sintaxe AT&T)
36. 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)
37. 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.
39. 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
40. Assembly - Seções
- section .text -> Essa é a seção onde o código do
programa é escrito
- Exemplo:
section .text
global _start
_start: . . .
. . .
. . .
41. 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
42. 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
43. 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
44. 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
46. Assembly – Organização do
Programa
— Um programa é constituido por várias
regiões de memória.
◦ Pilha
◦ Heap
◦ Código
◦ Dados
47. 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
48. 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
52. 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
