Você está na página 1de 9

Programando em Assembly

precisa-se saber exatamente como interpretar &


gerenciar a memria e como usar instrues de
baixo nvel para o processamento
No existem tipos e variveis (apenas bytes na
memria)
no tem-se o auxlio da verificao de tipos do
compilador, que ajudam a detectar vrios erros
cdigo assembly altamente dependente da
mquina -> perde-se a portabilidade de uma
linguagem de alto nvel

Gerao de Cdigo objeto


Arquivos fonte
p1.c p2.c
Comando de compilao:
gcc -O p1.c p2.c -o p
Otimizaes (-O)
text

C program (p1.c p2.c)


Compiler (gcc -S)

text

Asm program (p1.s p2.s)


Assembler (g
(gcc or as))

binary

Object program (p1.o p2.o)

Static libraries
(.a)

Linker (gcc or ld)


binary

Executable program (p)

Diferenas entre assemblers


Formato Intel/Microsoft

Formato GAS/Gnu

lea
sub
cmp
mov

leal
subl
cmpl
movl

eax,[ecx+ecx*2]
esp,8
dword ptr [ebp-8],0
eax,dword ptr [eax*4+100h]

(%ecx,%ecx,2),%eax
$8,%esp
$0,-8(%ebp)
$0x100(,%eax,4),%eax

Diferenas Intel/Microsoft X GAS


Operandos em ordem contrria
mov Dest, Src
movl Src, Dest
Constantes no precedidas pelo $, hexadecimais com h
no final
100h
$0x100
Tamanho do operando indicado por operando ou sufixo de
instruo
sub
subl
entre outros

Viso do programador Assembly


CPU
Registradores

EFLAGS

Memria
A
L
U
PC

Endereos
Dados
Instrues

Estado da CPU
PC
Program Counter
Endereo da prxima instruo
Registradores
g
Acesso rpido a dados/endereos
Registrador EFLAGS (Cdigos de
condio)
Armazena informao sobre resultado
da ltima operao artimtica
(overflow?, zero?, negativo?)
Usados para desvios condicionais

Codigo objeto
Dados do programa
Bibliotecas
Dados do S.O.
Pilha
(Stack)

Memria plana
Array de bytes endereveis
Contm cdigo, dados e pilha
Pilha usada para gerenciar
chamada a procedimentos

Caractersticas do Assembly
Tipos de dados bsicos
integer de 1, 2, ou 4 bytes
Valores int, short, long int, char
Endereos (equivalente a untyped pointer)
Dados em ponto flutuante de 4, 8, ou 10 bytes
No existem tipos de dados complexos como arrays ou structs
Apenas bytes alocados de forma contgua na memria

Operaes primitivas
Funes aritmticas sobre o contedo de registradores ou dados
na memria
Transferncia
T
f i d
de d
dados
d ((mov)) entre
t memria
i e registradores
i t d
Carregar dado de memria para registrador
Armazenar dado em registrador para memria
Controle de fluxo de execuo
Desvios (jump) incondicionais
Desvios condicionais (dependendo de um bit em EFLAGS)

Registradores de Propsito Geral


So usados para armazenamento
temporrio de dados e endereos da
memria (uso: %nome)
Capacidade: 32 bits (=word do IA32)
Todos podem armazenar tb. dados
menores:
%eax

%ax

16

%edx
%ecx
%ebx
%esi

%ah
32

%eax

%al
8

%edi
%esp

%esp e %ebp reservados para uso


%ebp
especial (p de ponteiro)
Exemplos:
movl %edx, %eax
%edx %eax
incl %ecx
%ecx+1 %ecx
addl %eax, $0xff
%eax+255 %eax

O Registrador EFLAGS
Seus bits indicam a ocorrncia de eventos (bit carry) ou o
resultado da ltima operao aritmtica, p.ex. t = a+b:
OF

SF

ZF

CF

PF

...

OF (Overflow flag)=1
se houve overflow (negativo ou
positivo) de representao com sinal
SZ (Sign flag)=1
se t < 0
ZF (Zero flag)=1
se t ==0
CF (Carry flag)=1
se houve overflow de unsigned
PF (Parity flag)=1
se o byte menos significativo
possui o nmero par de bits 1
Os bits de EFLAGS so consultados por instrues de desvio condicional

Transferncia de bytes
Instruo mais frequente
movl fonte, destino
Operando fonte pode ser:
Contedo de registrador
modo registrador
Contedo de memria apontado por registrador
modo memria
Constante
modo imediato
Smbolo
modo direto
Combinaes dos anteriores

Operando destino pode ser:


Registrador
Memria apontada por registrador
Combinaes dos anteriores

Obs:
Operando em modo memria caracterizado pelo uso de parenteses ( )
Exemplo:
movl (%ebx), %ecx
// Mem(ebx) Recx

Combinaes de operandos de movl


Fonte

movl

Destino

Exemplo

Equiv. em C

movl $0x4,%eax

temp = 0x4;

movl $-147,(%eax)

*p = -147;

Imed

Reg
Mem

Reg

Reg
Mem

movl %eax,%edx

temp2 = temp1;

movl %eax,(%edx)

*p = temp;

Mem

Reg

movl (%eax),%edx

temp = *p;
p;

Obs: No possvel fazer transferncia direta


memria-memria com uma nica instruo

Exemplos
Modo registrador
movl %eax, %ecx

// Reax Recx

Modo imediato
movl $Ox100, %eax

// const Reax

Modo memria forma: base (reg)


movl %eax, 16(%ecx)
movl %eax,
, (
(%ecx)
)

// Reax Mem[16+Recx ]
// Reax Mem[R
[ ecx]

Modo direto
movl table, %ebx

// Mem[table] Rebx

Todas as formas de operandos

Figura 3.3 (p.137)

Sufixos
Para muitas instrues existem vrias variantes,
definidas pelo seu sufixo (e.g. movl, addl,
decl)
Sufixo indica o tamanho do operando (resultado
armazenado alinhado com o byte menos
significativo)
b = tamanho de 1 byte
movb $0, (%eax)

w = tamanho de 2 bytes

//0 Mem[Reax ]

movw $0, (%eax)

l = tamanho de 4 bytes
movl $0, (%eax)

Grupos de Instrues

Movimento de dados
Aritmtica inteira
Instrues lgicas
Instrues de controle de fluxo
Instrues em ponto flutuante

Exemplos: Aritmtica Inteira & Instrues


Lgicas
Instrues de dois operandos
Formato
addl Src,Dest
subl Src,Dest
imull Src,Dest
sall Src,Dest
sarl Src,Dest
shrl Src,Dest
Src Dest
xorl Src,Dest
andl Src,Dest
orl Src,Dest

Efeito
Dest + Src Dest
Dest Src Dest
Dest * Src Dest
Dest << Src Dest
Dest >> Src Dest
Dest >> Src Dest
Dest ^ Src Dest
Dest & Src Dest
Dest | Src Dest

aritmtico
lgico
xor bit-a-bit
and bit-a-bit
or bit-a-bit

Exemplos: Aritmtica Inteira & Instrues


Lgicas
Instrues de um operando
Formato
F
t
incl Dest
decl Dest
negl Dest
notl Dest

Efeito
Ef
it
Dest +
Dest
- Dest
~ Dest

1 Dest
1 Dest
Dest
Dest

Declarao de Dados
Assembler do gcc permite declarao de
variveis
i i d
de vrios
i titipos ((na seo
d
de
dados .data).
Exemplos:
vet: .byte
48, 0b00110000, 0x30, 0
s1: .string o resultado eh de %d\n

Resumo: Mquinas abstratas


Modelos de mquinas
Ling. C
memria

procedimentos

Dados
1)
) Char
2) short
2) int, float
3) double
4) struct, array
5) pointer

Assembly
mem
Stack

regs

alu

Cond.
processor
Codes

1)
2)
2)
3)
4)
5)

Byte
2-byte word
4-byte word
8-byte long word
Alocao contgua de bytes
Endereo do byte inicial

Exerccio
Tentem entender...

void swap(int *xp, int *yp)


{
int t0 = *xp;
int t1 = *yp;
*xp = t1;
*yp
yp = t0;
}

swap:
pushl %ebp
movl %esp,%ebp
pushl %ebx
movl
movl
movl
movl
l
movl
movl

Inicializao
(ignorar)

12(%ebp),%ecx
8(%ebp),%edx
(%ecx),%eax
(%edx),%ebx
%
%eax,(%edx)
(% d )
%ebx,(%ecx)

yp
xp

movl -4(%ebp),%ebx
Finalizao
movl %ebp,%esp
(ignorar)
popl %ebp
ret