Introduo ao Assembly

Movimentao de Dados Operaes Aritmticas e Lgicas

Representao de Programas
Computadores executam cdigo de mquina
sequncias de bytes que codificam operaes

Um compilador gera o cdigo de um programa conforme

o conjunto de instrues da mquina alvo (IA32) as regras estabelecidas pela linguagem de programao (C) as convenes seguidas pelo sistema operacional

O compilador gcc gera como sada do passo de compilao um programa em linguagem de montagem
entrada para o passo de montagem (assembler)

Gerando o executvel: compilao

Compilador traduz o programa C em programa assembly

um formato de sada comum para os compiladores de vrias linguagens de programao de alto nvel
3

Linguagem de Montagem
Muito prxima linguagem de mquina Instrues de mquina executam operaes bem simples
operaes aritmticas/lgicas transferncia de dados entre memria e registradores controle do fluxo de execuo (desvios, chamadas de funo)

Tipos de dados bsicos

valores inteiros de 1, 2, ou 4 bytes endereos de memria dados em ponto flutuante (4 ou 8 bytes)

No existem tipos de dados estruturados (arrays / structs)

4

Viso do programador assembly

CPU
registradores A L U PC endereos dados instrues Memria
cdigo dados pilha (stack)

EFLAGS

Estado da CPU
PC: endereo da prxima instruo Registradores:
valores inteiros, endereos

Memria plana
array de bytes endereveis contm cdigo, dados e pilha pilha usada para suporte a chamada de procedimentos
5

EFLAGS: status da ltima operao

overflow? zero? resultado < 0? ado<..0)

Programa em assembly
.data nums: .int

10, -21, -30, 45 /* int nums[4] */

.text .globl main main:

movl movl L1: cmpl je movl

$0, %ebx $nums, %ecx $4, %ebx L2 (%ecx), %eax $1, %ebx $4, %ecx L1

/* ebx = 0; */ /* ecx = nums; */ /* if (ebx == 4) */ /* goto L2 */ /* eax = *ecx */

add add jmp

ret

Registradores
A CPU IA32 tem 8 registradores de 32 bits
valores inteiros e endereos (ponteiros) funcionam como memria de acesso muito rpido (esto dentro da CPU)
31 15 7

%eax %ebx %ecx %edx %esi %edi %esp %ebp

%ax %bx %cx %dx %si %di %sp %bp

%ah %bh %ch %dh

%al %bl %cl %dl

6 registradores so de propsito geral

algumas instrues usam registradores especficos

%ebp e %esp so ponteiros para a pilha

uso de acordo com convenes

Acessados como 32 bits (l) ou 16 bits (w)

os 4 primeiros registradores permitem acesso independente aos 2 bytes menos significativos (b)

Modos de Endereamento
Diversas instrues tem um ou mais operandos
contedo da memria, registrador, constante como especificar os operandos? movl fonte, destino modo imediato (constante): movl $0,%eax modo registrador: movl %ecx, %eax modo indireto: movl (%ecx), %eax modo base-deslocamento: movl 8(%ebp), %eax mov var, %eaxabsoluto
ATENO no existe o conceito de varivel

modo absoluto:

var um endereo de memria! movl var, %eax automaticamente move o valor referenciado (*var em C) 8 movl $var, %eax move o endereo var para %eax

Modos de Endereamento
Movimento de dados sempre CPU memria Nunca dois operandos na memria !!!

Tamanho dos operandos

Sufixo da instruo indica o tamanho do(s) operando(s) b - byte (1 byte = 8 bits)
movb $0, (%eax) movb %al, %bl /* %eax contm end. Memria */

w - word (2 bytes = 16 bits)

movw $0, (%eax) movw %bx, %ax

l - long (4 bytes = 32 bits)

movl $0, (%eax) movl %ebx, %eax
10

Alocao de Dados
Assembler do gcc permite alocao de dados globais de vrios tipos
- geralmente na seo de dados (.data)

Exemplos:
vet: .byte 48, 0x30, '0' s1: .string resultado igual a %d\n i: .int 1000
11

Grupos de Instrues
Movimentao de dados Aritmtica inteira Instrues lgicas Instrues de controle de fluxo Instrues de ponto flutuante

12

Movimentao de Dados
mov [l,w,b] fonte, destino Exemplos:
movl movl movl movw movb $0x4050, %eax %ebx, 4(%ecx) (%edx), %eax %bx, %ax $-17, (%ecx)
Constante Registrador Reg Mem Reg Mem Memria Reg

13

Movimentao com Extenso

Extenso com sinal (signed) ou com zeros (unsigned)
movswl e movzwl: 16 para 32 bits
movswl %ax, %ebx movswl (%eax), %ebx movzwl %ax, (%ebx)

movsbl e movzbl: 8 para 32 bits

movsbl %al, %ebx movzbl (%eax), %ebx movzbl %al, 8(%ebx)

movsbw e movzbw : 8 para 16 bits

movsbw %al, %bx movzbw (%eax), %bx
14

Exemplos de Extenso
Se %dx = 0xCD00
movswl %dx, %eax movzwl %dx, %eax %eax = FFFFCD00 %eax = 0000CD00

Se %dh = 0xCD
movsbw %dh, %ax movzbw %dh, %ax movsbl %dh, %eax movzbl %dh, %eax %ax = FFCD %ax = 00CD %eax = FFFFFFCD %eax = 000000CD

15

Operaes de Aritmtica Inteira

inc, dec :
incl %eax incl (%edx) decl %eax negl %eax

eax = eax + 1 (*edx) = (*edx) + 1 eax = eax 1 eax = -eax (complemento a 2)

add, sub, imul :

addl addl addl addb subl imul %ebx, %eax $4, %eax 4(%ecx),%eax $10,(%ecx) %ebx, %eax $2, %edx eax = eax + ebx eax = eax + 4 eax = eax + (*(ecx+4)) (*ecx) = (*ecx) + 10 (inteiro de 8 bits) eax = eax ebx edx = edx * 2
16

Operaes Lgicas (bit a bit)

not:
notl %eax notl (%eax) notb (%eax)

eax = ~eax (*eax) = ~(*eax) (inteiro de 32 bits) (*eax) = ~(*eax) (inteiro de 8 bits)

and, or, xor:

andl andl andb orl xorl $0x7FFFFFFF, %eax %ebx, %eax $0xFE,(%eax) (%ecx), %eax %eax, %ebx eax = eax & 0x7FFFFFFF eax = eax & ebx (*eax) = (*eax) & 0xFE (8 bits) eax = eax | (*ecx) ebx = ebx ^ eax

17

Operaes de Deslocamento
Deslocamento (shift) de 0 a 31 bits
valor imediato ou contedo de %cl shift para a direita pode ser aritmtico ou lgico
shll $2, %eax shll %cl, %eax shrl shrl sarl sarl $1, %eax %cl %eax $1, %eax %cl, %eax eax = eax << 2 eax = eax << cl eax = eax >> 1 eax = eax >> cl eax = eax >> 1 eax = eax >> cl (lgico) (lgico) (aritmtico) (aritmtico)

18