A linguagem 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
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 A P C
=> Zero => Auxiliar Carry => Parity => 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 Video
; modo video 320*200
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/ 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
Assembly – Referências