L'assembleur
Partie 4 sur 6
8Les indicateurs : la mémoire du dernier calcul
Après chaque opération arithmétique ou logique, l’unité de calcul inscrit dans de petites cases d’un bit, les indicateurs (en anglais flags, « drapeaux »), quelques informations sur le résultat. Ils sont regroupés dans un registre d’état qu’on ne manipule que par des instructions spécifiques. Les quatre principaux sont :
ZF(Zero Flag, indicateur de zéro) : vaut 1 si le résultat est nul. Il sert à tester l’égalité, en soustrayant les deux valeurs : si la différence est nulle, elles étaient égales.SF(Sign Flag, indicateur de signe) : recopie le bit de poids fort du résultat, qui indique le signe d’un nombre signé (1 pour négatif, 0 pour positif).CF(Carry Flag, indicateur de retenue) : vaut 1 s’il y a eu une retenue sortante lors d’une addition de nombres positifs, ou un « emprunt » lors d’une soustraction ; autrement dit, si le résultat n’a pas tenu dans le nombre de bits disponible, pour des nombres non signés.OF(Overflow Flag, indicateur de débordement) : vaut 1 si le résultat d’une opération sur des nombres signés n’est pas représentable (par exemple, la somme de deux nombres positifs qui donne un nombre négatif).
Voyons un exemple sur quatre bits. On additionne 0110 (6) et 0101 (5), ce qui donne 1011. Si l’on interprète ce résultat comme un nombre signé sur quatre bits, c’est −5 : la somme de deux positifs est négative, il y a donc débordement (OF = 1). Le résultat n’est pas nul (ZF = 0), son bit de poids fort est 1 (SF = 1), et il n’y a pas de retenue sortante (CF = 0). Pris comme un nombre non signé, ce même résultat vaut 11, qui est correct : le même calcul est correct dans un cas, faux dans l’autre, et ce sont les indicateurs qui le disent. Deux autres exemples sur huit bits : 0xFF + 0x01 donne 0x00 avec CF = 1 et ZF = 1 (retenue, résultat nul), mais OF = 0 (en signé, −1 + 1 = 0 est correct) ; 0x7F + 0x01 donne 0x80 avec OF = 1 et SF = 1 (en signé, 127 + 1 déborde en −128).
Les instructions STC et CLC (Set Carry, Clear Carry) mettent CF à 1 ou à 0 « à la main ».
8.1Comparer : CMP
L’instruction CMP (comparer) soustrait deux valeurs sans conserver le résultat et ne garde que les indicateurs. Elle fait ce que fait SUB, mais sans modifier ses opérandes. Par exemple, CMP AX, 2 met ZF à 1 si AX vaut 2. On lit parfois que sa « seule action » est de positionner ZF : c’est incomplet, puisqu’elle positionne tous les indicateurs, et ces autres indicateurs servent justement à comparer des valeurs inégales (plus grand, plus petit). L’instruction TEST est sa cousine : elle fait un AND sans conserver le résultat, pour tester des bits.
9Sauter : les branchements
En temps normal, le processeur exécute les instructions les unes après les autres, dans l’ordre de la mémoire. Le registre IP (ou RIP) contient l’adresse de la prochaine : le processeur la lit, avance IP à l’instruction suivante, exécute l’instruction lue, et recommence. Un saut (ou branchement) est une instruction qui modifie IP pour poursuivre ailleurs. Tous les tests (« si… alors… sinon ») et toutes les boucles (« tant que… ») des langages évolués deviennent des sauts à ce niveau-là (voir les langages de programmation).
9.1Le saut inconditionnel
L’instruction JMP (jump, « sauter ») effectue un saut quoi qu’il arrive. Son opérande dit où aller : une étiquette (un nom placé devant une instruction) ou un déplacement. Voici un exemple corrigé :
| Adresse | Octets | Instruction | Commentaire |
|---|---|---|---|
0100 | A1 20 01 | MOV AX, [0120] | copie la case 0120 dans AX |
0103 | EB FB | JMP 0100 | saute à l’adresse 0100 |
0105 | 89 1E 20 01 | MOV [0120], BX | jamais exécutée à cause du saut |
Cet exemple donne souvent lieu à deux erreurs de calcul. On affirme que « la taille de l’instruction JMP est de 1 bit » : c’est de 2 octets (un pour le code opération, un pour le déplacement), pour le saut court. Et l’on calcule le déplacement comme l’adresse visée moins l’adresse de l’instruction suivante, soit 0100 − 0104 = −4, mais en supposant l’instruction suivante à l’adresse 0104 alors que, le JMP faisant 2 octets, elle est à 0105. Le déplacement vaut donc 0100 − 0105 = −5, soit FB en hexadécimal sur un octet signé. La règle à retenir : le déplacement se compte à partir de l’instruction qui suit le saut, car au moment de l’exécution, IP a déjà avancé.
9.2Les sauts conditionnels
Un saut conditionnel n’est effectué que si une condition portant sur les indicateurs est remplie ; sinon le processeur passe, comme si de rien n’était, à l’instruction suivante. Il se place donc juste après une instruction qui a positionné les indicateurs, généralement CMP. Le tableau 4 donne les principaux.
| Instruction | Signification | Condition | Pour des nombres |
|---|---|---|---|
JE | saute si égal | ZF = 1 | tous |
JNE | saute si différent | ZF = 0 | tous |
JA | saute si supérieur (above) | CF = 0 et ZF = 0 | non signés |
JB | saute si inférieur (below) | CF = 1 | non signés |
JBE | saute si inférieur ou égal | CF = 1 ou ZF = 1 | non signés |
JG | saute si strictement plus grand (greater) | ZF = 0 et SF = OF | signés |
JLE | saute si inférieur ou égal (lower or equal) | ZF = 1 ou SF ≠ OF | signés |
Le dernier critère est essentiel et souvent oublié : le processeur ne sait pas si un nombre est signé ou non, c’est l’instruction de saut choisie par le programmeur qui donne le sens. L’octet FF vaut 255 pour un non signé et −1 pour un signé. Comparé à 1, il est « supérieur » dans le premier cas (JA saute) et « inférieur » dans le second (JG ne saute pas). Se tromper de saut est une source classique de bogues, et parfois de failles de sécurité.
9.3Une boucle complète
Voici une boucle qui additionne les entiers de 1 à 5, en x86-64, notation Intel (programme réel pour Linux, assemblé avec NASM ; le résultat est renvoyé au système comme code de sortie du programme) :
global _start
section .text
_start:
mov rax, 0 ; rax : total, au départ 0
mov rcx, 1 ; rcx : compteur, au départ 1
boucle:
add rax, rcx ; total = total + compteur
inc rcx ; compteur = compteur + 1
cmp rcx, 5 ; comparer le compteur à 5
jle boucle ; si compteur <= 5 (signé), retourner à « boucle »
mov rdi, rax ; le total devient le code de sortie
mov rax, 60 ; appel système « exit »
syscall ; le programme se termine avec le code 15
Le programme se termine avec le code de sortie 15, soit 1 + 2 + 3 + 4 + 5. On y retrouve toute la mécanique : un compteur dans un registre, une comparaison, un saut conditionnel qui renvoie en arrière. Dans un langage évolué, cela s’écrit for i in range(1, 6) ; l’assembleur dévoile ce qui se cache derrière.
Pour s’exercer
Exercice 5 : le déplacement d’un saut
Un JMP court de 2 octets, situé à l’adresse 0103, doit revenir à l’adresse 0100. Quel est le déplacement ? Comment s’écrit l’instruction en octets (le code opération du saut court est EB) ?
Voir la réponse
L’instruction suivante est à 0103 + 2 = 0105. Le déplacement vaut 0100 − 0105 = −5. Sur un octet signé, −5 s’écrit FB (256 − 5 = 251 = 0xFB). L’instruction est EB FB. Pour un déplacement mesuré depuis l’adresse du saut lui-même (−3), on se tromperait de deux octets, et le programme sauterait au milieu d’une instruction.
Exercice 6 : suivre la pile
On suppose SP = 0100, AX = 7, BX = 9, sur un processeur 16 bits. On exécute PUSH AX, PUSH BX, POP AX, POP BX. Donnez les valeurs de SP après chaque instruction et les valeurs finales de AX et BX. Que réalise cette séquence ?
Voir la réponse
Après PUSH AX : SP = 00FE (la pile grandit vers le bas, de 2 octets), la pile contient 7. Après PUSH BX : SP = 00FC, la pile contient 7 puis 9 au sommet. POP AX retire le sommet : AX = 9, SP = 00FE. POP BX retire 7 : BX = 7, SP = 0100. Les valeurs de AX et BX ont été échangées, et la pile est revenue à son état de départ : c’est un échange de deux registres par la pile.
Exercice 7 : signé ou non signé ?
On exécute MOV AL, 0FFh, CMP AL, 1, puis, selon le cas, JA suite ou JG suite. Le saut est-il pris dans chaque cas ? Pourquoi est-ce important en pratique ?
Voir la réponse
CMP calcule 255 − 1 sans conserver le résultat, ce qui donne CF = 0 et ZF = 0. JA (non signés) saute si CF = 0 et ZF = 0 : le saut est pris, car 255 est supérieur à 1. JG (signés) saute si ZF = 0 et SF = OF : la différence 254 (0xFE) a SF = 1 alors que OF = 0 (en signé, −1 − 1 = −2, sans débordement) ; la condition n’est pas remplie, le saut n’est pas pris, car −1 est inférieur à 1. En pratique, l’erreur la plus courante est de comparer avec le mauvais type de saut : un contrôle de taille écrit en signé peut laisser passer une valeur énorme (négative en signé) et ouvrir une faille de mémoire.