ia32

5/10/2018 IA32 - slidepdf.com

http://slidepdf.com/reader/full/ia325571fd204979599169987e03 1/12

Programação Imperativa em C e C++PICC

Assembly

Arquitectura IA32

Pedro Pereira [email protected] de CálculoInstituto Superior de Engenharia de Lisboa

mailto:[email protected]

http://www.cc.isel.ipl.com/

http://www.isel.ipl.com/

http://www.isel.ipl.com/

http://www.cc.isel.ipl.com/

mailto:[email protected]


http://slidepdf.com/reader/full/ia325571fd204979599169987e03 2/12CCISEL, 2007

Compilação gerando assembly

2Programação Imperativa em C e C++

...int v;

int incMod()

{

++v;

if (v==10)

v=0;

return v;}

_DATA SEGMENTCOMM _v:DWORD _DATA ENDS

PUBLIC _incMod _TEXT SEGMENT _incMod PROC mov eax, [_v]inc eax mov [_v], eaxcmp [_v], 10jne $L1

mov [_v], 0$L1: mov eax, [_v]ret

_incMod ENDP _TEXT ENDS

_incMod PROC mov eax, [_v]inc eaxcmp eax, 10jne $L1xor eax, eax

$L1: mov [_v], eaxret

_incMod ENDP

incMod.C incMod.asm

Optimizado

cl /c /FA /Od incMod.c

cl /c /FA /Ox incMod.c



Arquitectura IA32

•Arquitectura Intel a 32 bits – Registos

• eax…

– Instruções

• mov, inc, cmp, jne, ret, xor…

• Por quê saber IA32?

– Debug (demo)

– Optimizar código (mesmo que escrito em C) – Melhor compreensão do C

• Ponteiros;

• Passagem de parâmetros;

• etc…




História dos processadores Intel IA32 (família x86)

• 1978 – 8086 (8MHz)

– 16 bits – Endereçamento a 220 bytes

(1MB)

• 1980 – 8087 – Vírgula flutuante

• 1982 –

80286 (12.5MHz) – Endereçamento a 224 bytes(16MB)

– Segmentação

• 1985 – 80386 (20MHz) – 32 bits

– Endereçamento a 232 bytes(4GB)

– Paginação


• 1989 – 80486 (25MHz)

– Organização em pipeline• 1992 – Pentium (60MHz)

– Organização super-escalar

• 1995 – P6 (200MHz) – Organização com

escalonamento dinâmico – Espaço endereçamento

(64GB)

• 1997 – MMX (266MHz)• 1999 – Pentium III (500MHz)• 2000 – Pentium 4 (1.5GHz)• 2006 – Core 2 (3GHz)



Registos

• 8 registos de 32 bits de uso

(quase) genérico (algunscom acesso a 8 e 16 bits )

– esp stack pointer

– ebp base pointer

– esi, edi (em strings) – ecx (em contagens)

• Outros registos

– eip Instruction Pointer

– eflags (para flags)

c-carry; p-parity; z-zero; s-sign;o-overflow; d-direction

– cs, ds, ss, es, fs, gs selectoresde segmento (16 bits)


ah al

bh bl

ch cl

dh dlsi

di

bp

sp

16 bit2 bit

ax

bx

cx

dx

eax

ebx

ecx

edxesi

edi

ebp

esp

32 bit

16 bit

si

di

bp

sp

8 bit



CCISEL, 2007

Instruções

• Instruções com 0, 1 ou 2 operandos – hlt – inc ebx – mov eax, [esi+16]

• Com 2 operandos (o primeiro especifica o destino) – Registo, Registo mov eax, ecx

Registo, Imediato add ebx, 10Registo, Memória cmp ecx, [ebx]Memória, Registo mov [ebx], eax

Memória, Imediato sub [esi], 3Memória, Memória

• Instruções para: – Transferência de dados: mov, push, pop, pusha, popa, …

– Aritméticas e lógicas: add, sub, mul, div, inc, neg, cmp, and, or, … – Deslocamento e rotação de bits: shr, shl, ror, rol, rcr, rcl, … – Transferência de controle: jmp, call, ret, iret, int, j**, … – Operações sobre strings: movs, cmps, scas, lods, stos, …

– Controle das flags: stc, clc, std, cld, pushf, popf, … – ...




CCISEL, 2007

Formas de endereçamento

• Endereço dentro do segmento

• Forma genérica – endereço = registo + scale*registo + imediato

• registo – qualquer registo a 32 bits

• scale – 1, 2, 4 ou 8• imediato – definido a 8, 16 ou 32 bits

• Não necessita de ter todas as componentes

– Endereço = imediato (directo) – Endereço = registo (indirecto) – Endereço = registo + imediato (baseado) – Endereço = registo + registo (indexado) – Endereço = registo + scale*registo (indexado escalado)

• Exemplo– mov eax, [esi+4*edi+15]




CCISEL, 2007

ebp antigo

stack frame

• Chamada1. Passagem de parâmetros

• O chamador empilha os parâmetros da direita para a esquerda

2. Chamada• O endereço de retorno é empilhado pela instrução call

3. Acertar ebp (base pointer ) e alojar as variáveis locais• A função chamada empilha o valor de ebp

• guarda o valor de esp em ebp

• reserva espaço para as variáveis locais ajustando o valor deesp

• Retorno4. Valor de retorno

• A função chamada deixa em eax o valor de retorno

5. Libertar espaço das variáveis locais

• A função chamada repõe o valor esp e ebp6. Retornar ao chamador

• A execução passa para o chamador pela instrução ret

7. Libertar espaço dos parâmetros• O chamador ajusta o esp


…

Parâmetros…

Endereço deRetorno

…

Variáveislocais…

topo do stack esp

ebp

e n d e r e ç o s

m e n o r e s

e n d e r e ç o s

m a i o r e s



CCISEL, 2007

b = 20

stack frame (2)


int sum(int a, int b) {int res = a;res +=b;return res;

}

_sum PROC push ebp

mov ebp, espsub esp, 4 mov eax, [ebp+8] mov [ebp-4], eaxadd eax, [ebp+12] mov [ebp-4], eax

mov eax, [ebp-4] mov esp, ebp pop ebpret 0

_sum ENDP

void func() {int x = 10;...x = sum(x,20);...

}

_func PROC

... push 20 mov eax, [ebp-4] push eaxcall _sum

$L1:

add esp, 8 mov [ebp-4], eax...

_func ENDP

chamadochamador

ebp (func)

a = 10

$L1

res = ??esp

ebp

ebp (main)

ret addr

x = 0

s t a c k f r a m e d a

f u n ç ã o s u m ( )

s t a c k f r a m e d a

f u n ç ã o

f u n c ( )

[ebp-4]

[ebp+8]

[ebp+12]1

2

3

45

6

7

Epílogo

Prólogo



CCISEL, 2007

Convenções IA32/C na chamada de funções

• Parâmetros empilhados da direita para a esquerda

– O primeiro parâmetro fica no topo do stack para permitir número variávelde parâmetros printf(frmt,…)

• Parâmetros char, short, int e long são empilhados numa word(32 bits) – Tipos maiores ocupam 2 ou mais words no stack

• O chamador é responsável por desempilhar os parâmetros – Adicionar a esp (4*words dos parâmetros)

• O resultado da função fica em eax, ax ou al conforme o tipo é

32, 16 ou 8 bits

• Os registos têm que ser preservados pelas funções chamadas(no retorno devem ter os mesmos valores que na entrada),exceptuando eax, edx e ecx que podem ser usados livremente.




CCISEL, 2007

Ligação entre C e Assembly (função em assembly)


.686P

PUBLIC _distance_ones;int distance_ones(unsigned val);{

; int c=0;; if( !val ) return 0;; while(!(val&1)) val>>=1;; while( val ) { ++c; val>>=1; }; return c;;}

_TEXT SEGMENT _distance_ones PROC mov ecx, [esp+4] ; val --> ecxxor eax, eax ; c=0 --> eaxtest ecx, ecxjz $end ; if (!val)

$while1:test cl, 1jnz $while2 ; while(!(val&1))shr ecx, 1 ; val>>=1

jmp $while1$while2:test ecx, ecxjz $end ; while(val)inc eax ; ++cshr ecx, 1 ; val>>=1jmp $while2

$end:ret ; return c

_distance_ones ENDP _TEXT ENDSEND

distance_ones.asm

ml /c distance_ones.asm gera distance_ones.obj



CCISEL, 2007

Ligação entre C e Assembly (Chamada a partir de C)


#include <stdio.h>

int distance_ones(unsigned v);

int main() {int dist, val;scanf(“%d”,&val); bits = distance_ones(val) printf(“dist=%d \n",dist);

return 0;}

prog.c

cl prog.c distance_ones.obj gera prog.exe.

ia32

Documents