inf1600: architecture des micro-ordinateurs · inf1600: architecture des micro-ordinateurs...
TRANSCRIPT
Assembleur
1Génie informatique et génie logiciel H2015
INF1600: Architecture des micro-ordinateurs
AssembleurIntroduction à IA-32
Responsable du cours : Giovanni Beltrame
Local: M-4109
Chargée de cours: Luiza Gheorghe
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