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
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.
| Instruction | Signification | Drapeaux vérifiés | Scénario applicable |
|---|---|---|---|
| JE / JZ | Sauter si égal / zéro | ZF = 1 | cmp a, bVérifier a == b après CMP |
| JNE / JNZ | Sauter si différent / non zéro | ZF = 0 | cmp a, bVérifier a != b après CMP |
| JG / JNLE | Sauter si supérieur (signé) | ZF=0 et SF=OF | Nombres signés a > b |
| JGE / JNL | Sauter si supérieur ou égal (signé) | SF = OF | Nombres signés a >= b |
| JL / JNGE | Sauter si inférieur (signé) | SF != OF | Nombres signés a < b |
| JLE / JNG | Sauter si inférieur ou égal (signé) | ZF=1 ou SF!=OF | Nombres signés a <= b |
| JA / JNBE | Sauter si supérieur (non signé) | CF=0 et ZF=0 | Nombres non signés a > b |
| JAE / JNB | Sauter si supérieur ou égal (non signé) | CF = 0 | Nombres non signés a >= b |
| JB / JNAE | Saut si inférieur (non signé) | CF = 1 | Nombres non signés a < b |
| JBE / JNA | Saut si inférieur ou égal (non signé) | CF=1 ou ZF=1 | Nombres 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
; 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
; 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
; 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
; 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
; 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
; 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
Autres extensionsLes 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é.