Architecture1 (partie1)

Systèmes temps réel et systèmes embarqués
Architecture des ordinateurs
Loı̈c Cuvillon
Ecole Nationale Supérieure de Physique de Strasbourg
28 septembre 2011
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
1 / 82
Sommaire
1
Processeur et jeu d’instructions
Architecture ARM : principes
Architecture Intel et Assembleur x86
Branchements et leur prédiction
La Pile d’exécution
2
Du source à l’exécutable
Le format ELF
Le code relogeable
L’exécutable et son chargement
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
2 / 82
Bibliographie
Bibliographie
Architecture :
Architecture de l’ordinateur, 5ème édition, Andrew Tanenbaum, Pearson
education, 2005. par le créateur de l’OS Minix
Documentation technique :
Intel Architecture Software Developer’s Manuel
ARM Architecture Reference Manual
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
3 / 82
Bibliographie
Notation
Norme SI, IEEE, . . .
1 octet = 8 bits (b :bits)
1 Ko = 1000 octets (1KB, B :Bytes)=8000 bits
1 Mo = 104 octets
1 Go = 106 octets
(convention pour les disques durs)
1 Kio = 1 KibiOctet =1024 octets= 210 octets
1 Mio = 220 octets
1 Gio = 230 octets
Convention du cours, des programmeurs et systèmes (OS) :
1Ko =1024 octets. . .
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
4 / 82
Bibliographie
Notation
Représentation de 177 dans une base
décimal : 177 (#177)
binaire : 10110001
hexadécimal : 0xB1 ou B1h (note : 1 chiffre en hexa= 4bits)
Représentations possibles d’un octet
00000000
00000001
00000010
01111010
11111110
11111111
Entier non signé
0
1
2
122
254
255
Loı̈c Cuvillon (ENSPS)
Entier signé (complt. à 2)
0
1
2
122
-2
-1
Systèmes temps réel et systèmes embarqués
ASCI
/NUL
/SOH
/STX
z
♭
ÿ
Année scolaire 2010-2011
5 / 82
Bibliographie
Notation
Nombre décimaux (simple précision IEEE 754) :
n = (signe : s) ∗ 1.m ∗ 2e−127
31
s
23
0
e
m: mantisse
exemple : 0x40200000 = 1.25 ∗ 21 = 2.5
31
23
0 10000000
positif
Loı̈c Cuvillon (ENSPS)
128
0
01000000000000000000000
2 −2=0.25
Systèmes temps rXKCD.com
éel et systèmes embarqués
Année scolaire 2010-2011
6 / 82
Bibliographie
Notation
Little/Big Endian
Petit/Gros boutiste (étymologie : voyage de Gulliver)
exemple : la valeur 433=01B1h nécessitant 2 octets en mémoire
Big endian : most significant bit (MSB : 01h) en premier
Little Endian : lest significant bit (LSB : B1h) en premier
Little-Endian (x86,arm)
adresse mémoire 00 01
B1 01
Big-Endian (powerpc,arm,mips)
adresse mémoire 00 01
01 B1
Protocole IP : big endian (pour tous, interopérabilité)
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
7 / 82
Processeur et jeu d’instructions
Plan
1
Processeur et jeu d’instructions
Architecture ARM : principes
Architecture Intel et Assembleur x86
Branchements et leur prédiction
La Pile d’exécution
2
Du source à l’exécutable
Le format ELF
Le code relogeable
L’exécutable et son chargement
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
8 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Architecture ARM (Advance RISC Machine)
processeur RISC 32 bit
Reduced Instruction Set Computer ; instr. de taille fixe (32bits)
architecture ”load and store”
(opération arithmétique réalisable uniquement entre registres)
chaque instruction fait peu de travail mais rapidement
avantages : architecture épurée et fréquence d’exécution rapide
inconvénient : programme plus long (2x) que le même en CISC
populaire dans l’embarqué : lego mindstorm, nintendo DS ; apple
ipod,iphone (consommation électrique)
la société ARM
ne fabrique pas de processeurs mais les dessine !
vend des licences et ses dessins à des fondeurs
perçoit des royalties sur les processeurs vendus
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
9 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
L’architecture externe du ARM
bus d’adresses 32 bits :
4Go de RAM possible ;
bus de données
(+ instruction : Archi. Van
Neumann)
2 lignes d’interruptions ;
nReset : réinitialisation ;
nRW : sélection
écriture/lecture
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
10 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Fonction d’un processeur (Central Processing Unit)
Execution séquentielle d’instructions au travers d’un pipeline
Etapes du pipeline ARM7
Fetch Instruction
Decode
Execute
Loı̈c Cuvillon (ENSPS)
Fetch : Récupérer le code de
l’instruction à exécuter
Decode : Décode instruction et
registres à utiliser
(préparation des chemins de
données)
Execute : Exécution instruction
lecture registres ;
opération ;
écriture résultat registre ;
...
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
11 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Architecture Interne d’un processeur
Single Core CPU
Address bus
R1
R2
Data bus
Memory
R3
PC
Decode
IR
...
A
and Control Unit
Bus source
selection
B
ALU
ALU operation mode
C
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Registres : stockage de
mots (16, 32, 64 bits
suivant architecture)
ALU : Unité Arithmétique
et Logique ;
+,-,*,/,ET,OU,XOR,
décalage,. . .
Unité de décodage et
commande : génération
signaux de commande
(opération ALU, routage
des bus A,B et C).
Bus mémoire :
Année scolaire 2010-2011
12 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Architecture Interne d’un processeur
Registres
Single Core CPU
PC (R15) : Programme Counter
Address bus
R1
R2
Data bus
R3
Decode
IR
...
A
B
ALU
ALU operation mode
C
Loı̈c Cuvillon (ENSPS)
and Control Unit
Bus source
selection
PC
Memory
adresse de l’instruction en
cours ;
incrémenté par le CPU ;
(ou IP, instruction pointer)
IR : mot de l’instruction en cours
R1,R2,R3.. R14 : registres à
usages généraux
CPSR : current program status
register (flags sur résultat inst. :
Zero, Negatif)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
13 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
ISA : Instruction Set Architecture
Jeu d’instructions d’un CPU
Langage machine
langage natif du processeur définit par les concepteurs
seul et unique pour un processeur
un code binaire
l’Assembleur (Assembly language) :
représentation symbolique du langage machine
usage de mnémoniques pour faciliter la vie du programmeur
→ non-portable (6= langage haut-niveau (C,java))
(Saut d’adresse : B(L) chez ARM et JMP chez INTEL )
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
14 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
ISA : Instruction Set Architecture
Instruction d’addition sur processeur ARM
doc technique : ADD Rd Rn Rm
Rd=Rn+Rm (Rd : registre destination)
31
28 26 25
21 20
c o n d 0 00 0 1 0 0 0
16
Rn
12
Rd
3
shift
0
Rm
Assembleur : ADD R3 R2 R3 − > Langage machine :0xE0823003
31
28 26 25
21 20
16
12
0
1 11 0 0 00 0 1 0 0 0 0 0 1 0 0 0 1 1 0 00 0 0 00 0 0 0 1 1
(cond=1110 signifie ”toujours exécuter”)
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
15 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Illustration : Réalisation d’une addition
PC initialisé à 100
initialisation par un autre programme (ou reset du CPU)
Memory
Single Core CPU
R1
Address bus
R2
R3
PC
0x100 : LDR R2, 0x200
0x104 : LDR R3, #2
0x108 : ADD R3, R2, R3
0x10C : STR R3, 0x204
Data bus
0x100
Read/Write
IR
0x200 : 0x0005
0x204 : 0x????
...
ALU
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
16 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Illustration : Réalisation d’une addition
Fetch de l’instruction par l’IFU (Instruction Fetch Unit)
adresse de l’instruction donnée par le PC
Memory
Single Core CPU
0x100
R1
Address bus
R2
LDR R2, 0x200
R3
PC
0x100 : LDR R2, 0x200
0x104 : LDR R3, #2
0x108 : ADD R3, R2, R3
0x10C : STR R3, 0x204
Data bus
0x100
IR
LDR R2, 0x200
R
Read/Write
0x200 : 0x0005
0x204 : 0x????
...
ALU
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
17 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Illustration : Réalisation d’une addition
fin du Fetch : code de l’instruction à exécuter dans IR
Décodage et préparation du chemin de données
Memory
Single Core CPU
R1
Address bus
R2
R3
PC
0x100 : LDR R2, 0x200
0x104 : LDR R3, #2
0x108 : ADD R3, R2, R3
0x10C : STR R3, 0x204
Data bus
0x100
IR
LDR R2,0x200
Read/Write
0x200 : 0x0005
0x204 : 0x????
...
ALU
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
18 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Illustration : Réalisation d’une addition
Exécution de l’instruction LDR
LDR : load dans le registre Rx une donnée référencée ou une #constante
Single Core CPU
Memory
0x200
R1
R2
Address bus
0x0005
R3
PC
0x0005
0x100 : LDR R2, 0x200
0x104 : LDR R3, #2
0x108 : ADD R3, R2, R3
0x10C : STR R3, 0x204
Data bus
0x100
IR
LDR R2,0x200
R
Read/Write
0x200 : 0x0005
0x204 : 0x????
...
ALU
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
19 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Illustration : Réalisation d’une addition
fin de l’instruction
Incrémentation du PC de 0x004 : pointe sur instruction suivante
Memory
Single Core CPU
R1
R2
Address bus
0x0005
R3
PC
0x100 : LDR R2, 0x200
0x104 : LDR R3, #2
0x108 : ADD R3, R2, R3
0x10C : STR R3, 0x204
Data bus
0x104
IR
LDR
R2,0x200
Read/Write
0x200 : 0x0005
0x204 : 0x????
...
ALU
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
20 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Illustration : Réalisation d’une addition
Fetch de l’instruction suivante
écrase le contenu de l’IR
Memory
Single Core CPU
0x104
R1
R2
Address bus
0x0005
R3
PC
LDR R3, #2
0x100 : LDR R2, 0x200
0x104 : LDR R3, #2
0x108 : ADD R3, R2, R3
0x10C : STR R3, 0x204
Data bus
0x104
IR LDR R3, #2
R
Read/Write
0x200 : 0x0005
0x204 : 0x????
...
ALU
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
21 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Illustration : Réalisation d’une addition
Décode et Exécute l’instruction
LDR : load dans le registre Rx une donnée référencée ou une #constante
Memory
Single Core CPU
R1
Address bus
R2
0x0005
R3
0x0002
PC
0x104
IR LDR R3, #2
0x100 : LDR R2, 0x200
0x104 : LDR R3, #2
0x108 : ADD R3, R2, R3
0x10C : STR R3, 0x204
Data bus
Read/Write
0x200 : 0x0005
0x204 : 0x????
...
ALU
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
22 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Illustration : Réalisation d’une addition
fin de l’instruction : Incrémente de 0x004 le PC
Fetch de l’instruction suivante
Memory
Single Core CPU
0x108
R1
Address bus
R2
0x0005
R3
0x0002
PC
0x108
IR
ADD
R3,R2,R3
ADD R3, R2, R3
0x100 : LDR R2, 0x200
0x104 : LDR R3, #2
0x108 : ADD R3, R2, R3
0x10C : STR R3, 0x204
Data bus
R
Read/Write
0x200 : 0x0005
0x204 : 0x????
...
ALU
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
23 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Illustration : Réalisation d’une addition
exécution de l’instruction
ADD Rdest,Ra,Rb : addition Rdest<=Rb+Ra
Memory
Single Core CPU
R1
Address bus
R2
0x0005
R3
0x000 7
PC
0x108
0x100 : LDR R2, 0x200
0x104 : LDR R3, #2
0x108 : ADD R3, R2, R3
0x10C : STR R3, 0x204
Data bus
Read/Write
IR
ADD
R3,R2,R3
0x200 : 0x0005
0x204 : 0x????
...
0x05
0x02
ALU
Loı̈c Cuvillon (ENSPS)
+
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
24 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Illustration : Réalisation d’une addition
Fin instruction : incrémente le PC
Fetch instruction suivante
Memory
Single Core CPU
0x10C
R1
Address bus
R2
0x0005
R3
0x0007
PC
0x10C
IR R3,0x204
STR
STR R3,0x204
0x100 : LDR R2, 0x200
0x104 : LDR R3, #2
0x108 : ADD R3, R2, R3
0x10C : STR R3, 0x204
Data bus
Read/Write
0x200 : 0x0005
0x204 : 0x????
...
ALU
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
25 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Illustration : Réalisation d’une addition
Exécution de l’instruction
STR Rd Add : sauve contenu de Rd à l’adresse Add
Memory
Single Core CPU
0x204
R1
Address bus
R2
0x0005
R3
0x0007
PC
0x10C
IR R3,0x204
STR
0x0007
0x100 : LDR R2, 0x200
0x104 : LDR R3, #2
0x108 : ADD R3, R2, R3
0x10C : STR R3, 0x204
Data bus
W
Read/Write
0x200 : 0x0005
0x204 : 0x0007
...
ALU
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
26 / 82
Processeur et jeu d’instructions
Architecture ARM : principes
Le pipeline d’exécution
exécution en parallèle d’1 Fetch, 1 Décode et 1 Exécution
→ accélération du débit d’exécution : 1 exécution d’instruction/cycle
(alors que le traitement d’une instruction : 3 cycles)
Fetch de l’instruction pointée par PC+08 pendant exécution de PC
R1
Address bus
PC
R2
Data bus
R3
PC
Decode
...
A
B
R1
ALU
and Control Unit
(Inst.addr: PC−0x08)
IR
R3
LDR R2, #6
Bus source
selection
ADD R3, R3, R1
ADD R2, R2, R1
Fetch
Decode
Execute
Fetch
Decode
Execute
Fetch
Decode
LDR R2, #6
(Inst.addr: PC)
ALU operation mode
C
1 cycle
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Execute
temps
1 cycle
1 cycle
Année scolaire 2010-2011
27 / 82
Processeur et jeu d’instructions
Architecture Intel et Assembleur x86
Intel 8086
le 8086
processeur 16 bits, 8MHz, total de 16 registres
registres de 16 bits
= 64Ko de mémoire (216 adresses codées)
mais bus d’adresse de 220 bits = 1Mo (220
adresses)
accès complexe au 1Mo de mémoire :
8086 (1978 - 320$)
un registre segment de 16bits
offset : l’adresse mémoire sur 16bits
adresse finale= segment x16 + offset
son dérivé le 8088, coeur de l’IBM PC ! (1981)
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
28 / 82
Processeur et jeu d’instructions
Architecture Intel et Assembleur x86
Intel Pentium
ix86 : 386, 486, Pentium (586)
Démarrage en Mode réel :
Emulation du 8086 (compatibilité)
1 Mo uniquement accessible !
Mode protégé (activé par le bit Protection Enable dans le registre CR0) :
Mémoire virtuelle pagination, protection mémoire
Mécanisme pour le multitâche
Niveau de privilèges d’exécution (4)
Noyau (Toute Instruction permise)
User (Instruction I/O (entrées-sorties) indisponibles )
Loı̈c Cuvillon (ENSPS)
80286 (i286)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
29 / 82
Processeur et jeu d’instructions
Architecture Intel et Assembleur x86
Intel Pentium
Pentium P5 : Architecture interne
2 pipeline à 5 étages
prédiction de branchement dynamique
(avec historique)
mémoire cache séparée instructions données
(Harvard architecture)
cache TLB pour les tables de pages
(mémoire virtuelle)
processeur CISC
Complex Instruction Set Computer ;
Instructions de taille variable ! ;
Transformées à la volée en
micro-instruction (− > RISC)
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
pentium 4
(http ://www.cs.clemson.edu/m̃ark/330/p6.html)
Année scolaire 2010-2011
30 / 82
Processeur et jeu d’instructions
Architecture Intel et Assembleur x86
Intel Pentium
Registres du x86
EAX
General
registers
EBX
ECX
CS
Code Segment
DS
Data Segment
SS
Stack Segment
EDX
EIP
Instruction pointer
EBP
Stack Base pointer
ESP
Stack pointer
EFLAGS
CR3
EAX
Loı̈c Cuvillon (ENSPS)
Control 3
(page directory adress)
: memory management
AX
AH
Status
AL
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
31 / 82
Processeur et jeu d’instructions
Architecture Intel et Assembleur x86
Intel Pentium
Assembleur x86 : syntax AT&T
section données
initialisées
.data
# start of data segment
commentaire
x: .long 2
y: .long 47
section code
.text
# start of code segment
.globl _start
_start: point d’entrée
par défaut du prog.
_start:
ordre ops : source puis destination
(inverse en syntaxe intel et ARM)
movl y, %eax
movl $x, %ebx
%eax: mot dans le registre
cmpl (%ebx), %eax
(%ebx): mot a l’adresse
contenue dans %ebx
$ = constante
$x=cst=adresse du mot x
jne next
inc %eax
next: addl $1, (%ebx)
Loı̈c Cuvillon (ENSPS)
( ), operateur indirection :
la donnée de l’adresse contenue dans ebx
[ * en langage C ]
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
32 / 82
Processeur et jeu d’instructions
Architecture Intel et Assembleur x86
Intel Pentium
Assembleur x86 : syntaxe AT&T
.data
label: symbole pour l’adresse
d’une donnée ou instruction
# start of data segment
x: .long 2
y: .long 47
.text
# start of code segment
.globl _start
_start:
operation sur mots 32bits (l)
(w pour 16, b pour 8)
movl y, %eax
# mettre valeur y (47) dans eax
movl $x, %ebx
# mettre l’adresse de x dans ebx
cmpl (%ebx), %eax
# comparer la valeur de x et y
jne next
# jump if not equal
inc %eax
# incrementer eax
next: addl $1, (%ebx)
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
# x=x+1
Année scolaire 2010-2011
33 / 82
Processeur et jeu d’instructions
Architecture Intel et Assembleur x86
Intel Pentium
Opérandes
Registres : %eax, %ax, %ebx, ...
Valeurs immédiates = constantes : $2 , $label (l’adresse de la variable)
Mot, variable en mémoire : label et (%eax) (variable à l’adresse %eax)
Opérations de déplacement : movl
%eax,%ebx : copie entre registre
$0x??,%eax ou $n,%eax : copie d’une constante vers registre
(%eax),%ebx, ou n,%ebx, ou 0x??,%ebx : copie mémoire vers
registre
%eax,n ou %eax,(%ebx) ou %eax,0x?? : copie registre vers
mémoire
Mais opération entre 2 mots en mémoires impossible
Identique pour l’addition, la soustraction, ...
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
34 / 82
Processeur et jeu d’instructions
Branchements et leur prédiction
Limites du pipeline d’exécution : les branchements
Branchement : saut d’adresse
eflags ou cpsr : registre de
statut :
cmpl %edx, $0
if (i==0)
Z=1
movl $1, %eax
{a=1;
b=2;}
Z=0
...
movl $2; %ebx
jmp next
else
a=3;
jne else1
else1:
movl $3, %eax
next :
...
Loı̈c Cuvillon (ENSPS)
flag Z(ero) : 1 si résultat=0
flag S(igne) :1 si résultat<0
flag O(verflaw)
cmp op1,op2 : update statut
suivant résultat de (op1-op2)
jmp : saut inconditionnel
jz, je : si égalité (Z=1)
jnz, jne : si inégalité (Z=0)
jg, [jge] : si > 0 [≥]
flags (S xor O)=0
jl, [jle] : si < 0 [ou ≤]
flags (S xor O)=1
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
35 / 82
Processeur et jeu d’instructions
Branchements et leur prédiction
Limites du pipeline d’exécution : les branchements
Cas sans branchement
egalité : Z=1
0xF00(%EIP): jne else1
Fetch
Decode
Execute
Fetch
Decode
Execute
Fetch
Decode
Execute
Fetch
Decode
z=1
0xF04: movl $1, %eax
0xF08: movl $2, %ebx
0xF0C: jump next
Execute
t
Aucun problème dans le pipeline
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
36 / 82
Processeur et jeu d’instructions
Branchements et leur prédiction
Limites du pipeline d’exécution : les branchements
Cas avec branchement
inégalité : Z=0
0xF00(%EIP): jne else1
0xF04: movl $1, %eax
0xF08: movl $2, %ebx
Fetch
Decode
Execute
Fetch
Decode
Execute
Fetch
Decode
Execute
Fetch
Decode
z=0
next %EIP= else1
else1: movl $3, %eax
Execute
t
Pipeline à vider (aucune instruction exécutée pendant 2 cycles)
saut : 20% des instructions (+14 étapes pour pentium 4 pipeline)
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
37 / 82
Processeur et jeu d’instructions
Branchements et leur prédiction
Limites du pipeline d’exécution : les branchements
Solution : prédiction de branchement
statique (≤60%)
1. considérer que le branchement n’est pas pris !
dynamique (>90%)
Prédiction avec un historique des résultats de branchements (pris/pas pris)
Uilise une table (Branch Target Buffer) contenant
1
2
le branchement concerné (identifié par son adresse PC )
l’adresse prédite pour l’instruction suivante
Branch Target Buffer (BTB)
Loı̈c Cuvillon (ENSPS)
Branch PC
Predicted PC
0x034D
...
0x0F50
2 bits history
(taken/not taken)
Systèmes temps réel et systèmes embarqués
01
Année scolaire 2010-2011
38 / 82
Processeur et jeu d’instructions
Branchements et leur prédiction
Limites du pipeline d’exécution : les branchements
Fetch
Decode
Instruction
Current PC
Execute
Update BTB
history &
predicted PC
Non
is a branch ?
in BTB?
Oui
Non
Add current PC
to BTB
O/N
Branch
taken ?
O/N
Oui
BTB
Oui
Correct
Prediction?
Non
Predicted
PC
FLUSH
PIPELINE
Set New PC
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
39 / 82
Processeur et jeu d’instructions
Branchements et leur prédiction
Assembleur x86 : Exercice
# Sum of Array Elements
.data
x:
# data segment
.long 300
.long 4
.long 3
sum: .long 0
.text
.globl _start
_start: nop
movl $0, %eax
movl $x, %ebx
proces: addl
addl
addl
addl
addl
movl
exit:
(%ebx), %eax
$4, %ebx
(%ebx), %eax
$4, %ebx
(%ebx), %eax
%eax, sum
movl $1, %eax
int $0x80
Loı̈c Cuvillon (ENSPS)
# code segment
# no-operation (for debug purpose)
# EAX stores temporary result
# EBX
# store result in "sum"
# clean exit of the program (optional)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
40 / 82
Processeur et jeu d’instructions
Branchements et leur prédiction
Assembleur x86 : Exercice
assemblage + debug(-g) : as -g sum2.S -o sum2.o
création exécutable : ld sum2.o -o sum2
déboguer : ddd sum2
ddd, gui pour le gnu débogueur
1
2
3
4
5
6
Activer source, machine code, data windows et command tool dans View
Ajouter un breakpoint sur l’instruction movl $0,%eax (avec clic droit)
Visualiser l’état du mot sum (clic droit, ”display”)
Exécuter le programme avec Run dans la fenêtre ”command tool”
Il stoppe sur le breakpoint. Afficher les registres : Menu Status, Registers
Exécution instr. par instr. avec stepi dans la fenêtre ”command tool”
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
41 / 82
Processeur et jeu d’instructions
Branchements et leur prédiction
Assembleur x86 : Exercice 1
Questions :
1
2
3
Exécuter le programme à nouveau : Run et avancer de 2 instructions.
Que réalise l’opération movl $x, %ebx ? Vérifier votre réponse en
affichant le contenu de l’adresse indiquée dans %ebx (Data→Memory→
1 word from 0x..... et Display).
D’ailleurs, utiliser l’outil Data→Memory pour déterminer si la machine est
big ou little endian.
Que réalise l’opération addl %(ecx), %ebx ? Où est stocké le
résultat ?
4
Pourquoi l’instruction addl $4, %ecx permet-elle d’accéder à l’élément
suivant de x ?
5
La valeur de sum est elle celle attendue à la fin du programme ?
Comparer l’assembleur source et le code machine désassemblé.
6
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
42 / 82
Processeur et jeu d’instructions
Branchements et leur prédiction
Assembleur x86 : Exercice 2
.data # data segment
x:
.long 300
.long 4
.long 3
sum: .long 0
.text # code segment
.globl _start
_start: nop
# no-operation (for debug purpose)
movl $0, %eax
# EAX stores temporary result
movl $x, %ebx
# EBX
movl $3, %ecx
# ECX
proces: addl (%ebx), %eax
addl $4, %ebx
decl %ecx
jnz process
movl %eax, sum # store result in "sum"
exit: movl $1, %eax
int $0x80
1
#exit program, explanation later
Vérifier que le saut n’a lieu q’avec le flag Z présent dans le registre
EFLAGS.
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
43 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile d’exécution (stack)
Espace mémoire croissant vers des adresses inférieures
%esp : stack pointer (SP), pointeur permanent sur le sommet de la pile
push %eax : pose contenu de EAX sur la pile
pop %eax : retire le sommet de la pile dans EAX
push %eax
#%eax=0x19
after POP %ax
after PUSH %ax
initial State
movl $0xF17, %eax
Adresse
...
...
0x000
pop %eax
0x000
0x000
#%eax=0x19
...
SP
0x??????
SP
0x000019
0x000019
SP
0xFFFFF0
0x0F4
0xFFFFF0
0x0F4
0xFFFFF0
0x0F4
0x00B471
0x0F8
0x00B471
0x0F8
0x00B471
0x0F8
0xA5063C
0x0FC
0xA5063C
0x0FC
0xA5063C
0x0FC
un usage du stack : sauvegarde et restauration de %eax si besoin
temporaire de celui-ci pour une fonctionnalité
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
44 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
CALL/RET et les procédures (fonctions)
la pile stocke les adresses PC de retour des fonctions
ret, retour au programme appelant
L’adresse de retour (nouveau PC) est prise sur la pile.
ret ≈ pop %eip
call label, adresse de retour est posée sur la pile
ET saut à la procédure call label ≈ push %eip+4 ; jmp label
Stack
0x00
main: ...
func stack frame
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
0xA38
func1 : incl %eax
0xA3C
incl %ebx
0xA40
ret
Loı̈c Cuvillon (ENSPS)
main stack frame
SP
0x0398D
0x0FF49B
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
45 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
CALL/RET et les procédures (fonctions)
la pile stocke les adresses PC de retour des fonctions
ret, retour au programme appelant
L’adresse de retour (nouveau PC) est prise sur la pile.
ret ≈ pop %eip
call label, adresse de retour est posée sur la pile
ET saut à la procédure call label ≈ push %eip+4 ; jmp label
Stack
0x00
main: ...
func stack frame
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
Push Return IP
and jump
SP
main stack frame
0x0318
0xA38
func1 : incl %eax
0x0398D
0xA3C
incl %ebx
0x0FF49B
0xA40
ret
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
46 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
CALL/RET et les procédures (fonctions)
la pile stocke les adresses PC de retour des fonctions
ret, retour au programme appelant
L’adresse de retour (nouveau PC) est prise sur la pile.
ret ≈ pop %eip
call label, adresse de retour est posée sur la pile
ET saut à la procédure call label ≈ push %eip+4 ; jmp label
Stack
0x00
main: ...
func stack frame
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
main stack frame
SP
0x0318
0xA38
func1 : incl %eax
0x0398D
0xA3C
incl %ebx
0x0FF49B
0xA40
ret
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
47 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
CALL/RET et les procédures (fonctions)
la pile stocke les adresses PC de retour des fonctions
ret, retour au programme appelant
L’adresse de retour (nouveau PC) est prise sur la pile.
ret ≈ pop %eip
call label, adresse de retour est posée sur la pile
ET saut à la procédure call label ≈ push %eip+4 ; jmp label
Stack
0x00
main: ...
func stack frame
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
main stack frame
SP
0x0318
0xA38
func1 : incl %eax
0x0398D
0xA3C
incl %ebx
0x0FF49B
0xA40
ret
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
48 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
CALL/RET et les procédures (fonctions)
la pile stocke les adresses PC de retour des fonctions
ret, retour au programme appelant
L’adresse de retour (nouveau PC) est prise sur la pile.
ret ≈ pop %eip
call label, adresse de retour est posée sur la pile
ET saut à la procédure call label ≈ push %eip+4 ; jmp label
Stack
0x00
main: ...
func stack frame
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
main stack frame
0x0318
0xA38
func1 : incl %eax
0xA3C
incl %ebx
0xA40
ret
Loı̈c Cuvillon (ENSPS)
SP
0x0398D
0x0FF49B
previous stack
0xFC
Pop return IP
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
49 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
CALL/RET et les procédures (fonctions)
la pile stocke les adresses PC de retour des fonctions
ret, retour au programme appelant
L’adresse de retour (nouveau PC) est prise sur la pile.
ret ≈ pop %eip
call label, adresse de retour est posée sur la pile
ET saut à la procédure call label ≈ push %eip+4 ; jmp label
Stack
0x00
main: ...
func stack frame
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
0xA38
func1 : incl %eax
0xA3C
incl %ebx
0xA40
ret
Loı̈c Cuvillon (ENSPS)
main stack frame
SP
0x0398D
0x0FF49B
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
50 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
la pile autorise les appels imbriqués ou récursifs en conservant
l’historique des adresses de retour
main: ...
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
Stack
0x00
func stack frame
0x444
func2 : incl %edx
0x448
subl %eax,%ebx
0x44C
ret
main stack frame
...
SP
0xA38
func1 : incl %eax
0xA3C
call 0x444 <func2>
0xA40
ret
Loı̈c Cuvillon (ENSPS)
0x0398D
0x0FF49B
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
51 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
la pile autorise les appels imbriqués ou récursifs en conservant
l’historique des adresses de retour
main: ...
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
Stack
0x00
func stack frame
0x444
func2 : incl %edx
0x448
subl %eax,%ebx
0x44C
ret
main stack frame
SP
...
0x0398D
0xA38
func1 : incl %eax
0xA3C
call 0x444 <func2>
0xA40
ret
Loı̈c Cuvillon (ENSPS)
0x318
0x0FF49B
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
52 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
la pile autorise les appels imbriqués ou récursifs en conservant
l’historique des adresses de retour
main: ...
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
Stack
0x00
func stack frame
0x444
func2 : incl %edx
0x448
subl %eax,%ebx
0x44C
ret
main stack frame
SP
...
0x0398D
0xA38
func1 : incl %eax
0xA3C
call 0x444 <func2>
0xA40
ret
Loı̈c Cuvillon (ENSPS)
0x318
0x0FF49B
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
53 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
la pile autorise les appels imbriqués ou récursifs en conservant
l’historique des adresses de retour
main: ...
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
Stack
0x00
func stack frame
0x444
func2 : incl %edx
0x448
subl %eax,%ebx
0x44C
ret
SP
main stack frame
0x318
...
0x0398D
0xA38
func1 : incl %eax
0xA3C
call 0x444 <func2>
0xA40
ret
Loı̈c Cuvillon (ENSPS)
0xA40
0x0FF49B
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
54 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
la pile autorise les appels imbriqués ou récursifs en conservant
l’historique des adresses de retour
main: ...
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
Stack
0x00
func stack frame
0x444
func2 : incl %edx
0x448
subl %eax,%ebx
0x44C
ret
SP
main stack frame
0x318
...
0x0398D
0xA38
func1 : incl %eax
0xA3C
call 0x444 <func2>
0xA40
ret
Loı̈c Cuvillon (ENSPS)
0xA40
0x0FF49B
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
55 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
la pile autorise les appels imbriqués ou récursifs en conservant
l’historique des adresses de retour
main: ...
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
Stack
0x00
func stack frame
0x444
func2 : incl %edx
0x448
subl %eax,%ebx
0x44C
ret
SP
main stack frame
0x318
...
0x0398D
0xA38
func1 : incl %eax
0xA3C
call 0x444 <func2>
0xA40
ret
Loı̈c Cuvillon (ENSPS)
0xA40
0x0FF49B
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
56 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
la pile autorise les appels imbriqués ou récursifs en conservant
l’historique des adresses de retour
main: ...
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
Stack
0x00
func stack frame
0x444
func2 : incl %edx
0x448
subl %eax,%ebx
0x44C
ret
0xA40
main stack frame
SP
...
0x0398D
0xA38
func1 : incl %eax
0xA3C
call 0x444 <func2>
0xA40
ret
Loı̈c Cuvillon (ENSPS)
0x318
0x0FF49B
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
57 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
la pile autorise les appels imbriqués ou récursifs en conservant
l’historique des adresses de retour
main: ...
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
Stack
0x00
func stack frame
0x444
func2 : incl %edx
0x448
subl %eax,%ebx
0x44C
ret
main stack frame
0x318
...
SP
0xA38
func1 : incl %eax
0xA3C
call 0x444 <func2>
0xA40
ret
Loı̈c Cuvillon (ENSPS)
0x0398D
0x0FF49B
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
58 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
la pile autorise les appels imbriqués ou récursifs en conservant
l’historique des adresses de retour
main: ...
0x310
movl $0xF17, %ecx
0x314
call 0xA38 <func1>
0x318
...
Stack
0x00
func stack frame
0x444
func2 : incl %edx
0x448
subl %eax,%ebx
0x44C
ret
main stack frame
...
SP
0xA38
func1 : incl %eax
0xA3C
call 0x444 <func2>
0xA40
ret
Loı̈c Cuvillon (ENSPS)
0x0398D
0x0FF49B
Systèmes temps réel et systèmes embarqués
previous stack
0xFC
Année scolaire 2010-2011
59 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et le passage de paramètres au fonctions
Convention pour les appels de fonctions C
1
2
Paramètres passés sur la pile dans l’ordre inverse du prototype
Après exécution du call, la procédure appelée (fonctionC) :
Trouve ses paramètres dans la pile sous l’adresse de retour (initialement :
SP+4 → param1 , SP+8 → param2,..)
Peut utiliser la pile (%ebp éventuellement disponible pour mémoriser la
position de SP à l’entrée et la position des paramètres)
Met son code d’erreur ou sa valeur de retour dans %eax.
Supprime ses variables temporaires sur la pile (donc ESP → PC retour)
Exécute l’instruction ret
3
Suppression des paramètres passés sur la pile par l’appelant
La procédure rend la pile à l’appelant dans le même état qu’avant le call
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
60 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
func : ...
...
# int func(int* data, int b)
ret
Stack
main: ...
0x00
func stack frame
movl %edx, %ecx
pushl 685
pushl $data
main stack frame
call func
nop
SP
previous stack
addl $4, %esp
0xFC
...
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
61 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
func : ...
...
# int func(int* data, int b)
ret
Stack
main: ...
0x00
movl %edx, %ecx
pushl 685
pushl $data
call func
SP
@data
main stack frame
685
nop
previous stack
addl $4, %esp
0xFC
...
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
62 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
func : ...
...
# int func(int* data, int b)
ret
Stack
main: ...
0x00
movl %edx, %ecx
pushl 685
pushl $data
call func
SP
PC retour
@data
main stack frame
685
nop
previous stack
addl $4, %esp
0xFC
...
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
63 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
func : ...
...
# int func(int* data, int b)
ret
Stack
main: ...
0x00
SP
func stack frame
movl %edx, %ecx
local var
pushl 685
PC retour
pushl $data
call func
@data
(
BP)
main stack frame
685
nop
previous stack
addl $4, %esp
0xFC
...
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
64 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
func : ...
...
# int func(int* data, int b)
ret
Stack
main: ...
0x00
func stack frame
movl %edx, %ecx
pushl 685
pushl $data
call func
SP
PC retour
@data
main stack frame
685
nop
previous stack
addl $4, %esp
0xFC
...
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
65 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
func : ...
...
# int func(int* data, int b)
ret
Stack
main: ...
0x00
movl %edx, %ecx
pushl 685
pushl $data
call func
SP
@data
main stack frame
685
nop
previous stack
addl $4, %esp
0xFC
...
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
66 / 82
Processeur et jeu d’instructions
La Pile d’exécution
La Pile et les appels de procédures
func : ...
...
# int func(int* data, int b)
ret
Stack
main: ...
0x00
movl %edx, %ecx
pushl 685
pushl $data
main stack frame
call func
nop
SP
previous stack
addl $4, %esp
0xFC
...
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
67 / 82
Processeur et jeu d’instructions
La Pile d’exécution
Assembleur x86 : Exemple
# Call C function "puts" from asm
# char message[]="Hello world!";
# int main()
# { puts(&message);
#
return 0;}
.data
message:
.ascii "Hello world!\0"
#.align 4
.text
.globl main
main:
pushl $message
call puts
addl $4,%esp
movl $0, %eax
ret
Loı̈c Cuvillon (ENSPS)
#push the one parameter : @ de message
#remove parameter from the stack
#main : return 0; != movl 0,%eax
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
68 / 82
Processeur et jeu d’instructions
La Pile d’exécution
Assembleur x86 : Exercice
Compilation
assemblage + debug(-g) : as -g puts.S -o puts.o
création exécutable : gcc puts.o -o puts (lien avec la libC)
déboguer : ddd sum2
Exercice
Utiliser Data− >Memory pour afficher le sommet de la pile (4 hex words
from $esp) et constater le passage des paramètres ainsi que de
l’adresse de retour.
Modifier le programme puts.S pour utiliser la fonction C write au lieu de
puts
prototype write (file descrp., *cst char message , size of msg ) et voir le
manuel man 2 write
par défaut linux associe un file descripteur =1 pour le terminal-sdout
write retourne le nombre d’octet effectivement écrit
Utiliser le débogueur pour vérifier le code de retour de la fonction write
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
69 / 82
Du source à l’exécutable
Plan
1
Processeur et jeu d’instructions
Architecture ARM : principes
Architecture Intel et Assembleur x86
Branchements et leur prédiction
La Pile d’exécution
2
Du source à l’exécutable
Le format ELF
Le code relogeable
L’exécutable et son chargement
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
70 / 82
Du source à l’exécutable
Le format ELF
Le processus : compilation de son programme/code
La compilation C via GCC
GCC :
un préprocesseur (cpp) : suppression des commentaires, expansion des
macros (.i)
un compilateur (cc1) : traduction vers assembleur (.s)
un assembleur (as) : traduction assembleur (.s) − > objet .o (binaire
machine)
options possibles : -I[/chemin/vers/include] -L[/chemin/vers/bibliothèsque]
-l[bibliothèque] (-g pour debug)
un éditeur de lien : ld
localise les symboles (fonctions, variables globales) dans les bibliothèques
et objets
reloge les symboles dans un même fichier
mise sous un format exécutable en mémoire
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
71 / 82
Du source à l’exécutable
Le format ELF
la création d’un exécutable : la compilation sous Linux
1
2
3
4
gcc -E source.c -o source.i ou cpp source.c -o source.i
gcc -S source.i -o source.s
gcc -c source.s -o source.o ou as source.s -o source.o
ld -lc -[runtime C librairies,...] source.o -o source
source
assembleur
gcc −E
gcc −S
.i
.c
cpp
objet (language machine)
gcc −c
.s
cc1
.o
as
ld −lc −l[C runtime]
−lm −ljpg
gcc −lm −ljpg
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
libjpeg.a
libm.a
libc.a
executable (ELF)
Année scolaire 2010-2011
72 / 82
Du source à l’exécutable
Le format ELF
le format ELF
ELF (Executable and Linking Format)
conteneur commun pour les fichiers objets,
exécutables et bibliothèques partagées
utilisé par Linux, Wii, PS3,...
l’entête ELF :
la localisation dans le fichier de la table des
sections
l’adresse de la fonction start (si un exécutable)
Si objet : la table des sections donne la position
dans le fichier des diversessections
(.text (code), .data, .symbols, ...)
Si exécutable : la table programme indique où
charger en mémoire les segments
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
ELF Header
Programm Header
Table
.text
.rodata
(other
sections)
.data
Section Header
Table
Année scolaire 2010-2011
73 / 82
Du source à l’exécutable
Le format ELF
le format ELF
utilitaires du format elf
readelf
objdump
-f : affiche l’entête ELF du fichier
-h : affiche la table des sections
-t : affiche la table des symboles
-r : affiche la table de relogement
-d : désassemble le code de la section .text
-D : désassemble toute les sections
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
74 / 82
Du source à l’exécutable
Le code relogeable
les différents fichiers objets
Fichier objet relogeable .o
symboles : tous les labels des procédures et données
1 table de symboles : labels et leur adresse de définition dans l’objet
1 table de relogement : adresses d’occurrences des symboles non définis
Le relogement :
fusion de sections identiques (code (.text), données (.data)) en une seule
section
et mise à jour des adresses des symboles avec leur nouvelle adresse après
fusion
bibliothèque statique .a
une archive .a contenant un ensemble de .o
Création : ar -q ma_biblioteq.a func.o func2.o ...
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
75 / 82
Du source à l’exécutable
Le code relogeable
Les bibliothèques de code relogeable
bibliothèque statique .a
code de la librairie copié dans
l’exécutable
exécutable sans dépendance
lourde empreinte disque et
mémoire
bibliothèque dynamique .so
édition de liens à l’exécution
pas de duplication de code
empreinte mémoire légère
dépendance : bibliothèque
installée ?
Hello world ! avec la lib C
gcc –static
hello.c -o hello
ls -l hello : 564 Ko
Loı̈c Cuvillon (ENSPS)
gcc hello.c -o hello
ls -l hello : 7 Ko
ldd ./hello :
(liste dépendances)
libc.so.6
ld-linux.so.2
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
76 / 82
Du source à l’exécutable
Le code relogeable
Les bibliothèques dynamiques et statiques
bibliothèques dynamiques .so
bibliothèques statiques .a
add.o
fopen.o
...
fopen.o
...
add.o
source.o
source.o
source2.o
source2.o
linker
linker
main: x
x
printf: x
x
x
add: x
x
Loı̈c Cuvillon (ENSPS)
libc.so
printf.o
libc.a
printf.o
linker
linker
main: x
x
printf: x
x
Executables
main: x
x
add: x
x
printf:−
partially linked executables
main: x
x
(en mémoire)
printf.o
libc.so printf:−
fopen.o
...
loader (execv)
dynamic linker (ld−linux.so)
loader (execv)
dynamic linker
full executable in memory
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
77 / 82
Du source à l’exécutable
Le code relogeable
Fichier objet relogeable .o
as source.s -o source.o et objdump -t -r -D source.o
Offset
section
Assembleur :source.s
Disassembly of section .text:
.text
.globl _start
_start:
Objet :source.o
0:b8 00 00 00 00
movl $a,%eax
movl $b,%ebx
as
call sum
mov
5:bb 00 00 00 00
0x6
a:e8 fc ff ff ff
$0x0,%eax
mov $0x0,%ebx
call ?
Disassembly of section .data:
0:aa 00 00 00
.data
a:
.long 0xAA
SYMBOL TABLE:
RELOCATION RECORDS FOR [.text]:
OFFSET TYPE
VALUE
00000006 R_386_32
0000000b R_386_PC32
b
sum
00000000 l .data
00000000 g .text
00000000 *UND*
00000000 *UND*
Offset
definition
00000000 a
00000000 _start
00000000
b
sum
00000000
section
Undefined
name
local/ global
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
78 / 82
Du source à l’exécutable
Le code relogeable
Relogement partiel
ld -r *.o -o prog.o : fusion sections et mise à jour adresses
+ source.o
Objet :sum.o
Objet : prog.o
Disassembly of section .text:
Disassembly of section .text:
0: 8b 08
2: 03 0b
mov (%eax),%ecx
add (%ebx),%ecx
4: c3
ret
0: b8 00 00 00 00
5: bb 00 00 00 00
a: e8 fc ff ff ff
f: 90
10: 8b 08
12: 03 0b
14: c3
Disassembly of section .data:
0: bb 00 00 00
RELOCATION RECORDS FOR [.text]:
(empty)
SYMBOL TABLE:
00000000 g .text 00000000 sum
00000000 g .data 00000000 b
mov
mov
call
nop
mov
add
ret
$0x0,%eax
$0x0,%ebx
? <_start+?>
(%eax),%ecx
(%ebx),%ecx
Disassembly of section .data:
0:aa 00 00 00
4: bb 00 00 00
SYMBOL TABLE:
00000000 l .data 00000000 a
00000004 g .data 00000000 b
00000010 g .text 00000000 sum
00000000 g .text 00000000 _start
nouvelles
adresses
RELOCATION RECORDS FOR [.text]:
00000006 R_386_32
b
0000000b R_386_PC32
sum
Loı̈c Cuvillon (ENSPS)
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
79 / 82
Du source à l’exécutable
L’exécutable et son chargement
L’exécutable : relogement finale
substitution de tous les symboles par des adresses mémoires effectives
ld
Objet : prog.o
Disassembly of section .text:
0: b8 00 00 00 00
5: bb 00 00 00 00
a: e8 fc ff ff ff
f: 90
10: 8b 08
12: 03 0b
14: c3
mov $0x0,%eax
mov $0x0 ,%ebx
call ? <_start+?>
nop
mov (%eax),%ecx
add (%ebx),%ecx
ret
Disassembly of section .data:
0:aa 00 00 00
4: bb 00 00 00
Exec File : prog
Disassembly of section .text:
8048074: b8 8c 90 04 08
mov $0x804908c,%eax
8048079: bb 90 90 04 08 mov $0x8049090 ,%ebx
804807e: e8 01 00 00 00 call
0x8048084 (next inst. +1)
8048083: 90
nop
8048084: 8b 08
mov (%eax),%ecx
8048086: 03 0b
add (%ebx),%ecx
8048088: c3
ret
Disassembly of section .data:
804908c:aa 00 00 00
8049090: bb 00 00 00
SYMBOL TABLE:
00000000 l .data 00000000 a
00000004 g .data 00000000 b
00000010 g .text 00000000 sum
00000000 g .text 00000000 _start
SYMBOL TABLE :
(optional!)
RELOCATION RECORDS FOR [.text]:
00000006 R_386_32
b
0000000b R_386_PC32
sum
start address 0x08048074
Loı̈c Cuvillon (ENSPS)
NO RELOCATION RECORDS
ELF HEADER:
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
80 / 82
Du source à l’exécutable
L’exécutable et son chargement
L’exécutable : relogement finale
suppression tables de relogement (et symboles avec utilitaire strip)
code machine prêt pour exécution par CPU
ld
Objet : prog.o
Disassembly of section .text:
0: b8 00 00 00 00
5: bb 00 00 00 00
a: e8 fc ff ff ff
f: 90
10: 8b 08
12: 03 0b
14: c3
mov $0x0,%eax
mov $0x0 ,%ebx
call ? <_start+?>
nop
mov (%eax),%ecx
add (%ebx),%ecx
ret
Disassembly of section .data:
0:aa 00 00 00
4: bb 00 00 00
SYMBOL TABLE:
00000000 l .data 00000000 a
00000004 g .data 00000000 b
00000010 g .text 00000000 sum
00000000 g .text 00000000 _start
RELOCATION RECORDS FOR [.text]:
00000006 R_386_32
b
0000000b R_386_PC32
sum
Loı̈c Cuvillon (ENSPS)
Exec File : prog
Disassembly of section .text:
8048074: b8 8c 90 04 08
mov $0x804908c,%eax
8048079: bb 90 90 04 08 mov $0x8049090 ,%ebx
0x8048084 (next inst. +1)
804807e: e8 01 00 00 00 call
8048083: 90
nop
8048084: 8b 08
mov (%eax),%ecx
8048086: 03 0b
add (%ebx),%ecx
8048088: c3
ret
Disassembly of section .data:
8049090: bb 00 00 00
804908c:aa 00 00 00
SYMBOL TABLE :
(optional!)
NO RELOCATION RECORDS
ELF HEADER:
start address 0x08048074
Systèmes temps réel et systèmes embarqués
Année scolaire 2010-2011
81 / 82
Du source à l’exécutable
L’exécutable et son chargement
L’exécutable : Exécution
Appel au programme de chargement : le loader (Linux)
(1) copie le code de l’exécutable aux adresses définies à la compilation
(2) exécution par copier de l’adresse d’entrée dans registre PC
Secondary Memory
Main Memory (RAM)
00 45 F2 71
(Hard Disk Drive)
0x0000000
./prog
...
ELF Header
Single Core CPU
@start_: 0x8048074
...
0x8048074
Programm Header
mov 0x804908c, %eax
EAX
EBX
ECX
section
...
...
jne 0x45DE804
...
PC 0x8048074
aa 00 00 00
(2)
.data
mov 0x804908c, %eax
(1)
0x804908c
.text
aa 00 00 00
...
...
Loı̈c Cuvillon (ENSPS)
0x8048074
0x804908c
"loader"
...
...
memory addr
.text
(1)
0xFFF0000
Systèmes temps réel et systèmes embarqués
.data
./toto.txt
./011.mp3
Année scolaire 2010-2011
82 / 82