Le jeu d'instructions

Trois formes d'écriture, et presque rien d'autre

Une instruction RISC-V s'écrit toujours de la même façon : un nom, puis des opérandes séparés par des virgules. Ce qui change d'une famille à l'autre, c'est la nature de ces opérandes, et il n'y a que trois combinaisons à retenir.

Dans les deux premières formes, le premier nom est la destination, et c'est le seul registre que l'instruction modifie. La constante de la deuxième forme porte un nom, immédiat, parce qu'elle est écrite dans l'instruction elle-même au lieu d'être cherchée ailleurs. Le i final de addi, andi, slli ne veut rien dire d'autre que cela.

La troisième forme est la seule qui parle à la mémoire, et sa notation mérite d'être lue lentement. 0(t2) ne désigne ni le registre t2, ni le nombre zéro : il désigne la case dont l'adresse est le contenu de t2 augmenté de zéro. Le nombre devant la parenthèse est un décalage, ajouté à l'adresse au moment de l'accès.

programme

1. 0x0add t0, a0, a1
2. 0x4addi t1, a0, 100
3. 0x8la t2, mesurelui t2, 1
4. 0xcaddi zero, zero, 0
5. 0x10lw t3, 0(t2)
6. 0x14sw t0, 0(t2)

registres

sp	0x2000
t0	0
t1	0
t2	0
a0	12
a1	5
t3	0

mémoire

0x1000

mesure

40

Reculer Exécuter une instruction Aller à la fin Reprendre Modifier le programme

Rien n'a encore été exécuté. Le compteur ordinal pointe la première instruction, en 0x0.

Une quatrième forme existe, plus courte, et le mémento la donne plus bas : les branchements, comme beq a0, a1, fin, nomment deux registres à comparer et une étiquette où aller. Ils ne rangent rien nulle part, et n'ont donc pas de destination. C'est la seule exception à la règle du premier nom.

L'immédiat, et sa limite de douze bits

Une instruction occupe trente-deux bits, et pas un de plus. Ces trente-deux bits doivent loger l'opération à faire, le registre destination, le registre source, et la constante. Le compte est vite fait : il reste douze bits pour la constante, ce qui donne les valeurs de -2048 à 2047.

programme

1. 0x0addi t0, zero, 2047
2. 0x4addi t1, zero, -2048
3. 0x8li t2, 100000lui t2, 24
4. 0xcaddi t2, t2, 1696
5. 0x10li t3, 2048lui t3, 1
6. 0x14addi t3, t3, -2048

registres

t0	0
t1	0
t2	0
t3	0

Reculer Exécuter une instruction Aller à la fin Reprendre Modifier le programme

Rien n'a encore été exécuté. Le compteur ordinal pointe la première instruction, en 0x0.

Au-delà de cette limite, il n'y a pas d'instruction unique possible, et l'assembleur en fabrique deux. lui pose les vingt bits de poids fort de la valeur, puis addi ajoute les douze bits du bas. Le détour se voit dans la figure : t3 vaut 4096 avant de valoir 2048, ce qui est un chemin curieux pour atteindre un nombre aussi petit, et dit bien que 2048 est de l'autre côté de la frontière.

Les pseudo-instructions, et la colonne qui les démasque

Une pseudo-instruction est un nom que l'assembleur accepte à l'écriture et remplace par une ou deux instructions réelles avant de produire le programme. Elle n'existe pas dans le matériel. Les figures de ce module affichent toujours, à droite de la ligne écrite, l'instruction réellement exécutée, ce qui rend le remplacement visible au lieu d'avoir à le croire.

programme

1. 0x0mv t0, t1addi t0, t1, 0
2. 0x4neg t2, t1sub t2, zero, t1
3. 0x8not t3, t1xori t3, t1, -1
4. 0xcseqz t4, t1sltiu t4, t1, 1
5. 0x10snez t5, t1sltu t5, zero, t1
6. 0x14nopaddi zero, zero, 0

registres

t0	0
t1	7
t2	0
t3	0
t4	0
t5	0

Reculer Exécuter une instruction Aller à la fin Reprendre Modifier le programme

Rien n'a encore été exécuté. Le compteur ordinal pointe la première instruction, en 0x0.

Ce remplacement n'est pas une facilité gratuite. Il économise des instructions réelles, donc du silicium : copier un registre, poser une constante ou tester la nullité d'une valeur ne demandent aucune instruction dédiée dès lors que zero existe. Le jeu reste petit, et l'écriture reste lisible.

Voici la table complète des développements, telle que le moteur des figures les produit.

nop        -> addi zero, zero, 0
mv   t0,t1 -> addi t0, t1, 0
not  t0,t1 -> xori t0, t1, -1
neg  t0,t1 -> sub t0, zero, t1
seqz t0,t1 -> sltiu t0, t1, 1
snez t0,t1 -> sltu t0, zero, t1
sltz t0,t1 -> slt t0, t1, zero
sgtz t0,t1 -> slt t0, zero, t1
beqz t0,L  -> beq t0, zero, L
bnez t0,L  -> bne t0, zero, L
blez t0,L  -> bge zero, t0, L
bgez t0,L  -> bge t0, zero, L
bltz t0,L  -> blt t0, zero, L
bgtz t0,L  -> blt zero, t0, L
bgt  a,b,L -> blt b, a, L
ble  a,b,L -> bge b, a, L
bgtu a,b,L -> bltu b, a, L
bleu a,b,L -> bgeu b, a, L
j    L     -> jal zero, L
jr   t0    -> jalr zero, t0, 0
ret        -> jalr zero, ra, 0
call L     -> jal ra, L
li t0, 5   -> addi t0, zero, 5
li t0, 100000 -> lui t0, 24  puis  addi t0, t0, 1696

Deux lignes de cette table méritent un commentaire. Les quatre branchements bgt, ble, bgtu et bleu se contentent d'échanger leurs deux registres : le matériel ne sait tester que « plus petit » et « plus grand ou égal », et « plus grand que » s'obtient en posant la question à l'envers. Quant à li et à son voisin la, qui charge l'adresse d'une donnée, ils occupent deux instructions, la place étant réservée d'avance : la t2, mesure produit lui t2, 1 suivi d'un addi zero, zero, 0 qui ne sert qu'à occuper la place. Ce nop apparaît dans les figures, et n'est pas une erreur.

Calculer

La première famille fait l'arithmétique et la logique. Chaque opération existe en deux versions : une entre deux registres, une entre un registre et un immédiat, reconnaissable à son i final.

programme

1. 0x0add t0, a0, a1
2. 0x4sub t1, a1, a0
3. 0x8and t2, a0, a1
4. 0xcor t3, a0, a1
5. 0x10xor t4, a0, a1
6. 0x14sll t5, a0, a1
7. 0x18srl t6, t5, a1
8. 0x1csra s0, t1, a1
9. 0x20addi s1, a0, -6
10. 0x24andi s2, a0, 6
11. 0x28ori s3, a0, 6
12. 0x2cxori s4, a0, 6
13. 0x30slli s5, a0, 1
14. 0x34srli s6, a0, 2
15. 0x38srai s7, t1, 1

registres

t0	0
t1	0
t2	0
s0	0
s1	0
a0	20
a1	6
s2	0
s3	0
s4	0
s5	0
s6	0
s7	0
t3	0
t4	0
t5	0
t6	0

Reculer Exécuter une instruction Aller à la fin Reprendre Modifier le programme

Rien n'a encore été exécuté. Le compteur ordinal pointe la première instruction, en 0x0.

Il n'y a ni multiplication ni division dans RV32I. Doubler une valeur se fait en l'ajoutant à elle-même, ou en la décalant d'un bit vers la gauche, slli t0, t0, 1. Multiplier par une autre valeur demande une boucle, ou l'extension du jeu d'instructions que ce parcours n'emploie pas.

Comparer

Cette famille ne décide de rien : elle pose un 0 ou un 1 dans un registre, et laisse le programme en faire ce qu'il veut. Le s de slt est celui de set, « poser ».

programme

1. 0x0slt t0, a0, a1
2. 0x4slt t1, a1, a0
3. 0x8slt t2, a2, a0
4. 0xcsltu t3, a2, a0
5. 0x10slti t4, a0, 9
6. 0x14sltiu t5, a2, 9
7. 0x18seqz t6, a0sltiu t6, a0, 1
8. 0x1csnez s0, a0sltu s0, zero, a0

registres

t0	0
t1	0
t2	0
s0	0
a0	5
a1	9
a2	-1
t3	0
t4	0
t5	0
t6	0

Reculer Exécuter une instruction Aller à la fin Reprendre Modifier le programme

Rien n'a encore été exécuté. Le compteur ordinal pointe la première instruction, en 0x0.

Cette différence entre slt et sltu n'est pas un détail d'écriture : c'est la même suite de bits, lue de deux façons. Le chapitre sur les décisions revient dessus, et le module sur les masques en donne les conséquences.

Déplacer et charger une constante

Aucune de ces instructions ne calcule quoi que ce soit d'intéressant. Elles remplissent des registres, et ce sont les plus employées de tout le module.

programme

1. 0x0mv t0, a0addi t0, a0, 0
2. 0x4li t1, 100addi t1, zero, 100
3. 0x8li t2, 100000lui t2, 24
4. 0xcaddi t2, t2, 1696
5. 0x10la t3, mesurelui t3, 1
6. 0x14addi zero, zero, 0
7. 0x18lui t4, 2
8. 0x1cnopaddi zero, zero, 0

registres

t0	0
t1	0
t2	0
a0	42
t3	0
t4	0

mémoire

0x1000

mesure

7

Reculer Exécuter une instruction Aller à la fin Reprendre Modifier le programme

Rien n'a encore été exécuté. Le compteur ordinal pointe la première instruction, en 0x0.

Lire et écrire la mémoire

Cette famille est celle du chapitre suivant, qui l'installe geste par geste. Le mémento la donne ici pour mémoire, et la figure la fait tourner en entier.

programme

1. 0x0la t0, mesureslui t0, 1
2. 0x4addi zero, zero, 0
3. 0x8lw t1, 0(t0)
4. 0xclw t2, 4(t0)
5. 0x10sub t3, t2, t1
6. 0x14sw t3, 8(t0)
7. 0x18lb t4, 8(t0)
8. 0x1clbu t5, 8(t0)
9. 0x20lh t6, 8(t0)
10. 0x24lhu s0, 8(t0)
11. 0x28sh t1, 8(t0)
12. 0x2csb t2, 8(t0)

registres

sp	0x2000
t0	0
t1	0
t2	0
s0	0
t3	0
t4	0
t5	0
t6	0

mémoire

0x1000	mesures	12
0x1004		5
0x1008		0

Reculer Exécuter une instruction Aller à la fin Reprendre Modifier le programme

Rien n'a encore été exécuté. Le compteur ordinal pointe la première instruction, en 0x0.

Retenir pour l'instant les deux règles qui ne changeront plus : le décalage s'ajoute à l'adresse contenue dans le registre, et le processeur ne calcule jamais directement sur la mémoire. Tout passe par l'un des trente-deux registres. Ranger et reprendre reprend cette famille en détail, avec l'hexadécimal, l'ordre des octets et l'alignement.

Décider

Les branchements sont les seules instructions qui modifient le compteur ordinal autrement qu'en l'avançant de quatre. Ils comparent deux registres et sautent à une étiquette si la comparaison est vraie ; sinon l'exécution continue à la ligne suivante.

programme

1. 0x0li t0, 0addi t0, zero, 0
2. 0x4beq a0, a1, un
3. 0x8addi t0, t0, 1
4. 0xcbne a0, a1, deux
5. 0x10addi t0, t0, 2
6. 0x14blt a0, a1, trois
7. 0x18addi t0, t0, 4
8. 0x1cbge a0, a1, quatre
9. 0x20addi t0, t0, 8
10. 0x24bltu a0, a1, cinq
11. 0x28addi t0, t0, 16
12. 0x2cbgeu a0, a1, six
13. 0x30addi t0, t0, 32
14. 0x34beqz a0, septbeq a0, zero, sept
15. 0x38addi t0, t0, 64
16. 0x3cbnez a0, huitbne a0, zero, huit
17. 0x40addi t0, t0, 128
18. 0x44j finjal zero, fin
19. 0x48addi t0, t0, 256

registres

t0	0
a0	4
a1	9

Reculer Exécuter une instruction Aller à la fin Reprendre Modifier le programme

Rien n'a encore été exécuté. Le compteur ordinal pointe la première instruction, en 0x0.

j n'est pas un branchement mais un saut sans condition, et la colonne de droite le montre déjà : c'est jal zero, fin, une instruction de la famille suivante. Décider et Répéter traitent cette famille en détail, avec l'inversion de condition qu'un si … sinon demande et la forme d'une boucle.

Sauter et appeler

Un saut change le compteur ordinal. Un appel fait la même chose en gardant de quoi revenir, et c'est toute la différence.

programme

1. 0x0call doublerjal ra, doubler
2. 0x4li t0, 1addi t0, zero, 1
3. 0x8j finjal zero, fin
4. 0xcadd a0, a0, a0
5. 0x10retjalr zero, ra, 0
6. 0x14li t1, 2addi t1, zero, 2

registres

ra	0
t0	0
t1	0
a0	7

Reculer Exécuter une instruction Aller à la fin Reprendre Modifier le programme

Rien n'a encore été exécuté. Le compteur ordinal pointe la première instruction, en 0x0.

Le registre ra ne peut retenir qu'une adresse à la fois, ce qui suffit pour un appel et pas pour deux. Appeler résout ce problème avec la pile, et donne la convention qui rend un code appelable par un autre.

Ce qui n'est pas dans ce mémento

Ces tableaux couvrent les instructions que ce parcours emploie. RV32I en compte quelques autres, que le module ne rencontre pas : auipc, qui calcule une adresse relative au compteur ordinal, fence, qui ordonne les accès mémoire entre processeurs, ebreak, qui rend la main à un débogueur, et les instructions d'accès aux registres de contrôle. Une dernière, ecall, sert à demander un service au système et fait l'objet de Agir sur le monde.

Essayer plutôt que croire

Chaque figure de ce module porte un bouton « Modifier le programme ». Il ouvre le texte du programme, qui se réassemble et se réexécute à chaque frappe ; une erreur d'assemblage s'affiche à la place de la machine, avec son message, et un bouton ramène au programme d'origine. Un mémento cesse alors d'être une liste à lire pour devenir une liste à essayer, et c'est la seule façon de vérifier qu'une ligne de tableau a bien été comprise.

programme

1. 0x0add t0, a0, a1
2. 0x4slli t1, t0, 2

registres

t0	0
t1	0
a0	20
a1	6

Reculer Exécuter une instruction Aller à la fin Reprendre Modifier le programme

Rien n'a encore été exécuté. Le compteur ordinal pointe la première instruction, en 0x0.

Deux modifications à tenter sur cette figure, dans l'ordre.

1. Remplacer add par sub, puis prévoir la nouvelle valeur de t1 avant de regarder. Recommencer en échangeant a0 et a1 dans la même ligne : la soustraction n'est pas commutative, et le résultat change de signe.
2. Écrire addi t2, zero, 3000 en troisième ligne. L'assemblage est refusé, et le message nomme la limite des douze bits. Remplacer ensuite par li t2, 3000, qui passe, et lire la colonne des instructions réelles pour voir les deux instructions que l'assembleur a fabriquées.

Une troisième vaut pour toutes les figures de cette page : y ajouter la ligne d'une instruction du tableau qui reste obscure, avec des valeurs choisies exprès, et regarder ce qu'elle produit.

1.Dans addi t1, a0, 100, que désigne le nombre 100 ?

L'adresse d'une case mémoire où lire la valeurLe numéro du registre sourceUn immédiat, c'est-à-dire une constante écrite dans l'instruction elle-même

2.Que désigne 8(t0) dans lw t1, 8(t0) ?

La case mémoire dont l'adresse vaut le contenu de t0 augmenté de 8La huitième case du tableau dont t0 est le nomLe registre t0 décalé de huit bits

3.Pourquoi un immédiat ne peut-il pas dépasser 2047 ?

Parce qu'une instruction occupe trente-deux bits, dont douze seulement restent pour la constanteParce que les registres ne retiennent pas de valeurs plus grandesParce que l'assembleur refuse les nombres à quatre chiffres

4.Quelle instruction réelle l'assembleur produit-il pour mv t0, t1 ?

addi t0, t1, 0mov t0, t1Aucune : mv est exécutée telle quelle par le matériel

5.slt t2, a2, a0 et sltu t3, a2, a0 s'exécutent sur a2 valant -1 et a0 valant 5. Que donnent-elles ?

1 toutes les deux, puisque -1 est plus petit que 51 pour la première et 0 pour la seconde : les mêmes bits, lus signés puis non signés0 toutes les deux, puisque la comparaison porte sur des bits

6.Quelle est la différence entre j doubler et call doubler ?

Aucune : ce sont deux orthographes de la même instructioncall range l'adresse de retour dans ra, j ne garde riencall est plus rapide, j plus lisible

La méthode

1. Reconnaître la forme avant de chercher le nom : deux registres et une destination, un registre, une constante et une destination, ou un accès mémoire en décalage(registre). La forme dit déjà d'où viennent les valeurs et où va le résultat.
2. Lire le premier nom comme la destination, sauf pour les trois rangements sw, sh, sb et pour les branchements, qui n'en ont pas.
3. Vérifier qu'une constante tient sur douze bits avant de l'écrire dans une instruction ordinaire, et passer par li dans un registre au-delà de 2047.
4. Comparer la ligne écrite et l'instruction réelle chaque fois qu'un compte d'instructions ou une adresse d'étiquette est en jeu.
5. Chercher l'instruction dans la famille plutôt que dans une liste alphabétique : calculer, comparer, déplacer, lire et écrire, décider, sauter et appeler. Une instruction inconnue appartient forcément à l'une des six.
6. Essayer la ligne au lieu de la relire : ouvrir « Modifier le programme » sur la figure de la famille, ajouter l'instruction avec des valeurs choisies, et regarder le registre changer.

Synthèse

• Presque toute instruction RISC-V prend l'une de trois formes : deux registres vers un registre, un registre et une constante vers un registre, ou un accès mémoire noté décalage(registre). Les branchements forment une quatrième famille, sans destination.
• La notation 8(t0) désigne la case dont l'adresse est le contenu de t0 augmenté de 8, et jamais autre chose.
• Un immédiat est une constante écrite dans l'instruction. Il tient sur douze bits signés, de -2048 à 2047 ; au-delà, l'assembleur fabrique deux instructions, lui puis addi.
• Une pseudo-instruction est un nom remplacé à l'assemblage. mv, li, la, j, ret, call, beqz et les autres n'existent pas dans le matériel, et la colonne de droite des figures affiche ce qui s'exécute réellement.
• Le mémento range les instructions du module en six familles : calculer, comparer, déplacer et charger une constante, lire et écrire la mémoire, décider, sauter et appeler. Trois d'entre elles ont leur chapitre.
• Il n'y a ni multiplication ni division dans RV32I, et les trois rangements en mémoire sont les seules instructions dont le premier registre nommé est une source.
• Chaque figure se modifie, et se réassemble à chaque frappe : une instruction dont l'effet reste flou se vérifie en l'ajoutant à un programme plutôt qu'en relisant sa ligne de tableau.

Ces six familles suffisent à lire n'importe quel programme du module. Reste la question que les registres seuls ne peuvent pas régler : où vivent les données qui ne tiennent pas dans trente-deux cases. Ranger et reprendre ouvre la mémoire, et avec elle la famille des chargements et des rangements.