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

—  Cadafamí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
—  Assemblyfoi 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
—  Alinguagem Assembly é de baixo nível,
porém ainda precisa ser transformada na
linguagem que a máquina entende

—  Quemfaz 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

—  Umbyte possui 8 bits, um word possui 16

bits ou 2 bytes e um dword possui 32 bits
ou 4 bytes

Assembly - Fundamentos
—  EmAssembly é 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
8001 32.769 word
01
11111111111111
11
FFFF 65.535 word
11111111111111
11111111111111
FFFFFFFF 4.294.967.2 dword
1111 95

Assembly - Fundamentos
—  Registradores
são áreas especiais dentro
do processador que são mais rápidas que
operandos de memória.

—  Comovamos 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 ax pusha
push bx push es, ds
push cx popa
push dx pop es, ds
push ds
push es
push di
push si

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

—  Onome interrupção vem do fato de que o

processador tem sua atividade atual
interrompida quando recebe um sinal de
chamada

Assembly - Interrupções
—  Quandoisso 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
—  Umprograma é 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 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 – Carregar Arquivos

.text
call NomeProcedimento

NomeProcedimento PROC NEAR

mov ax, 0x0F;
ret
NomeProcedimento ENDP

Assembly - Procedimentos
—  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 – 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