faculté pluridisciplinaire de nador

SIMUPROC

Réalisé par :
otfx

Année universitaire 2021/2022

Table des matières

1 Instructions de base 0
1.1 MSG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
1.2 LDT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
1.3 STA [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
1.4 LDA [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
1.5 EAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
1.6 HLT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
1.6.1 Remarque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
1.6.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
1.7 CLA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.8 XAB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.9 ADD [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.9.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.10 SUB [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.11 MUL [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.12 DIV [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.12.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.13 MOV [dest,orig] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.13.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 Instructions conditionnelles , répétitives et de controle 7

2.1 INC [dest] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 DEC [dest] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 LOOP [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.1 Les constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4 JMP [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.5 CMP [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6 JEQ [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.7 JNE [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.7.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.8 JME [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.9 JMA [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.9.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.10 JC [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.11 JNC [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.12 JO [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.13 JNO [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.14 Instructions de control de flags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.14.1 CLN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.14.2 CLC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.14.3 STC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.14.4 CMC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1
3 Nombres à virgule flottante 13
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.1.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2 IN [registre,port] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.3 OUT [port,registre] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.3.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.4 LDF [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.4.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.5 STF [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.6 ADDF [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.6.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.7 SUBF [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.8 MULF [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.9 DIVF [mem] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4 La pile 17
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.2 Instructions de pile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.2.1 PUSH [registre] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.2.2 POP [registre] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.2.3 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1 Instructions de base
1.1 MSG
Affiche un message , ex : MSG ’Hello World’.

1.2 LDT
Lire une valeur de clavier et l’amener au registre AX , ex : LDT ’Saisir la valeur de A : ’ .
Le registre AX est celui qui contient l’un des operandes qui realisent les operations logiques et arith-
metiques.

1.3 STA [mem]

Stocker le contenu de AX dans la memoire spécifiée , ex : STA 15 .

1.4 LDA [mem]

Charge dans AX le contenu de l’adresse mémoire spécifiée , ex : LDA 15 .

1.5 EAP
Affiche le contenu de AX.

1.6 HLT
Fin de programme , chaque programme doit contenir cette instruction pour indiquer au SimuProc
que l’exécution est terminée .

1.6.1 Remarque
On peut écrire un commentaire dans notre programme de cette façon (apres le symbole ;) :
;Cette phrase est un commentaire.

1.6.2 Exemple
Avec ces instructions on peut écrire notre premiers programmes :

Exercice 1 :
Réaliser un programme qui demande à l’utilisateur de saisir les valeurs de A et B et les afficher :

MSG ’Saisir les valeurs de A et B : ’

;Afficher ce message dans l’écran
LDT ’Saisir la valeur de A : ’
;lire de clavier A et l’amener à AX
STA 15
;stocker le contenu de AX dans l’adresse memoire 15
LDT ’Saisir la valeur de B : ’
;lire de clavier la valeur de B et l’amener à AX

0
EAP
;afficher le contenu de AX qui est B
LDA 15
;charger dans AX le contenu de l’adresse memoire 15 qui est A
EAP
;afficher le contenu de AX qui est A
HLT

Figure 1.1 – Exercice 1

1.7 CLA
Saisir 0 dans AX , AX=0.

1.8 XAB
Échanger les valeurs des registres AX et BX

1.9 ADD [mem]

L’addition :
AX=AX + Le contenu de la memoire spécifiée .
Si le resultat de l’operation dépasse 16 bits , ce résultat est divisé en stockant les bits les plus signifi-
catifs dans le registre BX et en AX les moins , ex :

1
Si le resultat égale 101101000111100010111 (21 bits) :
AX=1000111100010111
BX=10110
Et le Flag Overflow est également activé.
Avant de donner un exemple que signifie Flag ?
Registre de control(flags) :
Registre dans lequel sont déposés les conditions ou les résultats d’une certaine opération réalisée, chaque
bit de ce registre est utilisé pour stocker des informations spécifiques, appelées drapeaux(flags) :
Z : Indique que l’opération réalisée a donné un zéro si Z=1
N : Indique que le signe de l’opération réalisée est negatif si N=1
C : Carry Flag est utilisé pour indiquer qu’une retenue ou un emprunt arithmétique a été généré Si
C=1
O : Overflow Flag indique qu’un débordement arithmétique a eu lieu lors d’une opération si O=1

1.9.1 Exemple
Exercice 2
Réaliser un programme qui demande à l’utilisateur de saisir les valeurs de A et B et afficher A+B :

LDT ’Saisir la valeur de A: ’

STA 15
LDT ’Saisir la valeur de B: ’
ADD 15
;AX=AX+Le contenu de @15 qui est la valeur de A
EAP
HLT

2
 Figure 1.2 – Exercice 2

1.10 SUB [mem]

La soustraction :
AX=AX-Le contenu de la memoire spécifiée.

1.11 MUL [mem]

La multiplication :
AX=AX*Le contenu de la memoire spécifiée.
Si le resultat de l’operation dépasse 16 bits , ce résultat est divisé en stockant les bits les plus signifi-
catifs dans le registre BX et en AX les moins.

1.12 DIV [mem]

La division :
AX=AX/Le contenu de la memoire spécifiée.
Et BX=AX%Le contenu de la memoire spécifiée (On stocke le reste de la division dans BX).

1.12.1 Exemple
Exercice 3
Réaliser un programme qui calcule l’expression suivante : R=A−B/(C+D)+E∗F−G

3
LDT ’Saisir la valeur de C: ’
STA 20
;Stocker la valeur de C dans 20
LDT ’Saisir la valeur de D: ’
ADD 20
STA 21
;Stocker C+D dans 21
LDT ’Saisir la valeur de B: ’
DIV 21
STA 22
;Stocker B/(C+D) dans 22
LDT ’Saisir la valeur de A: ’
SUB 22
STA 23
;Stocker A-B/(C+D) dans 23
LDT ’Saisir la valeur de G: ’
STA 24
;Stocker G dans 24
LDT ’Saisir la valeur de E: ’
STA 25
;Stocker E dans 25
LDT ’Saisir la valeur de F: ’
MUL 25
SUB 24
ADD 23
EAP
HLT

4
 Figure 1.3 – Exercice 3

1.13 MOV [dest,orig]

Copier la valeur stockée dans l’origine en destination , l’origine et la destination peuvent etre des
registres ou adresses mémoires.

1.13.1 Exemple
Exercice 4
Refaire l’exercice 1 en utilisant MOV
MSG ’Saisir les valeurs de A et B: ’
LDT ’Saisir la valeur de A: ’
MOV 15,AX
;Stocker le contenu de AX dans @15

5
LDT ’Saisir la valeur de B: ’
EAP
MOV AX,15
;Charger le contenu de @15 dans AX (A)
EAP
HLT

6
2 Instructions conditionnelles , répétitives et de controle
2.1 INC [dest]
Incrémente la destination spécifiée de 1, le paramètre peut être une adresse mémoire ou un registre.

2.1.1 Exemple
CLA
;AX=0
INC AX
;Incrementer AX ->AX=1
EAP
;Afficher 1
HLT

2.2 DEC [dest]

Décrémente la destination spécifiée de 1, Si la destination reste = 0, alors Z = 1

2.2.1 Exemple
CLA
;AX=0
INC AX
;Incrementer AX++, Donc AX=1
DEC AX
;Decrement AX--,Donc AX=0 ,Alors Z=0
EAP
;Afficher 0
HLT

2.3 LOOP [mem]

Décrémente CX et saute à la mémoire spécifiée si CX !=0 .

2.3.1 Les constantes

Avant de donner un exemple de LOOP nous allons voir comment definir une constante.
Le principe est d’ecrire l’adresse memoire dont saisir notre constante de cette maniere après HLT :
#Adresse
Et de sauter une ligne et ecrire la valeur de notre constante en binaire ! !

7
 Exemple

MOV AX,21
;Charger dans AX le contenu de la constante stockée en @21 qui est 2 (10 en binaire)
EAP
;Afficher le contenu de AX
HLT

#21
10

Figure 2.1 – Exemple

2.3.2 Exemple
Exemple d’utilisation de LOOP
Exercice 4
Afficher "Hello world" 10 fois

MOV CX,21
;Charger Dans CX la constante @21 qui contient la valeur 9 (1001 en binaire)
MSG ’Hello world’
LOOP 1
;Sauter au adresse 1 qui contient MSG si CX!=0 et decrementer CX jusqu’à CX=0
HLT

#21
1010

8
 Figure 2.2 – Exercice 4

2.4 JMP [mem]

Saut inconditionnel. PC = adresse mémoire où se trouve la prochaine instruction à exécuter.
ex : JMP 21 : Sauter à l’adresse memoire 21 .

2.5 CMP [mem]

Comparer AX avec [contenu de mem], si AX est supérieur, Z=0 N=0, si égal Z=1 N=0, si inférieur
Z=0 N=1.

2.6 JEQ [mem]

Sauter à [mem] si Z=1 , après l’utilisation de CMP si le resultat est égal on aura Z=1.
Le principe est de sauter si il y a une égalité.

2.7 JNE [mem]

Sauter à [mem] si Z=0 , après l’utilisation de CMP si le resultat n’est pas égal on aura Z=0.
Le principe est de sauter si il n’y a pas une égalité.

2.7.1 Exemple
Exercice 5
Saisir A et B et verifier si sont égaux

9
LDT ’Saisir la valeur de A’
MOV 21,AX
LDT ’Saisir la valeur de B: ’
CMP 21
;Comparer le contenu de AX qui est B avec le contenu de @21 qui est A et retourner les Flags
JEQ 6
;Si Z=1 (sont égaux) sauter à @6
JNE 8
;Si Z=0 sauter à @8
MSG ’A et B son égaux’ ;l’adresse 6 dont il a sauté si Z=1
JMP 9
;Saut inconditionnel , Sauter à @9 qui est fin de programme
MSG ’A et B ne sont pas égaux’ ;L’adresse 8 dont il a sauté si Z=0
HLT ;Adresse 9

Figure 2.3 – Exercice 5

2.8 JME [mem]

Sauter à [mem] si N=1 ,après l’utilisation de CMP si le resultat est inférieur on aura N=1.
Le principe est de sauter si dans CMP [memA] , AX<[Contenu de memA].

2.9 JMA [mem]

Sauter à [mem] si Z=0 et N=0 ,après l’utilisation de CMP si le resultat est superieur on aura Z=0
et N=0.
Le principe est de sauter si dans CMP [memA] , AX>[Contenu de memA].

10
2.9.1 Exemple
Exercice 6
Saisir A et B et les comparer .

LDT ’Saisir la valeur de C: ’

MOV 18,AX
LDT ’Saisir la valeur de D: ’
CMP 18
;Comparer le contenu de AX avec le contenu de @18 (Les flags de control vont se modifier)
JMA 8
;Sauter à @8 si Z=0 et N=0 (si D>C , D etait en AX)
JEQ A
;Sauter à @A si Z=1 (égalité)
;si le programme est arrivé ici , c’est parce que D n’était ni superieur que C ni égal
MSG ’C>D’
JMP 11
;Saut inconditionnel au fin de programme
;Le programme est arrivé ici si D>C
MSG ’D>C’ ;Adresse 8
JMP 11
;Saut inconditionnel au fin de programme
;Le programme est arrivé ici si sont égaux
MSG ’C=D’ ;Adresse A
HLT ;Adresse 11

Figure 2.4 – Exercice 6

11
2.10 JC [mem]
Sauter à [mem] si C=1 (Carry Flag activé).
C=1 si on a une retenue.

2.11 JNC [mem]

Sauter à [mem] si C=0 (Carry flag non activé).

2.12 JO [mem]
Sauter à [mem] si O=1 (Overflow flag activé) .

2.13 JNO [mem]

Sauter à [mem] si O=0 (Overflow flag non activé).

2.14 Instructions de control de flags

2.14.1 CLN
Effacer le flag négatif. N = 0

2.14.2 CLC
Effacer le flag de Carry. C=0

2.14.3 STC
Activer Carry Flag . C=1

2.14.4 CMC
Inverser le flag de Carry , Si C=1 alors on aura C=0 et vice versa.

12
3 Nombres à virgule flottante
3.1 Introduction
Les nombres à virgule flottante sont représentés sou la norme IEE754, qui utilise 32 bits ; pour cela
dans SimuProc nous utilisons deux emplacements mémoire consécutifs avec les bits les plus significatifs
dans le premier.

3.1.1 Exemple
On a -5.6 de base 10 :
-5.6(10)=11000000101100110011001100110011 (2) de format IEE754 32 bits .
Donc les bits les plus significatifs (les premiers 16 bits à gauche ) : 1100000010110011 seront stockés
dans la premiere case memoire , et les moins significatifs 0011001100110011 dans la 2 éme .

;Apres HLT on peut definir les constantes

#10
1100000010110011 ;les bits les plus significatifs dans @10
0011001100110011 ;les moins significatifs dans @11
;Lors de definition d’une constante dans une adresse memoire , il suffit de sauter la ligne
pour ecrire dans l’adresse memoire suivante.

Donc on a stocker un nombre à virgule flottante dans @10 et @11,on va utiliser autres instuctions pour
gérer ces nombres :

3.2 IN [registre,port]
Le registre prend la valeur renvoyée par le port spécifié.
Cette instruction est utilisée pour que l’utilisateur pourra saisir des nombres à virgule flottante, L’ins-
truction LDT charge uniquement de clavier dans AX tant que pour les nombre à virgule flottante doit
charger dans AX et BX ; dans BX les bits plus significatifs et dans AX les moins.
pour le port on utilise 1 pour les nombres à virgule flottante.

3.2.1 Exemple
;Pour demander à l’utilisateur de stocker un nombre à virgule flottante :
IN AX,1
;Donc on a charger les bits moins significatifs dans AX , et les plus dans BX

3.3 OUT [port,registre]

Écrit sur le port spécifié, la valeur de registre.
Cette instruction est utilisé pour afficher un nombre à virgule flottante pour le port on utilise 1.

3.3.1 Exemple
IN AX,1
;Pour saisir un nombre à virgule flottante
OUT 1,AX
;Pour afficher ce nombre

13
3.4 LDF [mem]
Charge dans BX et AX un numéro 32 bits (IEEE) qui est stocké dans la dir [mem] et mem+1.
Dans BX sont stockées les bits les plus significatifs.

3.4.1 Exemple
Supposons que le nombre 100,25 (10) = 01000010110010001000000000000000 (2) IEEE est chargé
en mémoire comme ceci :
18 0100001011001000 (Les bits les plus significatifs (à gauche))
19 1000000000000000 (Les bits les moins significatifs)
Donc avec l’instruction LDF 18 on aura le resultat suivant :
BX : 0100001011001000
AX : 1000000000000000
Donc dans BX on a les plus significatifs et dans AX les moins

LDF 18
;Charger dans BX le contenu de @18 les plus significatifs et dans AX
le contenu de @19 les moins
OUT 1,AX
;Afficher le nombre
HLT
#18
0100001011001000
1000000000000000

Figure 3.1 – Exemple

14
3.5 STF [mem]
Enregistrer en [mem] et mem+1 le contenu de BX et AX .
étant AX et BX = à l’exemple précédent, un STF 20 charge dans l’adresse 20 BX (les plus significatifs)
et dans l’adresse 21 AX (les moins significatifs).

3.6 ADDF [mem]

Additionner des nombres de 32 bits : Dans BX et AX reste le résultat de l’addition de ceux-ci plus
le contenu de [mem] et mem+1 . Ces instructions sont utilisées aussi pour les nombres negatifs.

3.6.1 Exemple
Addition de 2 nombre à virgule flottante.

MSG ’Saisir la valeur de A: ’

IN AX,1
;Pour saisir le nombre A , dans AX on a les bits moins significatifs
STF 20
;Pour stocker BX dans @20 et AX dans @21
MSG ’Saisir la valeur de B: ’
IN AX,1
ADDF 20
;Pour l’addition de A+B , Donc dans BX=BX+[contenu de @20] , AX=AX+[contenu de @21]
OUT 1,AX
;Afficher le resultat
HLT

Figure 3.2 – Exemple

15
3.7 SUBF [mem]
Soustraire le nombre 32 bits : BX et AX = BX et AX - [mem] et mem+1 .
On peut utiliser cette instruction aussi pour la comparaison de nombre de 32 bits.

3.8 MULF [mem]

La Multiplication :
BX et AX = BX et AX * [mem] et mem+1 .
Si le résultat est > 2147483647, résultat = 2147483647 et flag de Overflow = 1.

3.9 DIVF [mem]

La division :
BX et AX = BX et AX / [mem] et mem+1, dans CX le reste de la division reste sous forme d’entier
16 bits.

16
4 La pile
4.1 Introduction
La pile est simplement un ensemble de données qui est stocké dans une zone de la mémoire princi-
pale, et dans lequel les données sont enregistrées de manière LIFO, Last In, First Out (Dernier entré,
premier sorti).
Sa utilisation principale est de stocker des données, de contrôler le programme, de passer des variables
entre fonctions et de stocker des variables locales. Le programmeur est le responsable de réserver l’es-
pace approprié pour la pile.

Dans simuproc on a deux registres pour gérer la pile :

BP : Registre de base de pile qui contient l’adresse memoire dont stocker la premiere donnée dans la
pile, par défaut BP contient F80 , on peut changer le contenu de BP par : MOV BP,[adresse] .
SP : Pointeur de la pile , qui pointe sur l’adresse dont empiler(push) ou dépiler(pop)

4.2 Instructions de pile

4.2.1 PUSH [registre]
Pour empiler ; renvoie la valeur de registre spécifié à la pile , ex : PUSH AX : Renvoie le contenu
de AX à la pile.

4.2.2 POP [registre]

Pour dépiler ; enlever le dernier élément de la pile et le charger dans le registre spécifié , ex : PUSH
AX : Enleve le dernier de la pile et le charger dans AX .

4.2.3 Exemple
Ecrire un programme qui empiler et depile .

MOV AX,20
;Charger dans AX le contenu de @20 qui est 2
PUSH AX
;Empiler le contenu de AX , la charger dans F80 la base de pile et le pointeur SP s’incremente
MOV AX,21
;Charger dans AX le contenu de @21
PUSH AX
;Empiler le contenu de AX , la charger dans la memoire qui pointe SP F81 et incrementer SP
MOV AX,22
;Charger dans AX le contenu de @22
PUSH AX
;Empiler le contenu de AX , la charger dans F82 et incrementer SP
POP AX
;Dépiler et enlever la derniere valeur de pile qui est 4 et la charger dans AX et SP decremente
EAP
;Afficher AX
POP AX
;Dépiler et enlever la derniere valeur de pile qui est 3 et la charger dans AX et SP decremente
EAP

17
;Afficher AX
POP AX
;Dépiler et charger dans AX et decrement le pointeur SP
EAP
;Afficher AX
HLT

#20
10 ;2
11 ;3
100 ;4

Remarque
Pour voir comment s’empile et dépile il suffir d’executer ce code dans SimuProc .

Figure 4.1 – Exemple

18