Le processeur et l'assembleur

Le processeur ne comprend que des instructions

Cette phrase, que tous les cours du domaine répètent, passe pour une formule. Elle est littérale.

Un processeur est un circuit. Il reçoit un nombre de trente-deux bits et, selon la disposition de ces bits, laisse passer les valeurs vers son additionneur, vers son comparateur, ou vers la sortie qui parle à la mémoire. Ce nombre s'appelle une instruction. Rien à l'intérieur ne ressemble à un mot ou à un nom de variable : rien qui puisse être interprété, deviné, ou compris au sens courant du terme.

add t0, a0, a1 n'existe donc pas dans la machine : c'est la transcription lisible du nombre qui, lui, existe. Le nom add s'appelle un mnémonique, et l'assembleur traduit ces mnémoniques en nombres, presque toujours un pour un.

Un mot mérite d'être écarté : ce ne sont pas des commandes. Une commande se tape dans un terminal et peut échouer en expliquant pourquoi ; une instruction s'adresse à un circuit et ne discute pas.

La conséquence est vertigineuse : tout ce qu'une machine exécute, un interpréteur Python, un navigateur, un système d'exploitation, est une suite d'instructions choisies dans une liste très courte.

Trois pièces, et rien d'autre

Un processeur ne contient ni variables, ni fonctions, ni types. Son état complet tient dans trois choses.

Les registres sont des cases de calcul internes, en nombre fixe et très petit : trente-deux en RISC-V, chacune contenant un nombre de trente-deux bits. Ce sont les seules cases sur lesquelles le processeur sait calculer directement. Elles portent des noms courts, t0, a0, sp, qui sont des étiquettes sur des cases, pas des noms de variables.

La mémoire est un très grand tableau d'octets numérotés, dont le numéro s'appelle une adresse. Le processeur ne sait pas calculer dessus : il sait seulement en recopier un morceau dans un registre, ou l'inverse. Registres et mémoire s'occupe de ce va-et-vient.

Le compteur ordinal est un registre à part, qui contient l'adresse de la prochaine instruction à exécuter. C'est lui, et lui seul, qui décide de ce qui se passe ensuite. Il porte souvent son nom anglais, program counter, abrégé pc.

Exécuter un programme consiste à répéter le même geste : lire l'instruction que le compteur ordinal désigne, la faire, avancer le compteur ordinal.

La première instruction

Voici l'instruction la plus simple du jeu : elle prend le contenu de deux registres, les additionne, et range le résultat dans un troisième.

L'ordre des trois noms se lit toujours de la même façon en RISC-V : la destination d'abord, les sources ensuite. add t0, a0, a1 se lit donc « ranger dans t0 la somme de a0 et de a1 ». Cette régularité vaut pour presque tout le jeu, et c'est une des raisons pour lesquelles ce cours l'a choisi.

La ligne registres: en tête n'est pas une instruction : elle décrit la machine avant le départ. Sans elle, tous les registres valent zéro.

Une liste fixe, et publiée

Un langage de programmation s'étend sans cesse : une fonction définie, une bibliothèque importée, et le vocabulaire disponible a grandi. Un jeu d'instructions ne fonctionne pas ainsi. La liste est close. RISC-V de base en compte une quarantaine, décidées une fois et gravées dans le circuit : en ajouter une ne s'écrit pas, cela se fabrique.

Fixe au sens le plus matériel : le décodeur est câblé pour reconnaître ces motifs de bits et aucun autre. Publiée, ensuite : la spécification de RISC-V est un document public, ce qui permet d'écrire un compilateur ou un débogueur pour cette machine, puis d'exécuter le résultat sur la puce d'un autre fabricant.

Plusieurs de ces listes coexistent : x86-64 sur les serveurs, ARM sur les téléphones, RISC-V dans l'embarqué. Un programme compilé pour l'une ne s'exécute pas sur l'autre, et c'est ce que veut dire « un exécutable pour telle machine ».

La conséquence pratique est immédiate : quand un calcul ne figure pas dans la liste, il faut le construire avec ce qui s'y trouve. RISC-V de base n'a ni multiplication ni division : doubler une valeur se fait en l'ajoutant à elle-même, et multiplier deux valeurs quelconques demande une boucle. Le chapitre suivant donne la liste entière, famille par famille.

Le compteur ordinal avance de quatre en quatre

Chaque instruction occupe quatre octets en mémoire. La première du programme est donc à l'adresse 0x0, la deuxième à 0x4, la troisième à 0x8. L'écriture 0x annonce un nombre en hexadécimal, une notation que le chapitre sur le binaire et l'hexadécimal explique ; il suffit ici de savoir que 0x8 vaut huit.

Le registre t0 prend successivement les valeurs 10, 15, puis 30. Trois instructions, trois états : addi t0, t0, 5 ajoute cinq à ce que t0 contient déjà, et slli t0, t0, 1 décale son contenu d'un bit vers la gauche, ce qui revient à le doubler.

Le bouton qui recule d'un pas mérite d'être essayé tout de suite : il rend accessible l'instant précis où une valeur a changé, sans relancer le programme depuis le début.

L'ordre est le programme

Les trois mêmes instructions, dans un autre ordre, ne donnent pas le même résultat.

Dix, doublé, plus cinq : vingt-cinq. Dix, plus cinq, doublé : trente. L'écart n'a rien de surprenant, mais il dit l'essentiel sur la machine : un processeur n'a aucune notion de priorité des opérations. Pas de parenthèses, pas d'expression. Une suite de gestes, et le résultat est ce que cette suite produit.

Traduire une formule vers l'assembleur consiste donc à choisir un ordre, et à trouver où ranger les résultats intermédiaires.

Un programme est une trajectoire, pas une description. Un langage de haut niveau décrit un résultat et laisse le compilateur choisir le chemin. L'assembleur est le chemin : deux programmes qui finissent sur le même registre peuvent passer par des états entièrement différents.

Le registre qui ne change jamais

Parmi les trente-deux registres, le premier est particulier. Il s'appelle zero, et il contient zéro pour toujours : le matériel l'a câblé ainsi, et les instructions qui prétendent l'écrire sont exécutées normalement, leur résultat jeté.

Une case qui ne retient rien peut sembler un gâchis. C'est en réalité l'astuce la plus rentable du jeu, parce qu'elle évite d'inventer des instructions : copier un registre n'a pas d'instruction propre, c'est une addition avec zero, et poser une constante non plus. Le chapitre Les branchements conditionnels en donnera d'autres usages, autour des comparaisons.

Ce que l'assembleur écrit à la place de ce qui est écrit

Dans les figures précédentes, li t0, 10 apparaît, mais la colonne de droite affiche addi t0, zero, 10. Les deux lignes ne se contredisent pas : li n'existe pas dans le matériel. C'est un raccourci d'écriture, une pseudo-instruction, que l'assembleur remplace par une instruction réelle au moment de produire le programme. Le remplacement n'est pas toujours aussi direct.

La raison tient à une contrainte de format. Une instruction occupe trente-deux bits, qui doivent loger l'opération, les registres et la constante : il ne reste que douze bits pour cette dernière, soit -2048 à 2047. Cent mille n'y tient pas, et l'assembleur fabrique donc deux instructions, la figure montrant t1 passer par 98 304 avant d'atteindre 100 000.

Les pseudo-instructions sont une vingtaine, et le chapitre suivant en donne la table complète : il n'y a aucune raison de les retenir.

Traduire un petit calcul

Soit à calculer, à partir d'une mesure rangée dans a0 et d'une correction rangée dans a1, la valeur (a0 - a1) × 2 - 2. Faute de multiplication, doubler un nombre revient à l'ajouter à lui-même.

La première ligne emploie sub, la soustraction, qui se lit comme add : la destination d'abord, puis les deux sources dans l'ordre. sub t0, a0, a1 range donc dans t0 la valeur de a0 moins celle de a1, et cet ordre, indifférent pour une addition, décide ici du signe : sub t0, a1, a0 aurait rangé -21.

Vingt-cinq moins quatre donne vingt et un, doublé quarante-deux, moins deux quarante. Trois registres pour trois étapes : c'est la forme la plus lisible, et pas la plus économe, puisque chaque étape n'a besoin que de la précédente et qu'un seul registre suffirait.

Noter aussi ce qui n'apparaît nulle part : le fait que a0 soit une mesure et a1 une correction. La machine voit deux nombres, et tout le sens est dans la tête de qui écrit, ou dans les commentaires.

Ce que l'assembleur sert à faire, et ce qu'il ne sert plus à faire

Autant le dire : un ingénieur qui lit ce module n'écrira probablement jamais un programme en assembleur. Ce travail a été confié aux compilateurs il y a plusieurs décennies, et ils le font mieux : choisir quel résultat garder dans quel registre, ordonner les instructions pour que le processeur ne s'arrête pas à attendre, sont des tâches de comptabilité sur des milliers de lignes, où une machine bat un humain sans discussion.

Ce qui reste ne disparaît pas.

Lire. Un rapport de plantage, un débogueur arrêté dans une bibliothèque sans code source, un profileur qui désigne une ligne coûteuse : tous affichent des instructions. Savoir les lire transforme un écran incompréhensible en une phrase simple : « un chargement à une adresse qui vaut zéro ».

Vérifier. Deux écritures équivalentes dans un langage de haut niveau produisent parfois trois instructions dans un cas et trente dans l'autre, et seul le compilateur le dit.

Écrire quelques lignes, là où rien d'autre ne marche : le démarrage d'une machine, un gestionnaire d'interruption, un pilote qui parle à un composant à l'octet près. Quelques dizaines de lignes dans des systèmes qui en comptent des millions, mais quelqu'un les écrit.

Lire plutôt qu'écrire. Le bénéfice de ce module n'est pas une compétence de rédaction, c'est un modèle : un rez-de-chaussée où rien n'est caché, auquel il devient possible de descendre quand l'étage au-dessus cesse d'être compréhensible. Les bugs qui semblent relever de la magie ont presque toujours, ici, une explication ennuyeuse.

Mettre en pratique

Le programme suivant contient une instruction sans effet. La trouver avant de lancer la figure.