A linguagem assembly é uma linguagem de baixo nível dependente da arquitetura da CPU e não é portável entre diferentes hardware. Embora tenha sido amplamente usada até os anos 80, atualmente é utilizada em aplicações críticas de desempenho, como drivers de dispositivos e sistemas embutidos. A programação em assembly exige conhecimento profundo da estrutura de hardware e possui suas próprias convenções, como a manipulação de registradores e pilhas.

1. A linguagem ASSEMBLY

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

23. Assembly - Registradores
— Z => Zero
— A => Auxiliar Carry
— P => Parity
— C => Carry

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

29. 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

30. 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

31. 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

32. 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

33. 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

34. 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)

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.

38. Assembly - Seções
- Exemplo:
section .data
mensagem: db 'Hello world!'
msglength: equ 12

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

45. Assembly - Interrupções

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

49. Assembly - Include
.stack
.data
include arquivo1.asm
include arquivo2.asm
.code
start:
include arquivo3.asm
end start

50. 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

51. Assembly - Procedimentos
.text
call NomeProcedimento
NomeProcedimento PROC NEAR
mov ax, 0x0F;
ret
NomeProcedimento ENDP

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

53. 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