L'assembleur
Partie 5 sur 6
10La pile et les procédures
10.1La pile
La pile (en anglais stack) est une zone de mémoire qui sert à ranger temporairement des valeurs. On l’explique par l’image d’une pile de livres : on ne peut retirer que celui du dessus, qui est donc le dernier posé. On parle de structure LIFO (Last In, First Out, « dernier entré, premier sorti »). Deux instructions la manipulent : PUSH registre (empiler : poser la valeur du registre sur la pile) et POP registre (dépiler : retirer la valeur du dessus et la ranger dans le registre).
PUSH AX ; mettre AX de côté PUSH BX ; mettre BX de côté MOV AX, [0140] ; utiliser AX et BX librement… ADD BX, AX MOV [0140], BX POP BX ; restaurer BX (le dernier empilé sort le premier) POP AX ; restaurer AX
Cet exemple montre l’usage le plus courant : sauvegarder des registres avant de s’en servir et les restaurer ensuite, dans l’ordre inverse.
Deux registres gèrent la pile : SS (le segment de pile) et SP (Stack Pointer, le pointeur de pile), qui désigne le sommet. Détail qui déroute toujours au début : la pile grandit vers les adresses basses. Un PUSH sur 16 bits fait donc SP ← SP − 2 (la valeur occupe deux octets), et un POP fait SP ← SP + 2. En 64 bits, ces pas sont de 8 octets. Lorsque la pile est vide, SP pointe juste sous sa base ; un POP à ce moment-là lit des octets qui n’appartiennent plus à la pile, ce qui provoque une erreur ou, pire, un comportement imprévisible. L’inverse, empiler sans fin, produit un débordement de pile (stack overflow), cause fréquente de plantages dans les fonctions qui s’appellent elles-mêmes sans condition d’arrêt.
10.2Les procédures
Une procédure est un sous-programme : une suite d’instructions que l’on appelle par son nom, depuis plusieurs endroits, au lieu de la recopier. Les langages évolués l’appellent fonction. L’intérêt est le même que partout : écrire une fois, utiliser souvent, et obtenir un programme plus court et plus clair. Une procédure peut s’appeler elle-même, ce qui s’appelle la récursivité, à condition de prévoir une condition d’arrêt, sans quoi la pile se remplit jusqu’à déborder.
Pour appeler une procédure, on utilise CALL ; pour en revenir, RET. La difficulté est de revenir « au bon endroit » : une procédure peut être appelée de partout, et appeler d’autres procédures. La solution est la pile (figure 3) : CALL empile l’adresse de l’instruction qui suit l’appel (l’adresse de retour) avant de sauter dans la procédure, et RET dépile cette adresse et la recopie dans IP. Comme les appels s’emboîtent, les adresses de retour s’empilent dans l’ordre et ressortent en ordre inverse, exactement comme il le faut.
La procédure se déclare, en syntaxe MASM, entre des mots-clés : une étiquette (le nom), le mot PROC (début), les instructions, RET, puis ENDP (fin). Le mot near signalait une procédure située dans le même segment que l’appelant. Ces mots-clés sont des directives, des ordres donnés à l’assembleur lui-même et non au processeur.
10.3Passer des paramètres
Une procédure travaille en général sur des données qu’on lui fournit, mais, en assembleur, sa déclaration ne comporte pas de liste de paramètres. On les passe de deux manières.
- Par registres : on place les valeurs dans des registres convenus juste avant l’appel. C’est simple et rapide, mais limité par le nombre de registres.
- Par la pile : on empile les paramètres avant l’appel, et la procédure les lit à l’aide du registre
BP(Base Pointer), sans les dépiler : la procédure commence parMOV BP, SP, puisMOV AX, [BP]etMOV BX, [BP+2]lisent les mots suivants. Une subtilité souvent omise : au moment où la procédure démarre, le sommet de la pile contient l’adresse de retour empilée parCALLet non le premier paramètre ; l’accès aux paramètres se fait donc avec un décalage de deux octets de plus. Il faut aussi, après le retour, retirer les paramètres de la pile, soit par la procédure (RET 4par exemple), soit par l’appelant.
Dans la pratique actuelle, ce choix est fixé une fois pour toutes par une convention d’appel, un accord entre le compilateur, les bibliothèques et le système d’exploitation, pour que du code compilé séparément s’entende. Sous Linux et macOS sur x86-64 (convention dite « System V »), les six premiers paramètres entiers sont passés dans les registres RDI, RSI, RDX, RCX, R8 et R9, et le résultat revient dans RAX. Sous Windows, la convention utilise RCX, RDX, R8 et R9. Au-delà, les paramètres vont sur la pile. Cette convention est la raison pour laquelle, à la partie 13, la fonction qui calcule un carré lit son paramètre dans EDI.
11La mémoire et la segmentation
Un registre de 16 bits ne peut désigner que 216 = 65 536 cases, soit 64 kilo-octets de mémoire. C’était déjà trop peu pour l’Intel 8086, qui pouvait disposer de 1 mégaoctet (un million d’octets environ). Intel a résolu le problème par la segmentation : une adresse est formée de deux nombres de 16 bits, un segment et un déplacement (en anglais offset), notés segment:déplacement. Les instructions se lisent à l’adresse formée de CS:IP (segment de code et pointeur d’instruction), les données à DS: suivi de l’adresse de la case (segment de données), la pile à SS:SP.
On explique parfois cela de façon erronée : « les bus d’adresses récents possèdent 32 bits, les adresses sont donc constituées de deux composantes de 16 bits ». Ce n’est pas le bon calcul. Sur le 8086 (« mode réel »), l’adresse physique de 20 bits est obtenue en multipliant le segment par 16 (le décaler de quatre bits vers la gauche, soit un chiffre hexadécimal) puis en ajoutant le déplacement. Par exemple, 1234:0010 désigne l’adresse 12340 + 0010 = 12350. Les 20 bits permettent d’adresser 1 mégaoctet, non 4 gigaoctets. Un même octet peut d’ailleurs avoir plusieurs noms (1234:0010 et 1235:0000 désignent la même case), ce qui complique les programmes.
Que s’est-il passé depuis ? Avec le processeur 32 bits (1985), le « mode protégé » a changé le sens des registres de segment : ils ne contiennent plus une partie de l’adresse mais un numéro qui indexe une table décrivant la zone de mémoire (position, taille, droits d’accès). En pratique, les systèmes d’exploitation modernes utilisent un modèle « à plat » : un seul grand espace d’adresses pour chaque programme, et la protection est assurée par la mémoire virtuelle, un mécanisme qui donne à chaque processus l’illusion d’avoir sa propre mémoire, isolée des autres (voir la mémoire et les processus). En 64 bits, les segments de code, de données et de pile sont ignorés ; seuls deux registres de segment, FS et GS, servent encore, par exemple à retrouver les données propres à chaque fil d’exécution.
Un programme moderne est découpé en sections : une pour le code (en général .text, accessible en lecture et en exécution mais non modifiable), une pour les données initialisées (.data), une pour les données non initialisées (.bss), plus la pile et le tas (la zone où le programme demande de la mémoire à la demande). Séparer ces zones et leur donner des droits différents est une des principales défenses contre les attaques (partie 14).
12Du fichier source au programme
Le programme se saisit dans un fichier texte brut (sans gras, sans polices) appelé fichier source, avec une extension comme .asm. L’assembleur le traduit en un fichier objet (.obj sous Windows, .o sous Linux) qui contient les instructions en langage machine. Ce fichier ne peut pas encore s’exécuter : il lui manque les liens avec les autres fichiers objets et les bibliothèques. Un second programme, l’éditeur de liens (linker), réunit les fichiers et produit l’exécutable (.exe sous Windows). Même avec un seul fichier source, l’étape d’édition de liens est nécessaire.
On peut aussi générer un fichier binaire brut, copie exacte de la traduction, par exemple pour fabriquer le petit programme de démarrage placé sur le premier secteur d’un disque (voir le démarrage). C’est exact et toujours pratiqué.
12.1À quoi ressemble un fichier source
Un fichier source contient deux sortes de lignes : des instructions, que le processeur exécutera, et des directives, qui parlent à l’assembleur (réserver de la place, définir une constante, délimiter un segment, indiquer le point de départ). Le squelette d’un fichier MASM classique comprend un segment de données, un segment d’instructions, une directive ASSUME qui indique à l’assembleur quels registres de segment correspondent à quels segments, puis END debut qui nomme la première instruction à exécuter. Les points-virgules introduisent des commentaires. Voici l’équivalent actuel, pour Linux en 64 bits, avec l’assembleur NASM : un programme qui écrit « Bonjour » à l’écran, puis se termine.
global _start ; _start est le point d'entrée du programme
section .data ; section des données initialisées
msg db "Bonjour", 10 ; db : réserver des octets ; 10 = saut de ligne
len equ $ - msg ; len : constante = longueur du message
section .text ; section du code
_start:
mov rax, 1 ; numéro de l'appel système « write » (écrire)
mov rdi, 1 ; destination : sortie standard (l'écran)
mov rsi, msg ; adresse du texte
mov rdx, len ; nombre d'octets à écrire
syscall ; demander au système d'exploitation de le faire
mov rax, 60 ; numéro de l'appel système « exit » (terminer)
xor rdi, rdi ; code de sortie 0
syscall
Deux commandes suffisent à le construire et à l’exécuter : nasm -f elf64 bonjour.asm -o bonjour.o assemble, ld bonjour.o -o bonjour relie, et ./bonjour affiche « Bonjour ». Remarquez que le programme ne sait pas écrire à l’écran lui-même : il demande au système d’exploitation par l’instruction syscall, avec un numéro d’appel dans RAX et les paramètres dans les registres de la convention (voir les processus). Aucun programme ordinaire n’a le droit de toucher directement à l’écran ou au disque.
12.2Les outils de l’assembleur
Quelques outils reviennent constamment. Les assembleurs NASM (notation Intel, très répandu), MASM (celui de Microsoft) et GAS (GNU Assembler, notation AT&T par défaut) traduisent le texte. Le désassembleur, par exemple objdump -d, fait l’inverse : il retraduit des octets en instructions lisibles. Le débogueur (gdb, ou ses équivalents graphiques) exécute le programme pas à pas, instruction par instruction, en montrant l’état des registres, des indicateurs et de la pile ; c’est le meilleur moyen d’apprendre. Enfin le site « Compiler Explorer », créé par Matt Godbolt, affiche en direct l’assembleur produit par un compilateur à partir d’un petit programme en C, Rust ou autre.