Langage d'assemblage - Instructions arithmétiques
Les instructions arithmétiques sont la base des opérations mathématiques du CPU. Ce chapitre détaille l'addition, la soustraction, la multiplication, la division et les instructions d'opérations de retenue associées dans l'architecture x86.
ADD - Instruction d'addition
ADDAjoute l'opérande source à l'opérande destination et stocke le résultat dans l'opérande destination.
Exemple
; Exemple d'instruction ADD : calculer 100 + 200 + 300
section .data
a dd 100
b dd 200
c dd 300
sum dd 0
section .text
global _start
_start:
; Méthode 1 : registre += immédiat
mov eax, [a] ; eax = 100
add eax, 200 ; eax = 100 + 200 = 300
; Méthode 2 : registre += registre
mov ebx, [b] ; ebx = 200
add eax, ebx ; eax = 300 + 200 = 500
; Méthode 3 : registre += mémoire
add eax, [c] ; eax = 500 + 300 = 800
; Stocker le résultat
mov [sum], eax ; sum = 800
; Effet de l'addition sur les drapeaux
mov eax, 0xFFFFFFFF ; eax = plus grand nombre non signé sur 32 bits
add eax, 1 ; eax = 0 (le débordement s'enroule)
; CF = 1 (retenue générée)
; ZF = 1 (le résultat est 0)
; OF = 0 (pas de débordement du point de vue signé)
mov eax, 1
mov ebx, 0
int 0x80
SUB - Instruction de soustraction
SUBSoustrait l'opérande source de l'opérande destination et stocke le résultat dans l'opérande destination.
Exemple
; Exemple d'instruction SUB
section .data
x dd 1000
y dd 300
section .text
global _start
_start:
; Soustraction de base
mov eax, [x] ; eax = 1000
sub eax, [y] ; eax = 1000 - 300 = 700
; Effet de la soustraction sur les drapeaux
mov eax, 10
sub eax, 20 ; eax = -10 (c.-à-d. 0xFFFFFFF6)
; CF = 1 (emprunt généré : 10 < 20)
; SF = 1 (le résultat est négatif)
; ZF = 0 (le résultat est non nul)
; OF = 0 (pas de débordement signé)
; Soustraction de soi-même : souvent utilisée pour mettre à zéro
mov eax, 12345
sub eax, eax ; eax = 0
; ZF = 1, CF = 0
; C'est une façon classique de mettre à zéro un registre (plus efficace que mov eax, 0)
mov eax, 1
mov ebx, 0
int 0x80
sub eax, eaxest une technique classique pour mettre à zéro un registre ; elle n'occupe que 2 bytes, alors quemov eax, 0occupe 5 bytes. Elle est couramment utilisée dans des scénarios nécessitant une optimisation extrême de la taille (comme le shellcode).
INC / DEC - Instructions d'incrémentation/décrémentation
Instructions d'ajout de 1 et de soustraction de 1 plus concises que ADD/SUB :
Exemple
section .data
counter dd 0
section .text
global _start
_start:
mov dword [counter], 0 ; counter = 0
inc dword [counter] ; counter = 1 (opérande mémoire)
inc dword [counter] ; counter = 2
mov ecx, 10
dec ecx ; ecx = 9
dec ecx ; ecx = 8
; INC/DEC n'affectent pas l'indicateur CF (ce qui est une différence importante par rapport à ADD/SUB)
; Mais elles affectent ZF, SF, OF, PF
; Utilisation de INC dans une boucle
mov ecx, 5
mov eax, 0
loop_inc:
inc eax ; eax s'incrémente de 1 à chaque fois
loop loop_inc ; Répéter 5 fois, eax finalement = 5
mov ebx, eax ; Valeur de retour = 5
mov eax, 1
int 0x80
MUL - Multiplication non signée
MULEffectue une multiplication non signée. Les règles de multiplication sont quelque peu spéciales :
| Taille de l'opérande | Multiplicateur | Multiplicande (implicite) | Stockage du résultat |
|---|---|---|---|
| 1 octet | Tout registre ou mémoire de 8 bits | AL | AX = AL × opérande |
| 2 octets | N'importe quel registre 16 bits ou mémoire | AX | DX:AX = AX × opérande |
| 4 octets | N'importe quel registre 32 bits ou mémoire | EAX | EDX:EAX = EAX × opérande |
Exemple
; Exemple de multiplication non signée avec MUL
section .data
val1 dd 1000
val2 dd 2000
result_low dd 0
result_high dd 0
section .text
global _start
_start:
; multiplication 32 bits : EDX:EAX = EAX × opérande
mov eax, [val1] ; eax = 1000
mul dword [val2] ; edx:eax = 1000 × 2000 = 2,000,000
; Résultat = 2,000,000 = 0x001E8480
; EAX = 0x001E8480 (32 bits de poids faible)
; EDX = 0x00000000 (32 bits de poids fort, car le résultat n'a pas dépassé 32 bits)
; Démonstration de multiplication de grands nombres (le résultat dépasse 32 bits)
mov eax, 0xFFFFFFFF ; eax = 4,294,967,295
mov ebx, 2 ; ebx = 2
mul ebx ; edx:eax = 0xFFFFFFFF × 2
; EAX = 0xFFFFFFFE
; EDX = 0x00000001 (32 bits de poids fort)
; CF = 1 (le résultat dépasse 32 bits)
; Enregistrer le résultat
mov [result_low], eax
mov [result_high], edx
mov eax, 1
mov ebx, 0
int 0x80
IMUL - Multiplication signée
IMULUtilisé pour la multiplication de nombres signés, avec trois formes :
Exemple
; Exemple de multiplication signée IMUL
section .data
a dd -100
b dd 3
section .text
global _start
_start:
; Forme à un opérande : identique à MUL
mov eax, [a] ; eax = -100
imul dword [b] ; edx:eax = -100 × 3 = -300
; EAX = -300(0xFFFFFED4)
; EDX = 0xFFFFFFFF (extension de signe)
; Forme à deux opérandes : reg = reg × opérande
mov ebx, [a] ; ebx = -100
imul ebx, [b] ; ebx = -100 × 3 = -300
; Le résultat doit tenir sur 32 bits
; Forme à trois opérandes : reg = opérande1 × immédiat
imul ecx, [a], 5 ; ecx = -100 × 5 = -500
mov eax, 1
mov ebx, 0
int 0x80
MULetIMULLa principale différence est la gestion des signes :MULInterprétés comme des nombres non signés,IMULInterprétés comme des nombres signés. Par exemple, 0xFFFFFFFF vaut 4294967295 dans MUL, et -1 dans IMUL.
DIV - Division non signée
DIVEffectue une division non signée, les règles sont symétriques à MUL :
| Taille du diviseur | Dividende (implicite) | Quotient | Reste |
|---|---|---|---|
| 1 octet | AX | AL | AH |
| 2 octets | DX:AX | AX | DX |
| 4 octets | EDX:EAX | EAX | EDX |
Exemple
; Exemple de division non signée avec DIV
section .data
dividend dd 1000
divisor dd 7
quotient dd 0
remainder dd 0
section .text
global _start
_start:
; division 32 bits : edx:eax / diviseur
; Le dividende doit d'abord être étendu à EDX:EAX
mov eax, [dividend] ; eax = 1000
mov edx, 0 ; edx = 0 (mettre à zéro les 32 bits de poids fort)
div dword [divisor] ; edx:eax / 7
; EAX = 142 (quotient)
; EDX = 6 (reste : 1000 = 142×7 + 6)
mov [quotient], eax ; quotient = 142
mov [remainder], edx ; reste = 6
; Exemple de division d'octet : 55 / 4
mov ax, 55 ; Dividende
mov bl, 4 ; Diviseur
div bl ; al = 13 (quotient), ah = 3 (reste)
mov eax, 1
mov ebx, 0
int 0x80
Avant d'effectuer une division, assurez-vous d'utiliser
mov edx, 0ouxor edx, edxVidez EDX ! Si EDX contient des données obsolètes, le dividende sera incorrect. C'est le bug de division le plus courant pour les débutants.
IDIV - Division signée
IDIVS'utilise pour la division signée. Avant d'effectuer une division, vous devez utiliserCDQinstruction pour étendre le signe de EAX vers EDX:EAX :
Exemple
; Calculer -100 / 3
mov eax, -100 ; eax = -100
cdq ; Extension de signe : edx:eax = -100
; cdq copie le bit de signe de eax vers tous les bits de edx
mov ebx, 3 ; Diviseur
idiv ebx ; eax = -33 (quotient), edx = -1 (reste)
; Vérifier : -100 = -33 × 3 + (-1)
ADC / SBB - Opérations avec retenue/emprunt
Utilisé pourl'arithmétique des grands nombres(données dépassant 32 bits) :
Exemple
; Addition 64 bits : ajout de deux nombres 64 bits
section .data
; nombre 64 bits a = 0x00000001 FFFFFFFF
a_low dd 0xFFFFFFFF
a_high dd 0x00000001
; nombre 64 bits b = 0x00000000 00000005
b_low dd 0x00000005
b_high dd 0x00000000
; Résultat
result_low dd 0
result_high dd 0
section .text
global _start
_start:
; Ajouter les 32 bits de poids faible
mov eax, [a_low]
add eax, [b_low] ; eax = 0xFFFFFFFF + 5 = 0x00000004
; CF = 1 (une retenue s'est produite !)
mov [result_low], eax ; result_low = 0x00000004
; Additionner les 32 bits de poids fort avec retenue
mov eax, [a_high]
adc eax, [b_high] ; adc = add + CF
; eax = 1 + 0 + 1(retenue) = 2
mov [result_high], eax ; result_high = 2
; Résultat final 64 bits : 0x00000002 00000004
; Vérification : 0x1FFFFFFF + 5 = 0x200000004
; La soustraction SBB est similaire (avec emprunt)
mov eax, [a_low]
sub eax, [b_low] ; Soustraire les 32 bits de poids faible
mov [result_low], eax
mov eax, [a_high]
sbb eax, [b_high] ; sbb = sub - CF
mov eax, 1
mov ebx, 0
int 0x80
Tableau de référence rapide des instructions arithmétiques
| Instruction | Format | Fonction | Drapeaux affectés |
|---|---|---|---|
| ADD | add dest, src | dest = dest + src | CF, ZF, SF, OF, PF |
| SUB | sub dest, src | dest = dest - src | CF, ZF, SF, OF, PF |
| INC | inc dest | dest = dest + 1 | ZF, SF, OF, PF (n'affecte pas CF) |
| DEC | dec dest | dest = dest - 1 | ZF, SF, OF, PF (n'affecte pas CF) |
| MUL | mul src | Multiplication non signée | CF, OF |
| IMUL | imul src | Multiplication signée | CF, OF |
| DIV | div src | Division non signée | Indéfini (indéterminé) |
| IDIV | idiv src | Division signée | Indéfini (indéterminé) |
| ADC | adc dest, src | dest = dest + src + CF | CF, ZF, SF, OF, PF |
| SBB | sbb dest, src | dest = dest - src - CF | CF, ZF, SF, OF, PF |
| NEG | neg dest | dest = -dest (inverser le signe) | CF, ZF, SF, OF, PF |