INF1600: Architecture des micro-ordinateurs · INF1600: Architecture des micro-ordinateurs...

42
Assembleur 1 Génie informatique et génie logiciel H2015 INF1600: Architecture des micro-ordinateurs Assembleur Introduction à IA-32 Responsable du cours : Giovanni Beltrame [email protected] Local: M-4109 Chargée de cours: Luiza Gheorghe [email protected]

Transcript of INF1600: Architecture des micro-ordinateurs · INF1600: Architecture des micro-ordinateurs...

Assembleur

1Génie informatique et génie logiciel H2015

INF1600: Architecture des micro-ordinateurs

AssembleurIntroduction à IA-32

Responsable du cours : Giovanni Beltrame

[email protected]

Local: M-4109

Chargée de cours: Luiza Gheorghe

[email protected]

Assembleur

2Génie informatique et génie logiciel H2015

Exercice

Donnez le RTN abstrait de l’instruction: ADD 4(, %ecx, 8), %ebx

Assembleur

3Génie informatique et génie logiciel H2015

Exercice

Donnez le RTN abstrait de l’instruction: ADD 4(, %ecx, 8), %ebx

Assembleur

4Génie informatique et génie logiciel H2015

1) Donnez les signaux de contrôle pour « A, B, C, D, E, F, G, UAL, wEIP, wIR, wT, wT2, wRegistre » pour:T ← 8 ; T2 ← edx + T : T ← edx + T ;ecx ← Mémoire2[T2] : IR ← Mémoire1[EIP] ;EIP ← EIP + 0x2000

En supposants qu’au depart IR=0x004C0008

et qu’après son écriture, IR contient : IR⟨12..0⟩=0 : IR⟨14..13⟩=1 : IR⟨17..15⟩=0 : IR⟨20..18⟩=0 : IR⟨23..21⟩=0

Assembleur

5Génie informatique et génie logiciel H2015

T ←←←← 8;

T2 ←←←← edx + T: T ←←←← edx + T;

ecx ←←←← M2[T2] : IR ←←←← M1[EIP] ;

EIP ← ← ← ← EIP + 0x2000

Avant écriture: 0x004C0008 IR⟨12..0⟩=0 Après écriture IR⟨14..13⟩=1 : IR⟨17..15⟩=0 : IR⟨20..18⟩=0 : IR⟨23..21⟩=0

D =1:UAL=1:wT=1;

B =1:E=1:UAL=1:wT=1:wT2=1;

F =1:UAL=1:wIR=1:wR=1;A =0:wEIP=1;

Assembleur

6Génie informatique et génie logiciel H2015

Programme du cours

07/01/2016Introduction

04/02/2016

Programmation en assembleur

22/01/2016

Architecture d'un microprocesseur

29/01/2016

Organisation interne dumicroprocesseur

Hierarchie de mémoireTP0

Introduction aux outils

TP1

Périphériques et architecture

14/01/2016Micro-ordinateur et périphériques

TP2

Architecture du microprocesseur

TP3

Programmation en assembleur

TP4

Lien entre C++ et assembleur

TP5

Mémoires

C++ et assembleurThéorieTravaux Pratiques

Assembleur

7Génie informatique et génie logiciel H2015

Objectifs de la leçon

1

3

2

5

Faire une liste des composants (registres, unités, etc.) de l'architecture x86

Écrire des sections données dans un programme assembleur, en utilisant les conventions Intel

Utiliser des étiquettes pour spécifier des adresses dans un programme assembleur

Utiliser les modalités d'adressage IA-32 pour spécifier une adresse en mémoire

Décrire comment utiliser une pile dans l'architecture IA-32

Faire une liste de conditions possibles pour les branchements dans l'architecture IA-32

À partir d'un if-else en C, écrire le code équivalente en assembleur

4

6

7

Assembleur

8Génie informatique et génie logiciel H2015

4

Agenda

• Architecture IA-32

• Déclaration de données

• Opérandes

• La pile

• Branchements

1

32

5

76

Assembleur

9Génie informatique et génie logiciel H2015

• IA-32 pour architectures 32-bits– Architecture abstraite– Du 80386, jusqu’au Pentium 4…– Extension 64-bits: x86-64 / AMD64 (IA-64 est très différent)

• Une plage mémoire « physique », plusieurs « virtuelles »– Unité de segmentation (16-bit pour #segment + 32-bits; pas utilisé dans ce cours) – Unité de pagination (32-bits en entrée)– Protection sur les pages et segments– Adresse physique de 32-bits; 36-bits avec PAE (Page Address Extension)– Petit-boutiste, adressé en octets, alignement non imposé– Peut accéder en 8-bits, 16-bits, 32-bits, 64-bits, 80-bits, 128-bits– Mem_phys[0..236-1]<7..0> : – Mem[x] := Mem_phys[pagination(x)] :– M16[x] := Mem[x+1]#Mem[x] :– M32[x] := Mem[x+3]#Mem[x+2]#Mem[x+1]#Mem[x] :– M64[x] := M32[x+4]#M32[x] : …

IA-32 en résumé

1

Assembleur

10Génie informatique et génie logiciel H2015

IA-32 en résumé (suite)

•8 registres 32-bits directement accessibles― eax, ebx, ecx, edx, esi, edi utilisables

― ebp souvent utilisé comme « block pointer » (pour variables locales)

― esp pointeur de pile (pointe sur le dernier élément empilé)

•Un registre avec les indicateurs (eflags)― retenue, débordement, signe, etc.

•Un compteur de programme (eip; pour « instruction pointer »)

•6 registres de segments (pas utilisés dans ce cours)

•Unité virgule flottante― 8 registres de 80 bits accessibles comme une pile

― Registres de contrôle et de statut

•Unités MMX/SSE/SSE2/3D-Now …

1

Assembleur

11Génie informatique et génie logiciel H2015

Registres IA32

Registres usage général

031

EAX

EBX

ECX

EDX

ESI

EDI

EBP – block pointer

ESP – stack pointer

015

CS - code

DS - data

SS - stack

ES - data

FS - data

GS - data

Registres select – pointeurs qui identifient un segment dans la mémoire – non utilisés dans INF1600

Registres état etcontrôle

EFLAGS – plusieurs flag état, un flag ctrl

EIP – pointeur instructions - PC

031

Assembleur

12Génie informatique et génie logiciel H2015

Registres

�Registres « généraux » 8 bits, 16 bits et 32 bits― EAX⟨31..0⟩ : AX⟨15..0⟩ := EAX⟨15..0⟩ : AH⟨7..0⟩ := EAX⟨15..8⟩ : AL⟨7..0⟩ := EAX⟨7..0⟩

― Pareil pour les quatre premiers registres :� eax, ax, ah, al (EAX := R[0])

� ebx, bx, bh, bl (EBX := R[3])

� ecx, cx, ch, cl (ECX := R[1])

� edx, dx, dh, dl (EDX := R[2])

― Pas de 8 bits pour:� esi, si (ESI := R[6])

� edi, di (EDI := R[7])

� ebp, bp (EBP := R[5])

� esp, sp (ESP := R[4])

eax

ax

ah

31 16 15 8 7 0

al

1

Assembleur

13Génie informatique et génie logiciel H2015

4

Agenda

• Architecture IA-32

• Déclaration de données

• Opérandes

• La pile

• Branchements

1

32

5

76

Assembleur

14Génie informatique et génie logiciel H2015

Les donnéesC / C++ (GCC)Nom donné par Intel

• Byte = 1 octet (8 bits)

• Word = 2 octets (16 bits) - short

• Doubleword (dword) = 4 octets (32 bits) - int, long

• Quadword (qword) = 8 octets (64 bits) – long long

• Entiers non-signés de N bits, [0 , 2N-1]

• Entiers signées de N bits, [-2N-1 , 2N-1-1]– En complément à 2

• Float = 4 octets (32 bits)

• Double = 8 octets (64 bits)

• Temporary float (tfloat) = 10 octets (80 bits)

• Chaînes de caractères

char

short

int, long, *

long long

unsigned …

signed …

float

double

long double

ascii

2

Assembleur

15Génie informatique et génie logiciel H2015

.data # directive on est dans le segment données (comme déclarations)

val: .word 10, -14, 30 # trois mots

.text # on est dans le segment texte – instructions assembleur

.global main # mais est publique

main: addi $sp, $sp, -8 # additione immédiate

Etiquette (label) Type

Valeurs

Assembleur

16Génie informatique et génie logiciel H2015

Les donnés, déclarations

.data # espace initialisé, lisible, écrivable

# Si cet espace commence à 1000

unbyte: # unbyte = 1000

.byte 9,8,0b111 # Mem[1000] = 9, Mem[1001] = 8, Mem[1002] = 1112

unword: # unword = 1003

.word 1,2,10%3 # M16[1003]=1, M16[1005]=2, M16[1007]=10mod3=1

unshort: # unshort = 1009

.short 0x9C, 077 # M16[1009]=9C16, M16[1011]=778

unentier: # unentier = 1013

.int 52+4, unword-2 # M32[1013]=56, M32[1017]=1003-2=1001

.float 12.54 # M32[1021]=12.54 en IEEE-754 sur 32-bits

.double 67.34 # M64[1025]=67.34 en IEEE-754 sur 64-bits

2

Assembleur

17Génie informatique et génie logiciel H2015

Étiquettes• Les noms devant les « : » se nomment étiquettes

• La valeur de l’étiquette définie avec « : » est l’adresse présente

• Numériques – une seule chiffre entre 0 et 9 • Utilisée seulement pour référence locale

• Peuvent être redéfinies

• Symboliques - identificateur(ASCII) – doivent être définis seulement une fois

• .equ une_etiquette, 123 # une_etiquette = 123

• « . » est l’adresse présente

.equ une_autre, . # équivalent à « une_autre: »

• « .global étiquette » pour la rendre publique

• 1: #étiquette numérique « 1 » (1f ; 1b) i.e. jmp 1f

un: #étiquette symbolique « un »

3

Assembleur

18Génie informatique et génie logiciel H2015

• Une étiquette est une constante– Peut être utilisé partout où on peut entrer un chiffre

– Sa valeur réelle connue à l’exécution, selon l’adresse du programme• Ne peut faire étiquette1+étiquette2, ni étiquette1*val

– étiquette1-étiquette2 connu à la compilation si dans même fichier• Peut faire (étiquette1-étiquette2)*val

• Peut être définie a une valeur quelconque

Étiquettes

Assembleur

19Génie informatique et génie logiciel H2015

Directives

- commandes en assembleur:

i.e. MAXIMUM EQU 99 – l’ étiquette MAXIMUM est interprétée par assembleur comme 99

SPEED SET 45 - remplace aussi un nombre par un symbole

Assembleur

20Génie informatique et génie logiciel H2015

Exercices

.data # 1000

poly:.qword 10,041 # M...[1000] =..., M32[...] = …, M...[...]=...

mtl: # mtl =...

.short 1,0xAA # M...[...]=1, M...[...]=...

M64[1000]=10 ; M32[1008]=041 ; M32[1012]=0

mtl=1016

M16[1016]=1 ; M16[1018]=0xAA

32

Assembleur

21Génie informatique et génie logiciel H2015

Exercices

À partir de l'etiquette a le contenu de la mémoire est:

0xAA 0x22 0x24 0x5C 0x6E

Quel est le word à l'adresse a+3 ?

32

0x5C6E

Assembleur

22Génie informatique et génie logiciel H2015

Exercice

.data

debut_data:

var1:

.byte 8, 9, 10

var2:

.int 0x234

.word 0x5678, 256

.equ taille,

fin_data – var2

fin_data:

Donnez la valeurs de chaque octet en mémoire a partir de l’adresse de debut_data (1000 - incluse) jusqu’à l’adresse fin_data (non incluse)

.equ –> lien noms - valeurs, n’alloue pas de la mémoire

.equ name, expression

• Byte = 1 octet (8 bits)• Word = 2 octets (16 bits) - short• Doubleword (dword) = 4 octets (32 bits) - int, long• Quadword (qword) = 8 octets (64 bits) – long long

Assembleur

23Génie informatique et génie logiciel H2015

Exercice

.data

debut_data:

var1:

.byte 8, 9, 10

var2:

.int 0x234

.word 0x5678, 256

.equ taille, fin_data – var2

fin_data:

1 - Donnez la valeurs de chaque octet en mémoire a partir de l’adresse de debut_data(1000 - incluse) jusqu’a l’adresse fin_data (non incluse)

M[1000] 08

09

10

M[1003] 34

02

00

00

78

56 ….

Assembleur

24Génie informatique et génie logiciel H2015

Exercice

.data

debut_data:

var1:

.byte 8, 9, 10

var2:

.int 0x234

.word 0x5678, 256

.equ taille,

fin_data – var2

fin_data:

2 - En supposant que debut_data =

1000, donnez les valeurs de var1, var2 et taille.

var1 1000

var2 1003

taille 8

Assembleur

25Génie informatique et génie logiciel H2015

Exercice placement de données

.datadebut_data:a:

.word -0x10, (1 << 9) – 2

.equ d, b – a

.byte 0x02, 0x10, 0, 0

.int 0x1004b:

.byte 0x34

.word d

.int cc:fin_data:

Donnez la valeur de chaque octet en mémoire à partir de l’adresse debut_data(incluse), jusqu’à l’adresse fin_data (non incluse), en hexadécimal.debut_data 0x1000

0xF0 0xFF 0xFE 0x01 0x02 0x10 0x00 0x000x04 0x10 0x00 0x000x34 0x0C 0x000x13 0x10 0x00 0x00

debut_data=0x1000=a; b=0x100C; c=0x1013 = fin_data

Assembleur

26Génie informatique et génie logiciel H2015

4

Agenda

• Architecture IA-32

• Déclaration de données

• Opérandes

• La pile

• Branchements

1

32

5

76

Assembleur

27Génie informatique et génie logiciel H2015

Instructions

3 classes:

- Déplacement de données: mémoire <-> registre- chargement (load) registre<- mémoire

- stockage (store) mémoire <- registre

- Operations arithmétiques/logiques (UAL)- Addition, shift

- Branchement (instruction control flot de données)- Branchement, jump, call

Assembleur

28Génie informatique et génie logiciel H2015

Opérandes•Instructions à 2 opérandes: op source, destination (ou Intel - destination←source)

― Ex: add %ebx, %eax RTN: R[eax] ← R[eax] + R[ebx]•Types d’opérandes

― Immédiate (constante) – aucun accès à la mémoire : $1234 RTN: 1234― Mémoire: 1234 RTN: M[1234]― Registre – aucun accès à la mémoire : %eax RTN: R[eax]― Destination - jamais immédiate― Jamais source mémoire et destination mémoire

•Modes d’adressage― déplacement(%r1, %r2, k) RTN: M[déplacement+R[r1]+R[r2]*k]― Où

� déplacement est un entier 32-bits� r1 et r2 sont des registres (r2 ne peut pas être %esp)� k est 1, 2, 4 ou 8

― Les éléments peuvent être omis (défaut à 0, sauf k défaut à 1)― Ex: (,%eax,2) RTN: M[R[eax]*2]

•Suffixes b (byte), w (word), l (long) si taille non évidente― Ex: addw $4, 1234 RTN: M16[1234] ← M16[1234] + 4

addl $4, 1234 RTN: M32[1234] ← M32[1234] + 4

4

Assembleur

29Génie informatique et génie logiciel H2015

4

Agenda

• Architecture IA-32

• Déclaration de données

• Opérandes

• La pile

• Branchements

1

32

5

76

Assembleur

30Génie informatique et génie logiciel H2015

La pile•Une pile est gérée par le processeur

― Utilisée pour adresse de retour de sous-routines et interruptions― Normalement utilisé aussi pour:

� Sauvegarder temporairement des valeurs� Variables locales� Paramètres des sous-routines/méthodes

•%esp est le pointeur de pile― (%esp) élément du dessus de la pile

RTN: push(x) := (R[esp] ← R[esp] – 4 ; M32[R[esp]] ← x) :pop := (pop ← M32[R[esp]] : R[esp] ← R[esp] + 4)

― push %eax RTN: push(R[eax])― pop %eax RTN: R[eax] ← pop

•Toujours empiler/dépiler par tranches de 32-bits― Pas obligatoire, mais ralentirait beaucoup sinon

•Exemple:pushl $4pushl $3pop %eax # eax = 3pop %ebx # ebx = 4

5

Assembleur

31Génie informatique et génie logiciel H2015

4

Agenda

• Architecture IA-32

• Déclaration de données

• Opérandes

• La pile

• Branchements

1

32

5

76

Assembleur

32Génie informatique et génie logiciel H2015

Les indicateurs (eflags)

•Information sur le résultat de la dernière instruction effectuée― vrai := 1 : faux := 0― CF := eflags⟨0⟩ carry; retenue/emprunt; débordement non signé― PF := eflags⟨2⟩ parity; vrai si le nombre de bits à 1 est pair― AF := eflags⟨4⟩ auxiliary carry; pour le BCD (binary coded decimal)― ZF := eflags⟨6⟩ zero; vrai si le résultat est zéro― SF := eflags⟨7⟩ sign; vrai si le résultat est négatif― DF := eflags⟨10⟩ direction; (DF=faux → inc) : (DF=vrai → dec)― OF := eflags⟨11⟩ overflow; débordement signé

•Toutes les opérations arithmétiques/logiques modifient eflags― Les instructions « cmp » et « test » ne modifient que les eflags

•Eflag pas modifié par― Branchements (jmp, j?, call, ret, loop)― Copies/déplacent de données (mov, xchg, push, pop, lea)

6

15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0- NT OF DF IF TF SF ZF - AF - PF - CFIOPL

Assembleur

33Génie informatique et génie logiciel H2015

Branchements

•Sans condition: jmp quelquepart― quelquepart est un entier/adresse/étiquette

― RTN: R[eip] ← quelquepart

― quelquepart peut aussi être « *opérande »� jmp *%eax RTN: R[eip] ← R[eax]

� jmp *4(%eax) RTN: R[eip] ← M32[4 + R[eax]]

•Conditions: j? quelquepart― Où ? est le nom de la condition: c, nc, z, nz, o, no, s ns, p, np, a, na…

― Condition sur eflags ou %ecx

― RTN: condition_vrai → (R[eip] ← quelquepart)

•Appel/retour de sous-routine:― call quelquepart RTN: push(R[eip]) : R[eip] ← quelquepart

― ret RTN: R[eip] ← pop

6

Assembleur

34Génie informatique et génie logiciel H2015

Conditions•Toujours selon indicateurs (sauf cas de %ecx)

― Noms selon: indicateurs, comparaison non signée , comparaison signée

― jecxz/jcxz jump if ecx/cx is zero condition ecx = 0 ou cx = 0

•Noms selon indicateurs:― jc jump if carry CF = 1 → (R[eip] ← quelquepart)

― jnc jump if no carry CF = 0 "

― jz jump if zero ZF = 1

― jo jump if overflow OF = 1

― jno jump if no overflow OF = 0

― js jump if sign SF = 1

― jns jump if no sign SF = 0

― jp jump if parity PF = 1

― jnp jump if no parity PF = 0

― jpo jump if parity odd PF = 0 (même chose que « jnp »)

6

Assembleur

35Génie informatique et génie logiciel H2015

Conditions

•Comparaison: cmp y, x― affecte eflags selon l’opération x-y

•Noms suivant une comparaison non signée: (above/below)― jb jump if below CF = 1 (comme jc)

― jnb jump if not below CF = 0 (comme jnc)

― jbe jump if below or equal CF = 1 ∨ ZF = 1

― jnbe jump if not below or equal CF = 0 ∧ ZF = 0

― ja jump if above CF = 0 ∧ ZF = 0 (comme jnbe)

― jna jump if not above CF = 1 ∨ ZF = 1 (comme jbe)

― jae jump if above or equal CF = 0 (comme jnb)

― jnae jump if not above or equal CF = 1 (comme jb)

― je jump if equal ZF = 1 (comme jz)

― jne jump if not equal ZF = 0 (comme jnz)

6

Assembleur

36Génie informatique et génie logiciel H2015

Conditions

•Noms suivant une comparaison signée: (greater/lower)― jl jump if lower SF ≠ OF

― jnl jump if not lower SF = OF

― jle jump if lower or equal SF ≠ OF ∨ ZF = 1

― jnle jump if not lower or equal SF = OF ∧ ZF = 0

― jg jump if greater SF = OF ∧ ZF = 0(comme jnle)

― jng jump if not greater SF ≠ OF ∨ ZF = 1 (comme jle)

― jge jump if greater or equal SF = OF (comme jnl)

― jnge jump if not greater or equalSF ≠ OF (comme jl)

― je jump if equal ZF = 1 (comme en non signé)

― jne jump if not equal ZF = 0 "

•Comment se rappeler above/below vs. greater/lower― jb = jc

― « carry » est un débordement non signé

6

Assembleur

37Génie informatique et génie logiciel H2015

Conditions

En C: if(a) b; else c;Équivalent au C:

if(a == 0) goto partie_else;

b;

goto fin_du_if;

partie_else:

c;

fin_du_if:

En assembleur:

if:

# code pour a

j? partie_else

# code pour b

jmp fin_du_if

partie_else:

# code pour c

fin_du_if:

7

Assembleur

38Génie informatique et génie logiciel H2015

Exercice

int a = 3;

int b = 0;[...]

if( a + b == 3 ) {

b = b + 1;

} else {

b = a;

}

a:

.long 3

b:

.long 0

[…]

movl a, %eax

movl b, %ebx

addl %ebx, %eax

cmpl $3,%eax

jne IF

addl $1, %ebx

movl %ebx, b

jmp end

IF:

movl a, %ebx

movl %ebx, b

jmp end

end:

ret

7

Assembleur

39Génie informatique et génie logiciel H2015

4

Agenda

• Architecture IA-32

• Déclaration de données

• Opérandes

• La pile

• Branchements

1

32

5

76

Assembleur

40Génie informatique et génie logiciel H2015

Faire une liste des composants (registres, unités, etc.) de l'architecture x86

Écrire des sections données dans un programme assembleur, en utilisant les conventions Intel

Utiliser des étiquettes pour spécifier des adresses dans un programme assembleur

unbyte: # unbyte = 1000

.byte 9,8,0b111

unword: # unword = 1003

.word 1,2,10%3

Synthèse

1

3

2

Assembleur

41Génie informatique et génie logiciel H2015

Spécifier les opérandes pour une instruction IA-32

Décrire comment utiliser une pile dans l'architecture IA-32

– Immédiate (constante): $1234 RTN: 1234– Mémoire: 1234 RTN: M[1234]– Registre: %eax RTN: R[eax]– Destination jamais immédiat– Jamais source mémoire et destination mémoire– Modes d’adressage

• déplacement(%r1, %r2, k) RTN: M[déplacement+R[r1]+R[r2]*k]

– (%esp) élément du dessus de la pileRTN: push(x) := (R[esp] ← R[esp] – 4 ; M32[R[esp]] ← x) :

pop := (pop ← M32[R[esp]] : R[esp] ← R[esp] + 4) – push %eax RTN: push(R[eax])– pop %eax RTN: R[eax] ← pop

Synthèse

5

4

Assembleur

42Génie informatique et génie logiciel H2015

Faire une liste de conditions possibles pour les branchements dans l'architecture IA-32

À partir d'une boucle en C, écrire la boucle équivalente en assembleur

Synthèse

6

7