Architecture des ordinateurs

publicité
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Architecture des ordinateurs
Jérémy Fix
CentraleSupélec
[email protected]
2016-2017
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Petit retour sur l’architecture v0
00 00800008 00000000 00000000 00000000
04 00000000 00000000 00000000 00000000
08 00000c00 01401900 00000000 00000000
+1
0c 0080000c 00000000 00000000 00000000
10 00000c00 00084100 00c01800 00000000
MicroPC
14 00000c00 00080500 00084100 00c01800
D
18 00000000 00000000 00000000 00000000
00
@Adr
01
[8:15]
1c 00000c00 00080500 00002200 00c01800
00
Mux
10
Adr 20
00000c00 00090100 00c01800 00000000
···
···
···
···
···
30 00b0e000 00000000 00000000 00000000
···
···
···
···
···
[0:7]
11
MuxSel
70 00000c00 00881100 00000000 00000000
74 01802076 00c01800 00000c00 00881100
78 0188807a 00c01800 00000c00 00881100
CodeMCount
32
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
CodeMCount
UAL
SetB
ReadB
SetA
ReadA
SetPC
ReadPC
SetRADM
SetMem
ReadMem
@Adr
Bus B
Bus A
ReadMem
0x1000 0x0010 0x2000 0x0001
0x3000 0x1c00 0x000A 0x0000
Do
ReadA
RADM
Adr
0x0000 0x0000 0x0000 0x0000
ReadB
A
B
PC
0x0000
0x0000
0x0000
0x0000
SetRADM
SetA
SetB
SetPC
ReadPC
A
UAL
Di
SetMem
B
Z
C
S
V
Bus S
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Architecture à Jeu d’instructions (ISA)
Code instruction
0x0c00
0x1000
0x1400
0x1c00
0x2000
0x2400
0x2c00
0x3000
0x3400
0x3800
0x3c00
0x4000
0x4400
0x4800
0x5000
0x5400
0x5800
0x5c00
0x6000
0x6400
0x7000
0x7400
0x7800
Architecture
Nom
END
LDAi
LDAd
STA
LDBi
LDBd
STB
ADDA
ADDB
SUBA
SUBB
MULA
MULB
DIVA
ANDA
ANDB
ORA
ORB
NOTA
NOTB
JMP
JZA
JZB
Mots
1
2
2
2
2
2
2
1
1
1
1
1
1
1
1
1
1
1
1
1
2
2
2
Description
Fin du programme
Charge la valeur de l’opérande dans le registre A. [A:=opérande]
Charge la valeur dans la RAM pointée par l’opérande dans le registre A. [A:=Mem
Sauvegarde en mémoire la valeur du registre A à l’adresse donnée par l’opérande.
Charge la valeur de l’opérande dans le registre B. [B:=opérande]
Charge la valeur dans la RAM pointée par l’opérande dans le registre B. [B:=Mem
Sauvegarde en mémoire la valeur du registre B à l’adresse donnée par l’opérande.
Ajoute le contenu des registres A et B et mémorise le résultat dans le registre A. [
Ajoute le contenu des registres A et B et mémorise le résultat dans le registre B. [
Soutstrait le contenu des registres A et B et mémorise le résultat dans le registre A
Soutstrait le contenu des registres A et B et mémorise le résultat dans le registre B
Multiplie le contenu des registres A et B et mémorise le résultat dans le registre A
Multiplie le contenu des registres A et B et mémorise le résultat dans le registre B
Divise le contenu du registre A par deux et mémorise le résultat dans A. [A:=A/2]
Calcule un ET logique entre le contenu des registres A et B et mémorise le résulta
Calcule un ET logique entre le contenu des registres A et B et mémorise le résulta
Calcule un OU logique entre le contenu des registres A et B et mémorise le résulta
Calcule un OU logique entre le contenu des registres A et B et mémorise le résulta
Mémorise dans A la négation de A. [A:=!A]
Mémorise dans B la négation de B. [B:=!B]
Saute inconditionnellement à l’adresse donnée par l’opérande. [PC:=operande]
Saute à l’adresse donnée par l’opérande si le contenu du registre A est nul. [PC:=
Saute à l’adresse donnée par l’opérande si le contenu du registre B est nul. [PC :=
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Automate à états finis du séquenceur
0 × 10
0 × 11
ReadPC=1
UAL=0000
SetRADM=1
ReadMem=1
UAL=0001
SetA=1
0 × 20
0 × 21
ReadPC=1
UAL=0000
SetRADM=1
ReadMem=1
UAL=0001
SetB=1
0 × 1c
0 × 1d
0 × 1e
ReadPC=1
ReadMem=1 ReadA=1
UAL=0000
UAL=0001
UAL=0000
SetRADM=1 SetRADM=1 SetMem=1
0 × 00
0 × 08
ReadPC=1
CodeMCount=001
UAL=0000
@Adr=0x08
SetRADM=1
0 × 09
0 × 22
ReadPC=1
UAL=1000
SetPC=1
CodeMCount=001
@Adr=0x00
0 × 1f
ReadPC=1
UAL=1000
SetPC=1
CodeMCount=001
@Adr=0x00
0 × 30
ReadA=1
ReadB=1
UAL=0110
SetA=1
CodeMCount=001
@Adr=0x00
ReadMem=1
CodeMCount=010
ReadPC=1
SetPC=1
UAL=1000
0 × 14
0 × 15
0 × 16
ReadPC=1
ReadMem=1 ReadMem=1
UAL=0000
UAL=0001
UAL=0001
SetRADM=1 SetRADM=1 SetA=1
Architecture
0 × 12
ReadPC=1
UAL=1000
SetPC=1
CodeMCount=001
@Adr=0x00
0 × 17
ReadPC=1
UAL=1000
SetPC=1
CodeMCount=001
@Adr=0x00
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Séquenceur et programme
Séquenceur
• Sémantique des instructions
• Générique
• Automate à états finis : état dans MicroPC, signaux de
contrôle ROM[MicroPC]
Programme
• Qu’est ce que je veux calculer ?
• Spécifique
• Séquence de codes d’instructions et de données en RAM
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
La v0 est conçue, programmons la !
Conception
• Chemin de données
• Jeu d’instructions
• Séquenceur
Programmation
• Code machine
(instructions/données)
• Calcul des adresses “à la
main”
• adresses des
branchements?
• adresses des données ?
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
C’est dur et long pour le moment de programmer
Calculer la suite de Syracuse
∗
∀n ∈ N , un+1
(
un /2
=
3un+1 + 1
si un est pair
sinon
u0 = 127; un =?
⇔
Code machine
1000 007f 1c00 0024 1c00 1000 1400 0024 2000 0001 5000 7400
001b 1400 0024 2000 0003 4000 2000 0001 3000 1c00 0024 1c00
1000 7000 0006 1400 0024 4800 1c00 0024 1c00 1000 7000 0006
si si, je vous assure. Donc, c’est dur et long.
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
C’est dur et long pour le moment de programmer
Calculer la suite de Syracuse
∗
∀n ∈ N , un+1
(
un /2
=
3un+1 + 1
si un est pair
sinon
u0 = 127; un =?
⇔
Code machine
[LDAi 007f STA 0024 STA 1000] [LDAd 0024 LDBi 0001 ANDA
JZA 001b] [LDAd 0024 LDBi 0003 MULA LDBi 0001 ADDA STA
0024 STA 1000 JMP 0006] [LDAd 0024 DIVA STA 0024 STA
1000 JMP 0006]
si si, je vous assure. Donc, c’est dur et long.
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Comment faire pour simplifier la programmation ?
Ne plus écrire en code machine1
Code machine (arg..)
1000 0001
2000 0002
3000
???
←−−
Assemblage (cool!)
LDAi 1
LDBi 2
ADDA
???
←−−
Python (super cool!)
a=1
b=2
a=a+b
• Langage d’assemblage ? LDAi, STA, ADDA, ..
• Langages de haut-niveau (architecture indépendant) : C++,
Python, .. ?
et bien sûr comment faire la conversion vers le langage machine
1
Architecture
parfois utile tout de même
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Comment faire pour simplifier la programmation ?
Les procédures (ou fonctions)
Définition : succession d’opérations à exécuter pour accomplir une
tâche déterminée [Larousse]
Exemple de Syracuse en Python:
Sans procédures
un = 127
if(un % 2 ==
un = un/2
else:
un = 3 un
if(un % 2 ==
un = un/2
else:
un = 3 un
if(un % 2 ==
un = un/2
else:
Architecture
Avec procédures
0):
+ 1
0):
+ 1
0):
def f(u):
if(u % 2 == 0):
return u/2
else:
return 3 * u + 1
u = 127
u = f(u)
u = f(u)
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
On a presque des procédures
Syrarcuse
0x0000 1000 007E 7000 0014 7000 0014 7000 0014
···
0x000A
0x0014 2000 0001 5400 7800 001F 2000 0003 4400 2000 0001 3400
0x001F 4800 0000 0000 0000 0000
..
.
0x0000
0x000A
0x0014
0x001F
⇔
007E JMP 0014 JMP 0014 JMP 0014
···
LDBi 0001 ANDB JZB 001F LDBi 0003 MULB LDBi 0001 ADDB
DIVA 0000 0000 0000 0000
LDAi
}
}f
..
.
• programme de f : 0 × 0014
• on utilise ici explicitement le registre A pour stocker les
arguments et le résultat
• retour ?
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Nous avons donc trois problèmes à résoudre :
• comment passer les arguments à la routine ?
• Registres dédiés : combien ??
• comment revenir au programme appelant ?
• sauvegarder l’adresse de retour dans un registre dédié : link
register; que faire lors d’appels cascadés (A appelle B qui
appelle C qui appelle ...)
• comment récupérer le résultat ?
• un registre dédié ?
Ces trois questions trouvent leur réponse dans l’utilisation d’une
structure particulière : la pile
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Procédures, pile et pointeur de pile
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Spécifications d’une pile
Une pile en mémoire
• structure de données en mémoire principale (RAM)
• empiler, dépiler une valeur : sommet de pile
• ou est le sommet de pile : registre Stack Pointer
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Ajout de SP dans le chemin de données
00 00800008 00000000 00000000 00000000
04 00000000 00000000 00000000 00000000
08 00000c00 01401900 00000000 00000000
+1
0c 0080000c 00000000 00000000 00000000
MicroPC
···
···
···
···
D
···
00
@Adr
01
[8:15]
00
Mux
10
Adr 90
[0:7]
···
11
MuxSel
00c60000 00000000 00000000 00000000
···
···
B0 00020400 00002200
B4 00460400 00884100
B8 00000c00 00320500
BC 000000c0000320500
CodeMCount
32
···
···
00ce0000
00000000
00002200
00084100
00000000
00000000
00C01800
00c01800
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
CodeMCount
UAL
SetSP
ReadSP
SetB
ReadB
SetA
ReadA
SetPC
ReadPC
SetRADM
SetMem
ReadMem
@Adr
Bus B
Bus A
ReadMem
0x1000 0x0010 0x2000 0x0001
0x3000 0x1c00 0x000A 0x0000
Do
ReadA
RADM
Adr
0x0000 0x0000 0x0000 0x0000
ReadB
ReadPC
A
B
PC
SP
0x0000
0x0000
0x0000
0x0000
0x0000
SetRADM
SetA
SetB
SetPC
SetSP
ReadSP
A
UAL
Di
SetMem
B
Z
C
S
V
Bus S
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Ajout d’instructions de manipulation de la pile
Spécifications
• ou placer la pile en mémoire ?
• quelle est l’adresse du sommet de la pile en mémoire ?
• comment empiler/dépiler, écrire/lire des éléments de la pile ?
Instructions particulières
• pour manipuler le registre SP : LDSPi, STSP, INCSP, DECSP
• pour empiler/dépile : PUSH{A,B}, POP{A, B}
• pour lire/écrire relativement à SP : POKE{A,B}, PEEK{A,B}
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
PUSH, POP, POKE, PEEK, Hum?!
Exemple de POPA
Exemple de PUSHA
Après l'opération
0x0010
0x0000
0x0010
0x0000
0x0010
0x0000
0x0010
0x0000
0x0011
0x0000
0x0011
0x0000
0x0011
0x0000
0x0011
0x0000
0x0012
0x0000
0x0012
0x0000
0x0012
0x0000
0x0012
0x0013
0x0000
0x0013
0x0000
0x0013
0x0000
0x0014
0x0000
0x0014
0x0004
0x0014
0x0015
0x0003
0x0015
0x0003
0x0016
0x0002
0x0016
0x0017
0x0001
0x0017
Registre A
SP = 0x0014
Registre A
0x0004
SP = 0x0013
0x0000
0x0013
0x0000
0x0004
0x0014
0x0004
0x0015
0x0003
0x0015
0x0003
0x0002
0x0016
0x0002
0x0016
0x0002
0x0001
0x0017
0x0001
0x0017
0x0001
SP = 0x0013
Registre A
0x0004
Registre A
0x0000
Après l'opération
0x0004
Après l'opération
Avant l'opération
0x0000
0x0010
0x0000
0x0010
0x0000
0x0010
0x0000
0x0011
0x0000
0x0011
0x0000
0x0011
0x0000
0x0011
0x0000
0x0012
0x0000
0x0012
0x0000
0x0012
0x0000
0x0012
0x0013
0x0000
0x0013
0x0000
0x0013
0x0000
0x0014
0x0000
0x0014
0x0000
0x0014
0x0015
0x0003
0x0015
0x0003
0x0015
SP = 0x0014
Adresses
0x0010
SP = 0x0014
SP = 0x0013
0x0000
0x0013
0x0000
0x0004
0x0014
0x0004
0x0003
0x0015
0x0003
0x0016
0x0002
0x0016
0x0004
0x0016
0x0002
0x0016
0x0002
0x0017
0x0001
0x0017
0x0001
0x0017
0x0001
0x0017
0x0001
Registre A
0x0004
Registre A
0x0004
SP = 0x0014
Exemple de PEEKA 0x0002
Exemple de POKEA 0x0002
Avant l'opération
Adresses
Après l'opération
Avant l'opération
Adresses
Adresses
Avant l'opération
Registre A
0x0000
Registre A
SP = 0x0013
0x0003
→ Machines à états (b0, b4, b8, bc)?
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Utilisons la pile pour passer des arguments
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
Architecture
function somme(N)
Soient i, res deux variables locales
i ←N −1
res ← 0
while i 6= 0 do
res ← res + i
i ←i −1
return res
function main
somme(3)
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Somme: Une première tentative
main : // On initialise le registre SP
somme : // On réserve de la place pour
// les variables locales i et res
LDSPI 0x010F
DECSP
DECSP
// On effectue les calculs de la routine
// en utilisant PEEKA 0x0001 et PEEKA 0x0002
// pour accder aux variables locales
// en utilisant PEEKA 0x0003 pour l’argument
// On dépile les variables locales
// On empile l’argument
LDAi 0x0003
JMP
PUSHA
Appel de somme
// On dépile l’argument
POPA
????
INCSP
INCSP
// On retourne au programme principal
LDAi 0x0003
PUSHA
DECSP
DECSP
On empile l’argument
···
···
0 × 010B
0 × 0000
0 × 0000
0 × 010D
0 × 0000
0 × 0000
0 × 010C
0 × 010E
0 × 010F
Registre A
Registre SP
0 × 0000
0 × 0000
0 × 0000
···
0 × 0000
0 × 010F
···
0 × 0000
0 × 0000
SP
0 × 0000
0 × 0003
···
0 × 0003
0 × 010E
Programme main : Appelant
Architecture
On réserve de la place
pour les variables locales
0 × 0000
SP
0 × 0000
0 × 0000
0 × 0003
···
0 × 0003
0 × 010C
INCSP
INCSP
On supprime
les variables locales
POPA
On dépile l’argument
et le résultat
···
SP
var res
var i
···
0 × 0000
0 × 0000
0 × 0000
0 × 0006
0 × 0004
0 × 0003
···
0 × 0006
0 × 010E
Programme somme : Appelé
0 × 0000
SP
0 × 0006
0 × 0004
SP
0 × 0003
···
0 × 0006
0 × 010F
Programme main
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Appel et retour de routines
Spécifications
• Quand on part exécuter le code d’une procédure, il faut
sauvegarder là où retourner (marque page)
• Quand on termine une procédure, il faut poursuivre le
programme appelant
Instructions particulières
• CALL (0xA000): “CALL op” Empile l’adresse de la prochaine
instruction et branche
• RET (0xA800): “RET” Dépile dans PC l’adresse de retour
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Réalisation de ces instructions
main : // On initialise le registre SP
LDSPI 0x010F
// On empile l’argument
LDAi 0x0003
PUSHA
CALL somme
// On dépile l’argument
POPA
somme : // On réserve de la place pour
// les variables locales i et res
DECSP
DECSP
// On effectue les calculs de la routine
// en utilisant PEEKA 0x0001 et PEEKA 0x0002
// pour accder aux variables locales
// en utilisant PEEKA 0x0003 pour l’argument
// On dépile les variables locales
INCSP
INCSP
// On retourne au programme principal
RET
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Réalisation de ces instructions
00 00800008 00000000 00000000 00000000
04 00000000 00000000 00000000 00000000
08 00000c00 01401900 00000000 00000000
+1
0c 0080000c 00000000 00000000 00000000
MicroPC
···
···
···
···
D
···
00
@Adr
01
[8:15]
00
Mux
10
Adr 90
[0:7]
···
11
MuxSel
00c60000 00000000 00000000 00000000
···
···
B0 00020400 00002200
B4 00460400 00884100
B8 00000c00 00320500
BC 000000c0000320500
CodeMCount
32
···
···
00ce0000
00000000
00002200
00084100
00000000
00000000
00C01800
00c01800
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
SetT
ReadT
CodeMCount
UAL
SetSP
ReadSP
SetB
ReadB
SetA
ReadA
SetPC
ReadPC
SetRADM
SetMem
ReadMem
@Adr
Bus B
Bus A
ReadMem
0x1000 0x0010 0x2000 0x0001
0x3000 0x1c00 0x000A 0x0000
Do
ReadT
RADM
Adr
0x0000
0x0000 0x0000 0x0000 0x0000
ReadA
ReadB
ReadPC
Temp
A
B
PC
SP
0x0000
0x0000
0x0000
0x0000
0x0000
ReadSP
A
SetMem
SetRADM
SetT
SetA
SetB
SetPC
B
Z
C
UAL
Di
S
V
SetSP
Bus S
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Réalisation de ces instructions
main : // On initialise le registre SP
LDSPI 0x010F
// On empile l’argument
LDAi 0x0003
PUSHA
CALL somme
// On dépile l’argument
POPA
somme : // On réserve de la place pour
// les variables locales i et res
DECSP
DECSP
// On effectue les calculs de la routine
// en utilisant PEEKA 0x0001 et PEEKA 0x0002
// pour accder aux variables locales
// en utilisant PEEKA 0x0003 pour l’argument
// On dépile les variables locales
INCSP
INCSP
// On retourne au programme principal
RET
et le résultat au fait? La pile !
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Somme : une deuxième tentative
main : // On initialise le registre SP
LDSPI 0x0020
// On réserve de la place pour le résultat
somme : // On réserve de la place pour
// les variables locales i et res
DECSP
DECSP
DECSP
// On effectue les calculs de la routine
// en utilisant PEEKA 0x0001 et PEEKA 0x0002
// pour accder aux variables locales
// en utilisant PEEKA 0x0003 pour l’argument
// On dépile les variables locales
// On empile l’argument
LDAi 0x0003
PUSHA
CALL somme
// On dépile l’argument
POPA
// On récupère le résultat
INCSP
INCSP
// On sauvegarde le résultat dans la pile
POKEA 0x0002
// On retourne au programme principal
RET INCSP
POKEA 0x0002
POPA
POPA
DECSP
On réserve de la place
pour le résultat
0 × 010B
0 × 010C
0 × 010D
0 × 010E
0 × 010F
Registre A
Registre SP
···
···
0 × 0000
0 × 0000
0 × 0000
···
0 × 0000
0 × 010F
0 × 0000
SP
0 × 0000
0 × 0000
···
0 × 0000
0 × 010E
Programme main
Architecture
···
0 × 0000
0 × 0000
0 × 0000
DECSP
DECSP
On réserve de la place
pour les variables locales
···
0 × 0000
0 × 0000
LDAi 0x0003
PUSHA
On empile l’argument
0 × 0000
SP
0 × 0000
0 × 0003
0 × 0000
···
0 × 0003
0 × 010D
0 × 0000
SP
0 × 0000
0 × 0000
0 × 0003
0 × 0000
···
0 × 0003
0 × 010B
SP
var res
var i
POPA
INCSP
On supprime
les variables locales
On sauvegarde le résultat
dans la pile
···
···
0 × 0000
0 × 0006
0 × 0004
0 × 0003
0 × 0000
···
0 × 0006
0 × 010D
Programme somme
···
0 × 0000
SP
0 × 0006
0 × 0004
0 × 0003
0 × 0006
···
0 × 0006
0 × 010D
On dépile l’argument
et le résultat
0 × 0000
SP
0 × 0006
0 × 0004
0 × 0003
SP
0 × 0006
···
0 × 0006
0 × 010F
Programme main
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Déroulement d’un appel de routine
Le programme appelant
• réserve de la place pour le résultat (DECSP)
• empile les arguments (PUSH)
• sauvegarde la valeur PC après lecture de l’adresse de la routine et
branche sur la routine (CALL)
Programme appelé
• lit les arguments dans la pile (PEEK),
• calcule son résultat éventuel et le sauvegarde dans la pile (POKE)
• retourne au programme appelant (RET) : le registre SP doit être
restauré!
Programme appelant
• dépile les arguments (INCSP ou POP)
• dépile le résultat (POP) et se poursuit
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Qui met/enlève quoi dans la pile ?
Qui met quoi dans la pile ?
Qui enlève quoi dans la pile ?
Adresses
Variables locales
Programme appelé
Adresse de retour (PC)
CALL
Arguments de la routine
Programme appelant
Place pour le résultat
Sauvegarde éventuelle des registres
Adresses
Programme appelé
RET
Programme appelant
Variables locales
Adresse de retour (PC)
Arguments de la routine
Place pour le résultat
Sauvegarde éventuelle des registres
Attention!
Dans cette version d’architecture, les accès PEEK, POKE sont
relatifs au sommet de pile !
Autre possibilité : registre Base Pointer (BP)
Pour restaurer le registre SP, on pourrait ajouter un registre Frame
Pointer (FP)
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
C’est parti pour le code machine de :
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
Architecture
function somme(N)
Soient i, res deux variables locales
i ←N −1
res ← 0
while i 6= 0 do
res ← res + i
i ←i −1
return res
function main
somme(3)
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Procédures
Les procédures permettent :
• de factoriser le code
• d’éviter des bugs puisqu’on ne réécrit pas plusieurs fois le
“même” code
• de rendre le code plus compact
mais avec un petit surcoût à l’exécution (parfois inévitable)
Pile
La pile permet :
• de passer des arguments à une procédure
• de récupérer le résultat d’une procédure
• de sauvegarder l’adresse de retour d’une procédure
• de sauvegarder des variables locales à la procédure
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Des fonctions récursives : Hanoı̈
Pilier 1
Pilier 2
Pilier 3
Pilier 1
Pilier 2
Pilier 3
?
Configuration initiale
Configuration cible
Problème
Caluler le nombre de déplacement minimum nécessaires :
(
1
si n = 1
h(n) =
2h(n − 1) + 1 sinon
h(4) =?
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Des fonctions récursives : Hanoı̈
0x0006 CALL 0x000D
0x0FF3
0x0FF4
0x0FF5
0x0FF6
0x0FF7
0x0FF8
0x0FF9
0x0FFA
0x0FFB
0x0FFC
0x0FFD
0x0FFE
0x0FFF
Adr. Mem.
0x0008
0x0004
0x0000
SP
Adr. de retour de h(4)
Argument de h(4)
Résultat de h(4)
0x0018
0x0003
0x0000
0x0008
0x0004
0x0000
0x0016 CALL 0x000D
0x0016 CALL 0x000D
0x0018
0x0002
0x0000
0x0018
0x0003
0x0000
0x0008
0x0004
0x0000
0x0018
0x0001
0x0000
0x0018
0x0002
0x0000
0x0018
0x0003
0x0000
0x0008
0x0004
0x0000
Adr. de retour de h(3)
Argument de h(3)
Résultat de h(3)
Adr. de retour de h(4)
Argument de h(4)
Résultat de h(4)
Adr. de retour de h(2)
Argument de h(2)
Résultat de h(2)
Adr. de retour de h(3)
Argument de h(3)
Résultat de h(3)
Adr. de retour de h(4)
Argument de h(4)
Résultat de h(4)
Adr. de retour de h(1)
Argument de h(1)
Résultat de h(1)
Adr. de retour de h(2)
Argument de h(2)
Résultat de h(2)
Adr. de retour de h(3)
Argument de h(3)
Résultat de h(3)
Adr. de retour de h(4)
Argument de h(4)
Résultat de h(4)
Pile
0x0027 RET
0x0018
0x0001
0x0001
0x0018
0x0002
0x0000
0x0018
0x0003
0x0000
0x0008
0x0004
0x0000
Architecture
0x0016 CALL 0x000D
Argument de h(1)
Résultat de h(1)
Adr. de retour de h(2)
Argument de h(2)
Résultat de h(2)
Adr. de retour de h(3)
Argument de h(3)
Résultat de h(3)
Adr. de retour de h(4)
Argument de h(4)
Résultat de h(4)
0x0022 RET
0x0022 RET
0x0022 RET
0x0018
0x0001
0x0001
0x0018
0x0002
0x0003
0x0018
0x0003
0x0000
0x0008
0x0004
0x0000
0x0018
0x0001
0x0001
0x0018
0x0002
0x0003
0x0018
0x0003
0x0007
0x0008
0x0004
0x0000
0x0018
0x0001
0x0001
0x0018
0x0002
0x0003
0x0018
0x0003
0x0007
0x0008
0x0004
0x000F
Argument de h(2)
Résultat de h(2)
Adr. de retour de h(3)
Argument de h(3)
Résultat de h(3)
Adr. de retour de h(4)
Argument de h(4)
Résultat de h(4)
Argument de h(3)
Résultat de h(3)
Adr. de retour de h(4)
Argument de h(4)
Résultat de h(4)
Argument de h(4)
Résultat de h(4)
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Au fait ..
Comment passer de la formalisation du problème à un algorithme
efficace permettant de le résoudre ??
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Au fait ..
Comment passer de la formalisation du problème à un algorithme
efficace permettant de le résoudre ??
Cours FISDA: Fondement de l’Informatique, Structures de
Données et Algorithmie
Cours Génie logiciel: Etude des méthodes et bonnes pratiques
pour le développement logiciel
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Simplifions la programmation de la machine
Souhaits
• un programme moins long, moins répétitif, mois sujet aux
bugs : procédures et pile
• mais on programme toujours en code machine ?!?!
8000 0FFF
1000 0001
2000 0002
..
.
Architecture
LDSPi 0x0FFF
LDAi 0x0001
LDBi 0x0002
..
.
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
La couche d’assemblage
Couche ISA
LDAd
LDAi
Couche logique
JMP
STA
Couche physique
- circuits électroniques
D
JZA
E
PUSH
Q
- circuits optiques
- autres technologies ?
UAL
SUBA
POP
ADDA
Couche physique
Vout
Couche logique
A
B
S
0
0
1
1
0
1
0
1
0
1
1
0
Couche ISA
Registres : A, B, PC
LDA : 0x1000
STA : 0x1c00
JMP : 0x7000
LDBi
Couche d’assemblage
main: LDAi 0x0003
STA 0x1000
JMP 0x0020
Langage de haut niveau
C
Python
x = 3
print(x)
for i in range(3):
x = x - 1
int x = 3;
printf(”%i”, x);
while(x != 0) {
x = x - 1;
}
Vin
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Langage d’assemblage et assembleur
Adresse mémoire
0x0000
0x0002
0x0003
0x0005
0x0006
0x0008
0x0009
...........
0x0020
0x0021
0x0022
0x0023
0x0024
0x0025
0x0026
...........
Programme assembleur
LDSPi 0x0030
DECSP
LDAi 0x0007
PUSHA
LDAi 0x0008
PUSHA
CALL sum
..........
sum: PEEKA 0x0003
PEEKB 0x0002
ADDA
POKEA 0x0004
RET
Programme machine
8000 30
9400
1000 7
b000
1000 8
b000
a000 20
.........
bc00 3
cc00 2
3000
b800 4
a800
Assembleur : programme traduisant langage d’assemblage → code
machine.
Abus : programme assembleur = programme en langage
d’assemblage
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Quelques éléments de syntaxe de notre assembleur
• On utilise les mnémoniques LDAi, LDBi, STA, CALL, ...
• les valeurs en hexadécimal sans préfixe 0x
• “;” commentaire
• étiquettes : pour les branchements, pour les variables; spécial
@stack@
• pseudo-instructions : e.g.
• DSW : allocation de variables globales; par convention en
début de programme!
Les variables et les étiquettes ne doivent pas être interprétables en
hexadécimal
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Disposition du programme et des données en mémoire
(chez nous)
0x0000
Programme
···
Pile
···
Variables globales
(DSW)
0x0FFF
Architecture
0x1000
Premier afficheur
0x1001
Deuxième afficheur
0x1002
Troisième afficheur
···
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Traduction de quelques structures de contrôle
while i 6= 0 do
res ← res + i
3:
i ←i −1
1:
2:
loop: LDAd
JZA
LDBd
ADDB
STB
LDBi
SUBA
STA
JMP
end: ...
Architecture
i
end
res
res
1
i
loop
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Traduction de quelques structures de contrôle
for ⇔ while
1: for i = 0; i < N; i = i + 1 do
2:
res ← res + i
1: i ← 0
2: while i 6= N do
3:
res ← res + i
4:
i ←i +1
⇔
for ⇔ while
1: for (init; condition ; incrément) do
2:
action
1: init
2: while condition do
3:
action
4:
incrément
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Traduction de quelques structures de contrôle
if x! = 0 then
x ←1
3: x ← x + 1
1:
2:
end:
Architecture
LDAd
JZA
LDAi
STA
LDBi
ADDA
STA
x
end
1
x
1
x
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Traduction de quelques structures de contrôle
if x == 10 then
x ←0
3: else
4:
x ←x +1
1:
2:
LDAd
LDBi
SUBB
JZB
else: LDBi
ADDA
STA
JMP
if:
LDAi
STA
end: ....
Architecture
x
A
if
1
x
end
0
x
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
L’assembleur : traduction en code machine
Exercice : Assembler le programme
1: u ← 127
2: while True do
3:
u ← next(u)
4:
print(u)
5: function next(u)
6:
if u pair then return u/2
7:
elsereturn 3u + 1
Compteur d’emplacement, table des symboles, variables globals; cf
syr.asm
Démo : python assemble.py
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Langage de haut niveau (Python, C, C++, Scala, ..)
++
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Mais pourquoi ?
Assembleur
• spécifique à une architecture
• encore dur à programmer (LDAd b; LDBd c; ADDA; STA a)
• peu de vérification syntaxique: on peut ajouter des choux et
des carottes
Langage de haut niveau
• indépendant de l’architecture
• langage plus intuitif, e.g. a = b + c, structures de contrôle,
définition de fonctions
• vérification syntaxique
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Langage : Interprété ou compilé
Langage compilé
Un programme (compilateur) convertit le code source en code
machine qui peut ensuite être exécuté
Ex : C++/g++
g++ -S main.cc
g++ -o main main.cc ; hexdump main
./main
Langage interprété
Un programme (interpréteur) interprète “à la volée” le code source
Ex : Python/ python
python main.py
⇒ Machine virtuelle python
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Brève Anatomie d’un compilateur
C/C++
int main() {
int x = 3;
int y = 3 + x;
}
return x;
Code machine
1000 0003
Analyse
(frontend)
Langage intermédiare (CFG)
Synthèse
(backend)
1c00 00FF
1000 0003
2400 00FF
3000
1c00 0100
Référence : “The dragon book” Aho, Lam, Sethi, Ullman
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
La phase d’analyse (frontend)
Analyse lexicale
Ségmentation et identification des lexèmes
i
n
t
x
=
y + 3
;
(”int”, type)
(”x”, identifiant)
(”=”, opérateur binaire)
(”y”, identifiant)
(”+”, opérateur binaire)
···
Analyse syntaxique
Construction d’un arbre syntaxique à partir des lexèmes et d’une
grammaire du langage.
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
La phase d’analyse (frontend)
racine
opérateur =
x = 3;
while(x > 0) {
x = x - 1;
}
Analyse lexicale
(”x”, identifiant)
(”3”, constante)
(”while”, mot clef)
(”(”, parenthese)
(”x”, identifiant)
···
while
condition
Analyse syntaxique
variable x
constante 3
opérateur >
variable x
constante 0
corps
opérateur =
variable x
opérateur −
variable x
Architecture
constante 1
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Génération et optimisation d’une représentation
intermédiaire
Représentation intermédiaire
• indépendante du langage source (C, C++, ..) et de
l’architecture (x86, ARM, CentraleSupelec)
• facile à produire, facile à convertir en code machine
• optimisable
Ex : register transfer language, gimple, generic, three adress code,
single static assignment, control flow graph, ...
Référence : “The dragon book” Aho, Lam, Sethi, Ullman
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Exemple de représentation intermédiaire : Three Adress
code
Eléments de syntaxe
• opérations binaires : x := y op z
• opérations unaires : x:= op y
• copies : x := y
• sauts (in)conditionnels : goto L; If x relop y goto L
• procédures : param x1,.. call p, return y
• ...
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Exemple de représentation intermédiaire : Three Adress
code
int x = 3;
int y = 2 + 7 + x ;
i n t z = 2∗ y ;
if (x < y) {
z = x /2 + y / 3 ;
}
else {
z = x ∗ y + y;
}
Architecture
x = 3;
_t1 = 2 + 7;
y = _t1 + x;
z = 2 * y;
_t2 = x < y;
IfZ _t2 Goto _L0;
_t3 = x / 2;
_t4 = y / 3;
z = _t3 + _t4
Goto _L1
_L0: _t5 = x * y;
z = _t5 + z;
_L1:
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Exemple de représentation intermédiaire : Control Flow
Graph (CFG)
Début
x=3
y=x+7
z=2*y
if(x < y)
Faux
Vrai
t1 = x/2
t2 = y/3
z = t1 + t2
t3 = x*y
z = t3 + y
Fin
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Optimisation d’un CFG
Application répétée de quelques règles de simplification
• supprimer des affectations inutiles
• remplacer des constantes : int x = 3; int y = x + 2 ⇒ int x
= 3 ; int y = 3 + 2;
• calculer des expressions constantes : int y = 3 + 2; ⇒ int y =
5
jusqu’à ce que plus aucune des règles ne soit applicable
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Optimisation d’un CFG
Début
Début
Constante à remplacer
x=3
y=x+7
z=2*y
if(x < y)
x=3
y=3+7
Affectation inutile
if(3 < y)
Faux
Vrai
t1 = x/2
t2 = y/3
z = t1 + t2
t3 = x*y
z = t3 + y
t1 = 3/2
t2 = y/3
z = t1 + t2
Fin
Début
Début
Affectation inutile
y = 10
Expression évaluable
if(3 < y)
if(3 < y)
Faux
Faux
Vrai
t3 = 3*y
z = t3 + y
t1 = 3/2
t2 = y/3
z = t1 + t2
t3 = 3*y
z = t3 + y
Fin
x=3
y=3+7
Vrai
Faux
Vrai
t3 = 3*y
z = t3 + y
t1 = 3/2
t2 = y/3
z = t1 + t2
Fin
Fin
···
Début
Après plusieurs passes
z=4
Fin
Architecture
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
La phase de synthèse (backend)
Représentation intermédiaire ⇒ Code machine
• génération du code machine de chacun des blocs
• disposition en mémoire des blocs
• optimisations éventuelles
res = 1
n=4
bloc 0
res = res * n
n=n-1
if(n == 0)
faux
bloc 1
vrai
print res
bloc 2
BL0: LDAi 1
STA @res
LDBi 4
STB @n
JMP BL1
BL1: LDBd @res
LDAd @n
MULB
STB @res
LDBi 1
SUBA
STA @n
JZA BL2
JMP BL1
BL2: LDAd @res
STA 1000
Architecture
BL0: LDAi 1
STA @res
LDBi 4
STB @n
JMP BL1
BL1: LDBd @res
LDAd @n
MULB
STB @res
LDBi 1
SUBA
STA @n
JZA BL2
JMP BL1
BL2: LDAd @res
STA 1000
Code machine
Jérémy Fix
Petite synthèse
Procédure, pile et pointeur de pile
La couche d’assemblage
Langages de haut niveau
Et voila
C/C++
int main() {
int x = 3;
int y = 3 + x;
}
return x;
Code machine
1000 0003
Analyse
(frontend)
Langage intermédiare (CFG)
Synthèse
(backend)
1c00 00FF
1000 0003
2400 00FF
3000
1c00 0100
Référence : “The dragon book” Aho, Lam, Sethi, Ullman
Architecture
Jérémy Fix
Téléchargement