Le jeu d'instructions#
Nous avons toutes les pièces d'un processeur : des registres pour retenir, une mémoire pour ranger, une ALU pour calculer, des multiplexeurs pour aiguiller les données. Il nous manque une question : qu'est-ce qu'un programme, vu par le processeur ? La réponse tient en une phrase : une suite de nombres rangés dans la mémoire.
Notre processeur travaillera avec quatre registres de travail, r0, r1,
r2 et r3 : ce sont ses cases de calcul, ultra-rapides, sur lesquelles portent
la plupart des instructions.
Une instruction, c'est un nombre#
Un processeur ne comprend ni le français ni Python : il ne sait manipuler que des
nombres. Un programme, pour lui, est une suite de nombres rangés dans des
cases consécutives de la mémoire. Chacun est une instruction : un ordre
élémentaire, du genre "mets la valeur 13 dans r0" ou "ajoute r1 à r0".
Pour être lisible, une instruction est découpée en champs. Le premier, le code
opération (ou opcode), dit quoi faire. Les suivants désignent sur quels
registres agir. Comme il y a quatre registres, il faut 2 bits pour en nommer
un (00 = r0, 01 = r1, 10 = r2, 11 = r3). Sur nos 8 bits, on réserve
donc les 4 bits de gauche à l'opcode, puis 2 bits pour le registre de destination
Rd, et 2 bits pour le second registre Rs.
Une instruction se lit en trois morceaux : l'opcode (l'action), puis les deux registres concernés.#
Par convention, le premier registre est toujours la destination : c'est lui
qui reçoit le résultat. Ainsi ADD r0, r1 signifie "r0 reçoit r0 + r1". C'est
la même règle que dans les vrais assembleurs (x86, ARM).
Un petit jeu d'instructions#
La liste des instructions qu'un processeur sait exécuter s'appelle son jeu d'instructions. Voici le nôtre :
opcode |
instruction |
effet |
|---|---|---|
|
|
arrête le processeur |
|
|
|
|
|
affiche le contenu de |
|
|
|
|
|
|
|
|
|
|
|
|
On retrouve nos composants : ADD, SUB, AND et OR font travailler l'ALU
sur deux registres, LOAD fait entrer une valeur depuis la mémoire, et OUT
montre un résultat. L'opcode 0011 n'est pas utilisé.
Les opcodes ne sont pas choisis au hasard. Les quatre instructions de calcul
commencent toutes par 01, et leurs deux bits de droite sont exactement le
code opération de l'ALU : 00 = addition, 01 = soustraction, 10 = ET,
11 = OU. Le processeur n'aura donc rien à calculer pour régler l'ALU : il lui
suffira de brancher ces deux bits de l'instruction sur l'entrée op.
Important
Un registre se nomme sur
2bits :r0 = 00,r1 = 01,r2 = 10,r3 = 11.Le premier registre d'une instruction est la destination (il reçoit le résultat).
ADD r0, r1fait doncr0 ← r0 + r1.
Une subtilité pour LOAD : la valeur à charger (par exemple 13) ne tient pas
dans les 4 bits qui restent. On l'écrit donc dans l'octet suivant : LOAD
occupe deux octets, l'instruction proprement dite, puis la valeur. C'est ainsi
que fonctionnent les vrais processeurs : certaines instructions sont plus longues
que d'autres.
Un programme complet#
Voici un programme rangé en mémoire à partir de l'adresse 0 : c'est exactement
le contenu que vous avez rangé dans votre RAM au TP mémoire. Il met 13 dans
r0, 2 dans r1, les additionne dans r0, puis affiche le résultat.
adresse |
contenu binaire |
instruction |
|---|---|---|
|
|
|
|
|
(valeur : |
|
|
|
|
|
(valeur : |
|
|
|
|
|
|
|
|
|
Instruction après instruction, r0 prend la valeur 13, r1 prend 2, puis
ADD r0, r1 met 13 + 2 = 15 dans r0, qui est affiché avant l'arrêt.
Important
Un programme est une suite de nombres en mémoire ; chacun est une instruction faite d'un opcode et de registres.
LOADoccupe deux octets : l'instruction, puis la valeur à charger.
Exercices#
Exercice 41#
Décodez chaque instruction : donnez son nom (menu déroulant) et le numéro des
registres visés (en décimal, de 0 à 3). Servez-vous du tableau du jeu
d'instructions.
0100 01 11: avec Rd = et Rs =0101 00 10: avec Rd = et Rs =0010 11 00: sur le registre0001 10 00: sur le registre
Exercice 42#
On exécute ce programme. Au départ, tous les registres valent 0.
adresse |
instruction |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Donnez le contenu des registres demandés à la fin, ainsi que la valeur affichée.
r0aprèsADD r0, r1:r2à la fin :r1à la fin :valeur affichée par
OUT r0:
Solution
LOAD r0, 5:r0 = 5.LOAD r1, 3:r1 = 3.LOAD r2, 0:r2 = 0.ADD r2, r0:r2reçoit0 + 5 = 5: c'est une copie der0(etr0ne change pas).ADD r0, r1:r0reçoit5 + 3 = 8.OUT r0affiche donc8. À la fin :r0 = 8,r1 = 3,r2 = 5.
Exercice 43#
Écrivez, avec le jeu d'instructions du cours, un programme qui met 10 dans r0
et 4 dans r1, garde une copie de r0 dans r2, calcule r0 - r1 dans
r0, puis affiche d'abord r0 et ensuite r2.
Solution
LOAD r0, 10 r0 = 10
LOAD r1, 4 r1 = 4
LOAD r2, 0 r2 = 0
ADD r2, r0 r2 = 0 + 10 = 10 (copie de r0)
SUB r0, r1 r0 = 10 - 4 = 6
OUT r0 affiche 6
OUT r2 affiche 10
STOP
La copie dans r2 est indispensable : SUB r0, r1 écrase r0, donc sans la
copie préalable on perdrait la valeur 10.
Exercice 44#
La mémoire contient le programme ci-dessous, case après case. Au départ, tous les
registres valent 0.
00010000000011000001010000000101010100010100010101000100001000000010010000000000
Traduisez le programme en instructions (par exemple
LOAD r0, …), puis en pseudocode (par exempler0 = r0 + r1).Quelles valeurs le programme affiche-t-il, dans l'ordre ?
première valeur affichée (en décimal) :
deuxième valeur affichée (en décimal) :
Solution
binaire instruction pseudocode
00010000 00001100 LOAD r0, 12 r0 = 12
00010100 00000101 LOAD r1, 5 r1 = 5
01010001 SUB r0, r1 r0 = r0 - r1
01000101 ADD r1, r1 r1 = r1 + r1
01000100 ADD r1, r0 r1 = r1 + r0
00100000 OUT r0 afficher r0
00100100 OUT r1 afficher r1
00000000 STOP arrêter
Attention : LOAD occupe deux cases. 00001100 et 00000101 ne sont pas des
instructions, mais les valeurs 12 et 5.
Déroulement : r0 = 12, r1 = 5, puis r0 = 12 - 5 = 7, r1 = 5 + 5 = 10,
r1 = 10 + 7 = 17. Le programme affiche donc 7, puis 17.