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

; Chemin du fichier : add_demo.asm
; 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

; Chemin du fichier : sub_demo.asm
; 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

; exemple avec INC et DEC

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érandeMultiplicateurMultiplicande (implicite)Stockage du résultat
1 octetTout registre ou mémoire de 8 bitsALAX = AL × opérande
2 octetsN'importe quel registre 16 bits ou mémoireAXDX:AX = AX × opérande
4 octetsN'importe quel registre 32 bits ou mémoireEAXEDX:EAX = EAX × opérande

Exemple

; Chemin du fichier : mul_demo.asm
; 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

; Chemin du fichier : imul_demo.asm
; 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 diviseurDividende (implicite)QuotientReste
1 octetAXALAH
2 octetsDX:AXAXDX
4 octetsEDX:EAXEAXEDX

Exemple

; Chemin du fichier : div_demo.asm
; 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'utilisermov 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

; Exemple de division signée IDIV

    ; 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

; Chemin du fichier : adc_sbb_demo.asm
; 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

InstructionFormatFonctionDrapeaux affectés
ADDadd dest, srcdest = dest + srcCF, ZF, SF, OF, PF
SUBsub dest, srcdest = dest - srcCF, ZF, SF, OF, PF
INCinc destdest = dest + 1ZF, SF, OF, PF (n'affecte pas CF)
DECdec destdest = dest - 1ZF, SF, OF, PF (n'affecte pas CF)
MULmul srcMultiplication non signéeCF, OF
IMULimul srcMultiplication signéeCF, OF
DIVdiv srcDivision non signéeIndéfini (indéterminé)
IDIVidiv srcDivision signéeIndéfini (indéterminé)
ADCadc dest, srcdest = dest + src + CFCF, ZF, SF, OF, PF
SBBsbb dest, srcdest = dest - src - CFCF, ZF, SF, OF, PF
NEGneg destdest = -dest (inverser le signe)CF, ZF, SF, OF, PF
Autres extensions