Copy Link
Add to Bookmark
Report
Tutorial Assembleur - Chapitre 04
TUTORIAL ASSEMBLEUR - chapitre 4
--------------------------------
Les flags - Les sauts conditionnels - CMP
-----------------------------------------
Poursuivons notre parcours dans le monde de la programmation en assembleur par les notions
qui suivent.
Les flags - Les indicateurs
---------------------------
Les flags, "indicateurs", sont des bits qui donnent certaines informations. Ils sont regroupés
dans le registre de flag. Ces flags sont modifiés en fonction de l'exécution des différentes
instructions. Celles-ci changent la valeur des flags selon le résultat obtenu. Voici une
liste des différents flags et leur utilité. Les bits marqués du 1 ou du 0 ne sont pas
utilisés.
Bit 1 : CF
Bit 2 : 1
Bit 3 : PF
Bit 4 : 0
Bit 5 : AF
Bit 6 : 0
Bit 7 : ZF
Bit 8 : SF
Bit 9 : TF
Bit 10 : IF
Bit 11 : DF
Bit 12 : OF
Bit 13 : IOPL
Bit 14 : NT
Bit 15 : 0
Bit 16 : RF
Bit 17 : VM
Nous n'étudierons que les 12 premiers, ce sont les plus importants.
------------------------------------------------------------------------------------------------
CF
Nous avons tout d'abord CF (Carry Flag). C'est le flag dit de retenue.
Dans les opérations mathématiques, il arrive que le résultat de l'opération soit codé sur
un nombre supérieur de bits. Le bit en trop est placé dans CF. De nombreuses instructions
modifient aussi CF. Par exemple, les instructions CLC et CMC, la première mettant
à zéro CF et la deuxième qui inverse la valeur de CF. STC (set carry) met le flag à 1.
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
PF
Le deuxième flag ne se modifiant pas, nous passons au troisième qui est PF. Il s'agit du
Parity Flag. La valeur de ce flag est 1 si le nombre de bits d'une opérande
(paramètre d'une instruction) est pair.
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
AF
AF est l'auxiliary carry qui ressemble à CF.
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
ZF
Il s'agit du Zero Flag qui est misà un lorsque un résultat est égal à 0. Souvent utilisé pour
les diverses opérations, il est utile pour éviter des problèmes de divisions
(je vous rappelle que diviser par zéro est impossible).
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
SF
SF signifie Signe Flag. Simplement, sa valeur passe à 1 si nous avons un résultat
signé (négatif ou positif).
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
IF
IF pour Interrupt Flag, enlève la possibilité au processeur de contrôler les interruptions.
Si IF=0, le processeur ne commande pas et si IF=1 alors c'est le contraire.
L'instruction STI provoque IF=1 et CLI met IF=0.
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
DF
Le flag DF est le Direction Flag. C'est ce Flag qui donne l'indication sur la manière
de déplacer les pointeurs (références) lors des instructions de chaînes (soit positiviment,
soit négativement).
Deux instructions lui sont associées, il s'agit de CLD et STD.
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
OF
OF est l'Overflow Flag (indicateur de dépassement). Il permet de trouver et de corriger
certaines erreurs produites par des instructions mathématiques. Très utile pour éviter les
plantages. Si OF=1 alors nous avons affaire à un Overflow. Il existe une
instruction qui s'occupe de ce Flag, c'est INTO qui déclenche l'execution du code qui
se trouve à l'adresse 0000:0010 (interruption 4).
------------------------------------------------------------------------------------------------
C'en est tout pour les flags, vous comprendrez leur utilité au fur et à mesure de votre
progression mais passons aux instructions conditionnelles qui leur sont directement
associées.
Les instructions conditionnelles
--------------------------------
Nous abordons une partie qui est nécessaire lors de la création d'un programme. Souvent,
le programme doit faire une action selon la valeur d'un résultat. Les instructions
conditionnelles comme leur nom l'indique, sont des instructions qui font une action
selon un résultat. Elles se basent sur les flags pour faire leur choix.
Vous vous souvenez de l'instruction JMP, il s'agissait d'un simple saut vers une
autre partie du programme. D'autres instructions comme JMP font des sauts mais selon
certains critères, on les appelle des sauts conditionnels. Voici la liste des ces
instructions avec la valeur de l'indicateur nécessaire à l'exécution.
------------------------------------------------------------------------------------------------
JB - JNAE - JC
Below - Not Above or Equal - Carry
CF = 1
JAE - JNB - JNC
Above or Equal - Not Below - Not Carry
CF=0
JE - JZ
Equal - Zero
ZF=1
JNE - JNZ
Not Equal - Not Zero
ZF=0
JO - JNO
Overflow - Not Overflow
OF=1 - OF=0
JP - JPE
Parity - Parity Even
PF=1
JNP - JPO
No Parity - Parity Odd
PF=0
JS - JNS
Signed - Not Signed
SF=1 - SF=0
JA - JNBE
Above - Not Below or Equal
CF=0 et ZF=0
JBE - JNA
Below or Equal - Not Above
CF=1 ou ZF=1
JG - JNLE
Greater - Not Less or Equal
ZF=0 et SF=OF
JGE - JNL
Greater or Equal - Not Less
SF=OF
JL - JNGE
Less - Not Greater or Equal
SF (signé)=OF
JLE - JNG
Less or Equal - Not Greater
ZF=1 ou SF (signé)=OF
------------------------------------------------------------------------------------------------
Pour tester tout cela, nous avons besoin d'une instruction, c'est CMP qui nous aidera
à le faire.
L'instruction CMP
-----------------
Cette instruction va nous servir à tester différentes valeurs et modifier les flags en
fonction du résultat. CMP est un SUB qui ne change ni la source ni la destination, seulement
les flags. Un CMP BX,CX sera comme un SUB BX,CX à l'excéption près que BX ne sera pas modifié.
Si BX=CX alors BX-CX=0 donc le flag ZF sera égal à 1. Si nous voulons faire un saut
avec "égal à" (JNE ou JZ qui demande ZF=1), nous avons ZF=1 et comme
JZ demande que ZF=1 pour faire le saut, nous avons donc le saut. Souvenez-vous simplement
que la plupart du temps, il s'agit de comparaisons du genre :
effectue le saut :
plus grand que (nombres non-signés) ---> JA
plus petit que (nombres non-signés) ---> JB
plus grand que (nombres signés) -------> JG
plus petit que (nombres signés) -------> JL
égal à (signé et non-signé) -----------> JE ou parfois JZ
il suffit de rajouter un 'n' après le 'j' pour avoir la même instruction mais exprimée
de facon négative
ne saute pas si :
plus grand que (nombres non-signés) ---> JNA (jump if _not above_)
...et ainsi de suite.
### Chapitre 4 - dake / c a l o d o x ###
### http://www.space.ch/scene/calodox ###
