|
@@ -0,0 +1,213 @@
|
|
1
|
+# Architecture des processeurs, Langages d'assemblage et assembleur en ligne
|
|
2
|
+
|
|
3
|
+Benoit Morgan - Intel corp
|
|
4
|
+
|
|
5
|
+# Introduction
|
|
6
|
+
|
|
7
|
+L'assembleur est le langage qui permet de générer un langage machine / programme correct. Le langage est très proche du jeu d'instruction et de l'achitecture du processeur, mais suffisamment abstrait pour être lu et écrit par un humain. On associe une famille de processeur à un langage assemblage donnée
|
|
8
|
+
|
|
9
|
+# Architecture matérielles des processeurs
|
|
10
|
+
|
|
11
|
+## Processeur
|
|
12
|
+
|
|
13
|
+Il s'agit du composant essentiel d'une machine, il est capable d'exécuter des instructions machine d'un programme, il a accès à la mémoire, et aux périphériques. On l'associe en général à l'intelligence de la machine
|
|
14
|
+
|
|
15
|
+microprocesseur = processeur + mémoire + entrées / sorties + etc
|
|
16
|
+
|
|
17
|
+# Micro Processeur
|
|
18
|
+
|
|
19
|
+## Mémoire
|
|
20
|
+
|
|
21
|
+Plusieurs types de mémoires
|
|
22
|
+
|
|
23
|
+### Mémoire court termes - Registres
|
|
24
|
+
|
|
25
|
+Utilisés directement par les unités arithmétiques et logiques comme paramètre et stockage des opérations arithmétiques
|
|
26
|
+
|
|
27
|
+### Mémoire long terme - la RAM
|
|
28
|
+
|
|
29
|
+Utilisée pour le stockage des instruction ou les données d'un programme (variables temporaires, locales, globales...)
|
|
30
|
+
|
|
31
|
+### Périphériques
|
|
32
|
+
|
|
33
|
+Permettent l'acheminement du flot de données
|
|
34
|
+
|
|
35
|
+# Instructions machines
|
|
36
|
+
|
|
37
|
+Il s'agit des opérations élémentaires exécutées par un processeur. On en distingue plusieurs types :
|
|
38
|
+
|
|
39
|
+- UAL
|
|
40
|
+- Accès mémoire
|
|
41
|
+- I/O en lecture ou écriture
|
|
42
|
+- Gestion du flot d'exécution - Sauts, fonctions, interruptions
|
|
43
|
+- Système : configuration, noyau, VM, énergie...
|
|
44
|
+
|
|
45
|
+# Opérateurs binaires
|
|
46
|
+
|
|
47
|
+## Logique
|
|
48
|
+
|
|
49
|
+- & ET
|
|
50
|
+- | OU
|
|
51
|
+- $\oplus$ XOR
|
|
52
|
+
|
|
53
|
+## Arithmétiques
|
|
54
|
+
|
|
55
|
+- Addition +
|
|
56
|
+- Soustraction -
|
|
57
|
+- Multiplication x
|
|
58
|
+
|
|
59
|
+## Binaires
|
|
60
|
+
|
|
61
|
+# Architecture générique typique et simplifiée
|
|
62
|
+
|
|
63
|
+- Périph entrée et sortie
|
|
64
|
+- CPU
|
|
65
|
+- Mémoire
|
|
66
|
+- Jeu d'instructions
|
|
67
|
+ - Lire une entrée utilisateur
|
|
68
|
+ - Ecrire une entrée utilisateur
|
|
69
|
+ - Addition
|
|
70
|
+ - Soustraction
|
|
71
|
+ - Lecture mémoire
|
|
72
|
+ - Ecriture mémoire
|
|
73
|
+
|
|
74
|
+## Calcul arithmétique avec une UAL
|
|
75
|
+
|
|
76
|
+- Généralement deux entrées dans un CPU
|
|
77
|
+- Généralement une sortie
|
|
78
|
+- Processeur xbits <=> UAL x-bits
|
|
79
|
+
|
|
80
|
+Décomposition en suite d'instructions arithmétiques :
|
|
81
|
+
|
|
82
|
+sortie((entrée() +entrée()) * (entrée()+entrée()))
|
|
83
|
+
|
|
84
|
+<p align="center">
|
|
85
|
+ <img src="./Images/operation_to_instructions.png">
|
|
86
|
+</p>
|
|
87
|
+
|
|
88
|
+<p align="center">
|
|
89
|
+ <img src="./Images/o_t_i_inpc.png">
|
|
90
|
+</p>
|
|
91
|
+
|
|
92
|
+# Drapeaux et comparaisons
|
|
93
|
+
|
|
94
|
+## Drapeaux arithmétiques
|
|
95
|
+- Z : résultat nul
|
|
96
|
+- C (carry) - retenue
|
|
97
|
+- O (Overflow) l'espace des nombres signés a été dépassé
|
|
98
|
+- P : parité
|
|
99
|
+- S : Signé
|
|
100
|
+
|
|
101
|
+Encodage des nombres signés en mémoire
|
|
102
|
+
|
|
103
|
+$n = -b_{n-1} \times 2^{n-1} + \sum_{i=0}^{n-2}{b_i\times2^i}$
|
|
104
|
+
|
|
105
|
+# Instructions de contrôle du flot d'exécution
|
|
106
|
+
|
|
107
|
+Permet la mise en oeuvre de tests et de bouvles quand utilisées en complément avec l'UAL.
|
|
108
|
+
|
|
109
|
+```C
|
|
110
|
+if (expr.){statement} else {statement}
|
|
111
|
+while (expr.) {statements}
|
|
112
|
+for (statements;expr;statements){statements}
|
|
113
|
+```
|
|
114
|
+# Exemple de tests - if et boucles - for
|
|
115
|
+
|
|
116
|
+```C
|
|
117
|
+if (6==entrée()){
|
|
118
|
+ sortie(0);
|
|
119
|
+}
|
|
120
|
+else{
|
|
121
|
+ sortie(1);
|
|
122
|
+}
|
|
123
|
+```
|
|
124
|
+```x86asm
|
|
125
|
+Programme Commentaires
|
|
126
|
+A = 6 if (6 - entrée() == 0)
|
|
127
|
+B = entrée
|
|
128
|
+A = A - B ou A CMP B
|
|
129
|
+cpt. ordinal = 6 ssi Z = 0
|
|
130
|
+sortie = 0 sortie(0)
|
|
131
|
+cpt. ordinal = 7 else
|
|
132
|
+sortie = 1 sortie(1)
|
|
133
|
+[..]
|
|
134
|
+```
|
|
135
|
+
|
|
136
|
+```C
|
|
137
|
+for (int i = 0; i < 10; i++) {
|
|
138
|
+sortie(i);
|
|
139
|
+}
|
|
140
|
+```
|
|
141
|
+
|
|
142
|
+Peut être traduit en suite d’instructions génériques suivantes :
|
|
143
|
+```x86asm
|
|
144
|
+Programme Commentaires
|
|
145
|
+A = 0 int i = 0
|
|
146
|
+B = 10
|
|
147
|
+A CMP B i < 10 ?
|
|
148
|
+cpt. ordinal = 7 ssi Z = 1 {
|
|
149
|
+sortie = A sortie(i)
|
|
150
|
+A = A + 1 i++
|
|
151
|
+cpt. ordinal = 2 }
|
|
152
|
+[..]
|
|
153
|
+```
|
|
154
|
+
|
|
155
|
+# Support des procédures
|
|
156
|
+
|
|
157
|
+Une bonne façon de faire des appels de fonction supportant les appels de fonctions consécutifs et les appels imbriqués de fonction et de procéder de la façon suivante :
|
|
158
|
+
|
|
159
|
+Un appel récursif avec pile et accès mémoire indirect :
|
|
160
|
+
|
|
161
|
+```x86asm
|
|
162
|
+Programme Commentaires
|
|
163
|
+P = 41 Initialisation pile
|
|
164
|
+A = 0 main() {}
|
|
165
|
+appel 10 f() et C = 2
|
|
166
|
+appel 10 f() et C = 3
|
|
167
|
+[..]
|
|
168
|
+P = P - 1 f() {} sauvegarde du contexte
|
|
169
|
+MEM[P] = C
|
|
170
|
+A = A + 1
|
|
171
|
+appel 20 f2() et C = 14
|
|
172
|
+C = MEM[P] restauration du contexte
|
|
173
|
+P = P + 1
|
|
174
|
+cpt. ordinal = C cpt. ordinal = @retour
|
|
175
|
+[..]
|
|
176
|
+A = A + 2 f2() {}
|
|
177
|
+cpt. ordinal = C cpt. ordinal = @retour
|
|
178
|
+```
|
|
179
|
+
|
|
180
|
+**Attention, il n'est pas toujours nécessaire de passer par la pile**. Par défaut ce sera cette structure qui sera utilisée dans une architecture x86, mais en soi, pour un simple appel de fonction non récursive, il suffirait de garder uniquement le registre C qui contient l'adresse de la ligne suivante de code à éxecuter.
|
|
181
|
+
|
|
182
|
+# Structure des instructions
|
|
183
|
+## Champ usuels
|
|
184
|
+
|
|
185
|
+| Code opération | Opérandes |
|
|
186
|
+- Code d'opération $\simeq$ Opération à exécuter, peut donc spécifier la taille des opérandes :
|
|
187
|
+ - addition, appel, cpt.ord = etc...
|
|
188
|
+
|
|
189
|
+- Opérandes $\simeq$ les paramètres de l'instruction :
|
|
190
|
+ - adresse absolue, registre, etc...
|
|
191
|
+
|
|
192
|
+## Taille d’une instruction
|
|
193
|
+- Jeu d’instruction à taille fixe
|
|
194
|
+ - Exemple : ARM, MIPS
|
|
195
|
+- Jeu d’instruction à taille variable
|
|
196
|
+ - Exemple : Intel x86
|
|
197
|
+
|
|
198
|
+## Sémantique et structure d'une opérande
|
|
199
|
+
|
|
200
|
+- Généralement interprétés en fonction du code opération
|
|
201
|
+- Id du registre
|
|
202
|
+ - Ex : 0 = A, 1=B
|
|
203
|
+- Valeur imméditate
|
|
204
|
+ - Ex : A=4
|
|
205
|
+- Adresse
|
|
206
|
+ -Ex : appel 20
|
|
207
|
+
|
|
208
|
+Classification des processeurs
|
|
209
|
+- _Reduced Instruction Set Computer_ (RISC) : ARM Thumb, MIPS
|
|
210
|
+Peu d’instructions, faible emprunte silicium.
|
|
211
|
+- _Complex Instruction Set Computer_ (CISC) : Intel X86, ARMv8
|
|
212
|
+Instructions complexes simplifiantes. Énorme emprunte silicium.
|
|
213
|
+
|