Les nombres entiers
Notation binaire
Un entier est une abstraction qui représente des nombres sans partie décimale, comme 4, -2, 0 ou 64532.
Pour représenter un entier sous forme de suite d'octets, on utilise la notation binaire.
Dans cette notation, chaque bit de la séquence représente une puissance de deux distincte, la valeur augmentant à mesure que l'indice du bit augmente de la droite vers la gauche.
Nombres non signés
Si le nombre ne peut être que positif ou nul, on parle d'un nombre non signé.
Les nombres non signés sont représentés directement comme la somme des puissances de deux correspondant à tous les bits à 1 de leur séquence.
La plage des entiers positifs ou nuls représentables dans un registre va de 0 (aucun bit à 1) à 2⁶⁴ - 1 (somme des 64 bits à 1).
Pour élargir un nombre non signé vers une taille supérieure, on remplit tous les bits de poids fort avec des 0, de sorte qu'aucun nouveau bit ne contribue à la valeur.
C'est ce qu'on appelle l'extension par zéros.
L'instruction movzx (z pour zéro) étend par des zéros un opérande source de 8 ou 16 bits vers un opérande destination plus grand.
Un opérande source de 32 bits est toujours étendu par des zéros sur les 64 bits de l'opérande destination avec un simple mov.
Nombres signés
Si un entier peut prendre des valeurs positives ou négatives, on parle d'un nombre signé.
Pour représenter les nombres négatifs, x86-64 utilise la représentation en complément à deux.
En complément à deux, les nombres signés sont eux aussi représentés comme la somme des puissances de deux correspondant aux bits à 1.
Cependant, si le bit le plus haut est à 1, il est soustrait au lieu d'être ajouté aux autres.
Comme ce bit correspond à une valeur supérieure à la somme de tous les autres, en pratique cela signifie qu'un nombre dont ce bit est à 1 est toujours négatif.
Ce bit particulier est appelé le bit de signe.
Élargir un nombre signé vers une taille supérieure consiste à remplir chaque nouveau bit de poids fort avec une copie du bit de signe, afin que la valeur soit préservée.
C'est ce qu'on appelle l'extension de signe.
L'instruction movsx (s pour signe) étend le signe d'un opérande source de 8 ou 16 bits vers un opérande destination plus grand.
Une variante de movsx appelée movsxd fait de même d'un opérande source de 32 bits vers un opérande destination de 64 bits.
L'instruction neg permet de changer le signe d'un nombre.
En assembleur, il n'existe aucun moyen de savoir si une suite d'octets représente un nombre signé ou non signé.
C'est au programmeur de donner un sens à ces octets.
L'usage de commentaires peut grandement aider dans cette tâche.
Dans un concept précédent, on a vu qu'un nombre constant, comme 4 ou -15, peut être utilisé comme opérande source de nombreuses instructions.
Ces nombres sont appelés des immédiats.
Un immédiat n'est stocké ni dans un registre ni en mémoire : il est encodé à l'intérieur de l'instruction elle-même.
Dans la plupart des instructions, l'espace qui lui est réservé ne fait que 32 bits de large, quelle que soit la taille de l'opérande destination.
Quand l'opérande destination fait 64 bits de large, ces 32 bits sont étendus par le signe pour le remplir.
La moitié haute de l'opérande est entièrement remplie de copies du bit le plus haut de l'immédiat, donc seul un nombre de la plage d'un entier signé sur 32 bits peut être écrit de cette façon :
add rax, -1 ; the immediate is sign-extended, so all 64 bits of rax are affected
add rax, 2147483647 ; the largest immediate an instruction like this accepts
Un nombre en dehors de cette plage ne peut pas être utilisé comme immédiat.
L'exception à cette règle est mov, qui accepte un immédiat complet de 64 bits quand l'opérande destination est un registre.
Si un immédiat de 64 bits est nécessaire, on utilise d'abord mov pour le charger dans un registre, puis on se sert de ce registre :
mov rax, 3435973837 ; this works, mov can take a 64-bit immediate
mov rdx, 18446744073709551615 ; the largest immediate mov accepts
sub rdx, rax
Note qu'un immédiat négatif et le nombre non signé ayant la même représentation binaire sont équivalents et s'assemblent exactement vers la même valeur :
mov rax, -1 ; rax = 18446744073709551615
mov rax, 18446744073709551615 ; rax = -1
Somme
L'addition de deux nombres peut se calculer avec l'instruction add.
Il existe aussi une instruction inc à un opérande, qui ajoute 1 à la valeur de son opérande :
inc rax ; rax = rax + 1
La somme de deux entiers fonctionne de la même façon pour les nombres non signés et signés.
Soustraction
La soustraction de deux entiers s'effectue avec l'instruction sub.
Il existe aussi une instruction dec à un opérande, qui soustrait 1 à la valeur de son opérande :
dec rax ; rax = rax - 1
La soustraction de deux entiers fonctionne elle aussi de la même façon pour les nombres non signés et signés.
Multiplication
Il existe deux instructions différentes pour effectuer une multiplication entre deux nombres en x86-64.
En règle générale, la multiplication non signée utilise l'instruction mul, tandis que la multiplication signée utilise imul.
L'instruction mul prend la forme à un opérande suivante, où src est l'opérande source :
mul src
L'instruction imul peut prendre une forme à un, deux ou trois opérandes :
imul src
imul dest, src
imul dest, src1, src2
Multiplication à un opérande
Deux registres sont implicitement utilisés pour effectuer une multiplication sous la forme à un opérande : rax et rdx.
Si la multiplication porte sur deux nombres de 64 bits, les 64 bits de poids faible du résultat se trouvent dans rax et les 64 bits de poids fort dans rdx.
On appelle généralement cela rdx:rax, pour indiquer que les deux registres sont utilisés de concert :
mul rcx ; rax = lower 64 bits of rax * rcx
; rdx = upper 64 bits of rax * rcx
Il en va de même pour les autres tailles d'opérande.
Ainsi, par exemple, si l'on multiplie deux nombres de 32 bits, ce sont eax et edx qui sont utilisés.
L'exception est la multiplication entre deux octets.
Dans ce cas, au lieu de dl:al, c'est ax qui est utilisé.
La partie basse de ax (al) reçoit les 8 bits de poids faible du produit, tandis que la partie haute (ah) reçoit les 8 bits de poids fort.
Les registres implicitement utilisés dans une multiplication, comme rax et rdx, sont toujours écrasés.
Il faut sauvegarder les valeurs de ces registres avant l'opération si on en a besoin plus tard.
Multiplication à deux opérandes
La forme à deux opérandes de imul a un opérande destination explicite et suit la syntaxe habituelle.
rdx n'est pas utilisé.
À la place, le résultat est tronqué pour tenir dans l'opérande destination.
imul r8, r9 ; r8 = lower 64 bits of r8 * r9
Multiplication à trois opérandes
La forme à trois opérandes de imul a deux opérandes source, dont le second est toujours un immédiat (un nombre constant).
Les deux opérandes source sont multipliés, puis le résultat est tronqué et placé dans l'opérande destination :
imul r8, r9, 100 ; r8 = lower 64 bits of r9 * 100
Note que l'opérande destination n'est pas utilisé dans la multiplication.
Il ne fait que recevoir le résultat.
Gère le débordement
Les multiplications à deux et à trois opérandes tronquent le résultat pour qu'il tienne dans la taille de l'opérande destination.
Une multiplication à un opérande préserve toute la plage, mais le résultat est généralement réparti sur deux registres, rdx et rax.
Il est donc parfois utile d'élargir les opérandes avant la multiplication pour faire tenir tout le produit dans un seul registre.
Un opérande non signé est étendu par des zéros, tandis qu'un opérande signé est étendu par le signe :
movzx eax, di ; di and si hold unsigned 16-bit numbers
movzx ecx, si
mul ecx ; the 32-bit product fits in eax, and edx is cleared
Division
Comme pour la multiplication, il existe également deux instructions pour effectuer une division entre deux nombres.
La division non signée utilise l'instruction div, tandis que la division signée utilise idiv.
Les deux instructions ne fonctionnent qu'avec un seul opérande :
div src
idiv src
Les divisions sur 16, 32 et 64 bits utilisent respectivement dx:ax, edx:eax et rdx:rax comme dividende.
Dans ces cas, les deux registres agissent de concert pour former une valeur de 2N bits, où N est la taille de l'opération (16, 32 ou 64 bits).
Cette valeur est ensuite divisée par l'opérande source.
Le quotient est écrit dans ax, eax ou rax et le reste dans dx, edx ou rdx, selon la taille de l'opération.
La division entre octets est particulière : au lieu d'utiliser dl:al, c'est ax qui est utilisé.
Les 8 bits de poids faible de ax (al) reçoivent le quotient de l'opération et les 8 bits de poids fort (ah) reçoivent le reste.
Note que tous les bits du dividende doivent être correctement positionnés avant la division.
Tout bit à 1 dans rdx (ou dans ah pour une division sur 8 bits) contribue à la valeur à diviser.
Dans une division non signée, quand la valeur à diviser tient dans la moitié basse, il faut mettre à zéro la moitié haute.
N'importe quelle instruction qui met ces bits à zéro fait l'affaire.
Par exemple, mov edx, 0 met à zéro les bits de poids fort dans une division sur 32 bits.
Dans une division signée, il faut plutôt étendre la valeur par le signe.
Certaines instructions automatisent ce processus : cbw, cwd, cdq et cqo.
La première positionne les bits de ah selon le signe de al.
Les autres réalisent une extension de signe respectivement de ax vers dx, de eax vers edx et de rax vers rdx.
Les registres implicitement utilisés dans une division, comme rax et rdx, sont toujours écrasés.
Il faut sauvegarder les valeurs de ces registres avant la division si on en a besoin plus tard.
Exercice d'apprentissage
