Langage assembleur - Jugement conditionnel

Le jugement conditionnel est la pierre angulaire du flux de contrôle d'un programme. Le langage assembleur implémente une logique de jugement telle que if-else, switch, etc., au moyen d'instructions de comparaison et d'instructions de saut conditionnel.


CMP - Instruction de comparaison

CMPEffectue une opération de soustraction sur deux opérandes (destination - source), mais ne sauvegarde pas le résultat, met uniquement à jour les indicateurs.

EssentiellementCMP dest, srcÉquivalent àSUB dest, srcMais abandonne le résultat du calcul.

Exemple

; exemple d'instruction de comparaison CMP

section .text
    global _start

_start:
    mov eax, 10
    cmp eax, 10                 ; eax == 10?
    ; ZF = 1 (égal, le résultat est zéro)
    ; CF = 0 (pas d'emprunt)
    ; SF = 0 (résultat non négatif)

    mov eax, 5
    cmp eax, 10                 ; eax == 10?
    ; ZF = 0 (non égal, résultat non nul)
    ; CF = 1 (emprunt : 5 < 10)

    mov eax, 20
    cmp eax, 10                 ; eax == 10?
    ; ZF = 0 (non égal)
    ; CF = 0 (pas d'emprunt : 20 >= 10)
    ; SF = 0 (résultat non négatif : 10 > 0)

    mov eax, 1
    mov ebx, 0
    int 0x80

Instructions de saut conditionnel

Les instructions de saut conditionnel déterminent s'il faut sauter en fonction de l'état des drapeaux. Si la condition est vraie, sauter vers l'étiquette cible ; sinon, continuer l'exécution de l'instruction suivante.

InstructionSignificationDrapeaux vérifiésScénario applicable
JE / JZSauter si égal / zéroZF = 1cmp a, bVérifier a == b après CMP
JNE / JNZSauter si différent / non zéroZF = 0cmp a, bVérifier a != b après CMP
JG / JNLESauter si supérieur (signé)ZF=0 et SF=OFNombres signés a > b
JGE / JNLSauter si supérieur ou égal (signé)SF = OFNombres signés a >= b
JL / JNGESauter si inférieur (signé)SF != OFNombres signés a < b
JLE / JNGSauter si inférieur ou égal (signé)ZF=1 ou SF!=OFNombres signés a <= b
JA / JNBESauter si supérieur (non signé)CF=0 et ZF=0Nombres non signés a > b
JAE / JNBSauter si supérieur ou égal (non signé)CF = 0Nombres non signés a >= b
JB / JNAESaut si inférieur (non signé)CF = 1Nombres non signés a < b
JBE / JNASaut si inférieur ou égal (non signé)CF=1 ou ZF=1Nombres non signés a <= b

De nombreuses instructions possèdent deux alias (comme JE et JZ), qui sont exactement identiques au niveau du code machine. Le choix de l'un ou de l'autre dépend du contexte : utilisez JE/JNE après des comparaisons, et JZ/JNZ après la vérification des résultats d'opérations. Cela améliore la lisibilité du code.


Structure IF à une seule branche

Exemple

; File path: if_demo.asm
; Implémentation : if (x > 10) x = 10;

section .data
    x dd 15                     ; Valeur de test
    limit dd 10

section .text
    global _start

_start:
    mov eax, [x]                ; Charger x dans eax
    cmp eax, [limit]            ; x > 10 ?
    jle skip_update             ; Si x <= 10, sauter la mise à jour

    mov dword [x], 10           ; x = 10

skip_update:
    ; Le programme continue... (ici x est déjà 10)

    mov eax, 1
    mov ebx, 0
    int 0x80

Structure à double branche IF-ELSE

Exemple

; Chemin du fichier : if_else_demo.asm
; Implémentation : if (score >= 60) grade = 'P' else grade = 'F'

section .data
    score dd 75                 ; Score d'examen
    grade db 0                  ; Note
    PASS_SCORE equ 60

section .text
    global _start

_start:
    mov eax, [score]            ; Charger le score
    cmp eax, PASS_SCORE         ; score >= 60 ?
    jge pass_label              ; Si >= 60, sauter à pass

    ; branche else : échec
    mov byte [grade], 'F'       ; grade = 'F'
    jmp end_if                  ; ignorer la branche if

pass_label:
    ; branche if : pass
    mov byte [grade], 'P'       ; grade = 'P'

end_if:
    ; la variable grade est maintenant définie

    ; afficher grade
    mov eax, 4
    mov ebx, 1
    mov ecx, grade
    mov edx, 1
    int 0x80

    mov eax, 1
    mov ebx, 0
    int 0x80

Résultat de l'exécution :

$ nasm -f elf32 if_else_demo.asm -o if_else_demo.o
$ ld -m elf_i386 if_else_demo.o -o if_else_demo
$ ./if_else_demo
P

Structure multi-branches IF-ELSE IF-ELSE

Ci-dessous, un système de notation par score est utilisé comme exemple pour montrer le déroulement d'une décision multi-branches :

条件判断多分支流程图

Exemple

; Chemin du fichier : multi_branch.asm
; Notation par score : >=90 -> A, >=80 -> B, >=70 -> C, >=60 -> D, <60 -> F

section .data
    score dd 85
    result db 0
    newline db 0xA

section .text
    global _start

_start:
    mov eax, [score]            ; Charger le score

    ; Vérifier >= 90
    cmp eax, 90
    jl check_80                 ; Si < 90, continuer la vérification
    mov byte [result], 'A'
    jmp print_result

check_80:
    cmp eax, 80
    jl check_70
    mov byte [result], 'B'
    jmp print_result

check_70:
    cmp eax, 70
    jl check_60
    mov byte [result], 'C'
    jmp print_result

check_60:
    cmp eax, 60
    jl fail_label
    mov byte [result], 'D'
    jmp print_result

fail_label:
    mov byte [result], 'F'

print_result:
    ; Afficher la note
    mov eax, 4
    mov ebx, 1
    mov ecx, result
    mov edx, 1
    int 0x80

    ; Afficher un saut de ligne
    mov eax, 4
    mov ebx, 1
    mov ecx, newline
    mov edx, 1
    int 0x80

    mov eax, 1
    mov ebx, 0
    int 0x80

TEST - Instruction de test non destructive

TESTEffectue un AND bit à bit mais ne sauvegarde pas le résultat, met uniquement à jour les drapeaux.

TESTSouvent utilisé pour vérifier si un bit spécifique vaut 1, ou si un registre vaut 0.

Exemple

; Exemple d'instruction TEST

    ; Vérifier si eax est 0 (plus efficace que CMP eax, 0)
    test eax, eax               ; eax & eax = eax, ne met à jour que ZF
    jz  eax_is_zero             ; Si ZF=1, alors eax=0

    ; Vérifier un bit spécifique
    test al, 0x01               ; Vérifier si bit0 est 1
    jnz bit0_is_set             ; Si bit0=1, sauter

    ; Vérifier plusieurs bits
    test al, 0x03               ; Vérifier si au moins l'un de bit0 et bit1 vaut 1
    jnz some_bit_set

SETcc - Instruction d'affectation conditionnelle

Au lieu de sauter, met l'octet de destination à 1 ou 0 selon la condition :

Exemple

; Exemple d'affectation conditionnelle avec SETcc

    ; Stocker le résultat de a > b dans al
    mov eax, 10
    cmp eax, 5                  ; 10 > 5 ?
    setg al                     ; al = 1 (la condition « supérieur à » est vraie)
    ; Si eax = 3, alors al = 0

    ; Autres instructions SETcc :
    ; sete / setz -> égal/zéro
    ; setne / setnz -> différent / non nul
    ; setl -> inférieur à (signé)
    ; setb -> inférieur à (non signé)
    ; setg -> supérieur à (signé)
    ; seta -> supérieur à (non signé)

Exemple complet : déterminer pair/impair et positif/négatif

Exemple

; Chemin du fichier : number_check.asm
; Déterminer si le nombre est pair/impair, positif/négatif

section .data
    number dd -42
    msg_even db 'Even', 0xA
    msg_even_len equ $ - msg_even
    msg_odd db 'Odd', 0xA
    msg_odd_len equ $ - msg_odd
    msg_pos db 'Positif', 0xA
    msg_pos_len equ $ - msg_pos
    msg_neg db 'Négatif', 0xA
    msg_neg_len equ $ - msg_neg
    msg_zero db 'Zéro', 0xA
    msg_zero_len equ $ - msg_zero

section .text
    global _start

_start:
    mov eax, [number]

    ; Vérifier si zéro
    cmp eax, 0
    jne check_sign
    ; est zéro
    mov eax, 4
    mov ebx, 1
    mov ecx, msg_zero
    mov edx, msg_zero_len
    int 0x80
    jmp exit

check_sign:
    ; Vérifier positif/négatif
    cmp eax, 0
    jg  is_positive             ; eax > 0

    ; négatif
    mov eax, 4
    mov ebx, 1
    mov ecx, msg_neg
    mov edx, msg_neg_len
    int 0x80
    jmp check_parity

is_positive:
    ; positif
    mov eax, 4
    mov ebx, 1
    mov ecx, msg_pos
    mov edx, msg_pos_len
    int 0x80

check_parity:
    ; Déterminer impair/pair (il suffit de vérifier le bit de poids faible)
    mov eax, [number]
    test eax, 1                 ; Vérifier le bit0
    jnz is_odd

    ; pair
    mov eax, 4
    mov ebx, 1
    mov ecx, msg_even
    mov edx, msg_even_len
    int 0x80
    jmp exit

is_odd:
    ; impair
    mov eax, 4
    mov ebx, 1
    mov ecx, msg_odd
    mov edx, msg_odd_len
    int 0x80

exit:
    mov eax, 1
    mov ebx, 0
    int 0x80

Les instructions de saut conditionnel ne peuvent sauter que vers des étiquettes situées dans le segment de code courant ; la portée du saut est généralement limitée d'environ 128 bytes (saut court) à 2GB (saut proche). NASM sélectionne automatiquement l'encodage de saut approprié.

Autres extensions