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 de 8 bits découpée en trois champs : opcode 0100 (4 bits), Rd 00 (2 bits) et Rs 01 (2 bits), qui se décode en "ADD r0, r1 : r0 reçoit r0 + r1"

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

0000

STOP

arrête le processeur

0001

LOAD Rd, valeur

Rd reçoit la valeur (sur 2 octets, voir plus bas)

0010

OUT Rd

affiche le contenu de Rd

0100

ADD Rd, Rs

Rd reçoit Rd + Rs

0101

SUB Rd, Rs

Rd reçoit Rd - Rs

0110

AND Rd, Rs

Rd reçoit Rd ET Rs

0111

OR Rd, Rs

Rd reçoit Rd OU Rs

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 2 bits : 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, r1 fait donc r0 ← 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

0

0001 00 00

LOAD r0, …

1

0000 1101

(valeur : 13)

2

0001 01 00

LOAD r1, …

3

0000 0010

(valeur : 2)

4

0100 00 01

ADD r0, r1

5

0010 00 00

OUT r0

6

0000 0000

STOP

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.

  • LOAD occupe 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.

  1. 0100 01 11 : avec Rd = et Rs =

  2. 0101 00 10 : avec Rd = et Rs =

  3. 0010 11 00 : sur le registre

  4. 0001 10 00 : sur le registre

Exercice 42#

On exécute ce programme. Au départ, tous les registres valent 0.

adresse

instruction

0

LOAD r0, 5

2

LOAD r1, 3

4

LOAD r2, 0

6

ADD r2, r0

7

ADD r0, r1

8

OUT r0

9

STOP

Donnez le contenu des registres demandés à la fin, ainsi que la valeur affichée.

  1. r0 après ADD r0, r1 :

  2. r2 à la fin :

  3. r1 à la fin :

  4. valeur affichée par OUT r0 :

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.

Exercice 44#

La mémoire contient le programme ci-dessous, case après case. Au départ, tous les registres valent 0.

  • 00010000

  • 00001100

  • 00010100

  • 00000101

  • 01010001

  • 01000101

  • 01000100

  • 00100000

  • 00100100

  • 00000000

  1. Traduisez le programme en instructions (par exemple LOAD r0, …), puis en pseudocode (par exemple r0 = r0 + r1).

  2. Quelles valeurs le programme affiche-t-il, dans l'ordre ?

  1. première valeur affichée (en décimal) :

  2. deuxième valeur affichée (en décimal) :