Utilisation des sauts conditionnels avec CMP

Les sauts conditionnels permettent de réaliser des actions répétitives ou conditionnelles, comme dans les boucles, les tests et les branchements logiques.

Une boucle se divise généralement en deux parties :

1. La partie qui exécute une action

2. La partie qui teste si l’action doit continuer

Exemple simple d’une boucle

• Ici, CMP AX,12 met à jour les flags selon la valeur de AX.

• JE Fin saute vers l’étiquette Fin si ZF = 1 (AX = 12).

• Le JMP Boucle relance la boucle tant que AX ≠ 12.

Version optimisée

• Avec cette version, une instruction JMP est supprimée, ce qui rend le code plus rapide et lisible.

• Vous pouvez remplacer JNE par n’importe quel saut conditionnel selon le flag approprié (CF, SF, ZF…).

• Plusieurs CMP ou boucles peuvent être imbriquées pour créer des programmes plus complexes.

Instructions mathématiques

L’assembleur offre des instructions pour toutes les opérations arithmétiques, signées ou non signées.

Multiplication – MUL et IMUL

• MUL : multiplication non signée

• IMUL : multiplication signée

Règles :

• L’opérande source se trouve dans un registre (BX, CX…)

• Le registre AX contient le nombre à multiplier

• Résultat : AX ← AX * source

Exemple non signé :

Exemple signé :

• Pour IMUL sur 16 bits, utilisez CWD pour étendre le signe dans DX si nécessaire :

• Pour les multiplications non signées, assurez-vous que DX = 0 avant MUL.

Division – DIV et IDIV

• DIV : division non signée

• IDIV : division signée

• Divise le contenu de AX (ou DX:AX pour 32 bits) par la source.

• Résultat : AX ← quotient, DX ← reste

Exemple :

Attention : la division par zéro provoque une erreur et retourne au DOS.

Décalages – SHR et SHL

• SHR : shift right → divise par une puissance de 2

• SHL : shift left → multiplie par une puissance de 2

Exemples :

• On peut combiner plusieurs décalages pour multiplier par un nombre non puissance de 2 :

• Cette méthode est rapide mais parfois plus complexe que MUL.

Changement de signe – NEG

• NEG inverse le signe d’un registre ou d’une variable mémoire :

Nombres à virgule fixe

• L’assembleur ne gère pas directement les nombres à virgule dans les registres (sans coprocesseur).

• On utilise des nombres entiers représentatifs avec un facteur fixe (ex. 256) :

Exemple : multiplier 300 par 0.5

• Plus le facteur de conversion est grand, plus le calcul est précis.

• Attention aux dépassements et aux nombres signés.

Résumé pratique

• Boucles → CMP + saut conditionnel (JNE, JE, JA, etc.)

• Multiplications → MUL / IMUL

• Divisions → DIV / IDIV

• Décalages rapides → SHL / SHR

• Changement de signe → NEG

• Nombres à virgule fixe → multiplier puis décaler avec SHR/SHL

Ces instructions forment la base pour toutes les opérations arithmétiques et le contrôle du flux en assembleur.