Guide explicatif sur le chapitre 7 des notes de cours de
GABRINI, Ph. -- Organisation des ordinateurs et assembleur.
Chapitre 7. Instructions du processeur PEP8
7.1 Format des instructions
Page 57.
Voir la documentation spécifique sur les codes-machine.
Champs de spécification des instructions:
| aaa |
Mode
d’adressage aaa |
a |
Mode
d’adressage a |
r |
Registre r |
| 000 |
Immédiat (I) |
0 |
Immédiat |
0 |
Accumulateur A |
| 001 |
Direct (D) |
1 |
Indexé |
1 |
Registre index X |
| 010 |
Indirect (N) |
|
|
|
|
| 011 |
Pile (S) |
|
|
|
|
| 100 |
Pile indirect (SF) |
|
|
|
|
| 101 |
Indexé (X) |
|
|
|
|
| 110 |
Indexé pile (SX) |
|
|
|
|
| 111 |
Indexé pile indirect (SXF) |
|
|
|
|
7.2 Instructions unaires simples
Page 58.
Ces instructions n'occupent qu'un seul octet et
n'affectent pas les témoins.
Instruction STOP
L’instruction STOP a un code opération nul. Lorsque cette
instruction est exécutée, il y a arrêt de
l’exécution du programme et retour au système qui l’avait lancée, dans le cas de
PEP 8 au simulateur,
mais dans le cas d’un processeur réel au système d’exploitation.
Instruction RETTR
Cette instruction indique un retour en fin de traitement d’une
interruption (return from trap); le
contexte du programme interrompu est rétabli et le programme interrompu reprend
(voir chapitre 12).
Instruction MOVSPA
Cette instruction copie la valeur du pointeur de pile (stack
pointer SP) dans le registre A (voir chapitre 9).
Instruction MOVFLGA
Cette instruction copie la valeur des codes de condition NZVC
dans le registre A, les 4 bits étant
précédés de 12 bits nuls.
Par exemple :
LDA 0xC234,i ; A = C234 Témoins N=1 Z=0 V=? C=?
ADDA 1,i ; A = C233 Témoins N=1 Z=0 V=0 C=0
MOVFLGA ; A = 0008
7.3 Instructions de chargement et rangement
Page 58.
Instruction LDr
Voir la documentation spécifique sur
le chargement LOAD/LOADBYTE.
2 octets sont obtenus de la mémoire et placés dans le registre A
ou X et les témoins N et Z sont affectés.
Instruction STr
L’instruction de rangement place deux octets en mémoire à partir
du registre spécifié.
Les témoins ne sont pas affectés.
Instruction LDBYTEr
Cette instruction charge la moitié droite du registre d’une
valeur de 8 bits, laquelle est soit située dans
l’instruction, soit située en mémoire. Faites attention que la moitié gauche du
registre demeure
inchangée. Les témoins N et Z sont affectés suite au contenu FINAL du registre.
Instruction STBYTEr
L’instruction de rangement place un octet en mémoire à partir de
la moitié droite du registre spécifié.
Les témoins ne sont pas affectés.
7.4 Instructions arithmétiques
Page 59.
Instruction ADDr
Cette instruction obtient l’opérande et l’additionne au contenu
du registre qui est le seul modifié.
Les 4 témoins N, Z, V et C sont affectés.
Voir les exemples complets: Instructions et directives:
additions et soustractions
Instruction SUBr
Cette instruction obtient l’opérande et le soustrait du contenu du registre
qui est le seul modifié.
Les 4 témoins N, Z, V et C sont affectés.
Instruction NEGr
Cette instruction unaire (sans opérande) interprète le contenu
du registre comme un entier
en complément à deux et en fait la négation. Les 4 témoins N, Z, V et C sont
affectés.
Le code de condition V n’est touché que si la valeur originale est –32768,
puisqu’il n’existe pas de valeur positive
+32768 dans l’arithmétique en complément à deux sur 16 bits.
Instruction ADDSP
Cette instruction ajoute une valeur au contenu du pointeur de
pile; si la valeur est positive, le sommet
de la pile est déplacé vers le bas, ce qui correspond à un désempilage.
Les 4 témoins N, Z, V et C sont affectés.
Instruction SUBSP
Cette instruction ajoute une valeur au contenu du pointeur de
pile; si la valeur est positive, le sommet
de la pile est déplacé vers le haut, ce qui correspond à un empilage.
Les 4 témoins N, Z, V et C sont affectés.
exemple: la multiplication inverse les signes si le
multiplicande est négatif: prog74.txt
; Multiplication de deux nombres entiers par la méthode simple.
; Lorne H. Bouchard (adapté par Ph. Gabrini Mars 2006)
;
debut: DECI nb1,d ; cin >> nb1;
DECI nb2,d ; cin >> nb2;
DECO nb1,d ; cout << nb1
CHARO '*',i ; << '*'
DECO nb2,d ; << nb2
CHARO '=',i ; << '=';
LDX nb2,d ; X = nb2
BRGE commence ; if(nb2 < 0){
LDA nb1,d ;
NEGA ;
STA nb1,d ; A = nb1 = -nb1;
LDX nb2,d ;
NEGX ; X = nb2 = -nb2;
STX nb2,d ; }
commence:LDA 0,i ; A = 0;
addition:ADDA nb1,d ; do{ A += nb1;
SUBX 1,i ; X--;
BRNE addition ; } while(X != 0);
fini: STA res,d ; res = A;
DECO res,d ; cout << res;
STOP ;
nb1: .WORD 0
nb2: .WORD 0
res: .WORD 0
.END
7.5 Instructions d’entrée-sortie
Page 61.
Instruction CHARI
Cette instruction lit un caractère en entrée et le range dans un
octet en mémoire. Les registres et les
codes de condition ne sont pas affectés. Le mode d’adressage immédiat n’est pas
autorisé.
Instruction CHARO
Cette instruction affiche un caractère
au terminal.
Les registres et les codes de condition ne
sont pas affectés.
Instruction STRO
Cette instruction affiche une chaîne de caractères au terminal.
Le dernier caractère de la séquence de caractères à sortir doit être un
caractère dont le code est nul
Les registres et les codes de condition ne sont pas affectés.
Seuls les modes d’adressage direct, indirect et indirect pile sont permis.
Instruction DECI
Cette instruction lit une valeur entière au terminal. Elle
permet un nombre quelconque d’espaces ou
de sauts de ligne avant le début de la valeur à lire qui doit débuter par un
signe plus, un signe moins ou
un chiffre décimal; le reste de la valeur est fait de chiffres décimaux.
Les témoins N, Z et V sont affectés.
Instruction DECO
Cette instruction affiche une valeur décimale au terminal. La
valeur est précédée d’un signe moins si elle est négative;
elle n’est pas précédée d’un signe plus si elle est positive et n’est pas
précédée de zéros de tête.
Elle est affichée avec le nombre minimum de caractères. Les registres et les
codes de condition ne sont pas affectés.
7.6 Instructions logiques
Page 62.
Instruction NOTr
Cette instruction unaire effectue une opération de négation
logique sur le contenu du registre. Tous les 16
bits sont inversés. L’instruction affecte les codes de condition N et Z.
Par exemple :
LDA 0x3F4A,i ; A = 3F4A NZVC=0000
en binaire 0011 1111 0100 1010
NOTA ; A = C0B5 NZVC=1000 en
binaire 1100 0000 1011 0101
Voir les exemples complets:
Instructions et directives:
logiques de négativité
Instruction ANDr
Cette instruction effectue une opération ET logique bit à bit
sur les 16 bits du registre et de l’opérande.
Elle affecte les témoins N et Z.
Par exemple :
LDA 0xC0B5,i ; A = C0B5 NZVC=1000
1100 0000 1011 0101
ET 0011 1111 0100 1010
---- ---- ---- ----
0000 0000 0000 0000
ANDA 0x3F4A,i ; A = 0000 NZVC=0100
Voir les exemples complets:
Instructions et directives:
ET logique
Instruction ORr
Cette instruction effectue une opération OU logique bit à bit
sur les 16 bits du registre et de l’opérande.
Elle affecte les témoins N et Z.
Par exemple :
LDA 0xC0B5,i ; A = C0B5 NZVC=1000
1100 0000 1011 0101
OU 0011 1111 0100 1010
---- ---- ---- ----
1111 1111 1111 1111
ORA 0x3F4A,i ; A = FFFF NZVC=1000
Voir les exemples complets:
Instructions et directives:
OU logique
Instruction ASLr
L’instruction ASLr effectue un décalage à gauche (L pour left)
d’une position. Le bit de gauche qui sort
du registre est placé dans le code de condition C. Un bit zéro entre par la
droite pour prendre la place
du dernier bit Tous les témoins sont affectés.
Le témoin V est mis à 1 dans le cas où le signe change (valeur du premier bit (à gauche)).
Témoin C
|
|
Bit perdu
|
<-
|
Opérande
|
<-
|
0
|
Exemple :
LDX 0x2468,i ; X = 2468 NZVC=0000
en binaire 0010 0100 0110 1000
ASLX ; X = 48D0 NZVC=0000
en binaire 0100 1000 1101 0000
ASLX ; X = 91A0 NZVC=1010
en binaire 1001 0001 1010 0000
ASLX ; X = 2340 NZVC=0011
en binaire 0010 0011 0100 0000
Voir les
exemples complets: Instructions et directives: décalages à
gauche
Instruction ASRr
Voir les exemples complets:
L’instruction ASRr effectue un décalage à droite (R pour right)
d’une position. Le bit de droite qui sort
du registre est placé dans le code de condition C. Le bit de signe est reproduit
et prend la place du
premier bit. Les témoins N, Z, et C sont affectés.
| |
Témoin C
|
signe (0 positif ou 1 négatif) ->
|
Opérande
|
->
|
bit perdu
|
Exemple :
LDA 0xABCD,i ;
en binaire 1010 1011 1100 1101
ASRA ; A=D5E6 NZVC=1001
en binaire 1101 0101 1110 0110
ASRA ; A=EAF3 NZVC=1000
en binaire 1110 1010 1111 0011
Voir les
exemples complets: Instructions et directives: décalages à
droite
Instruction ROLr
L’instruction ROLr effectue une rotation cyclique à gauche (L
pour left) d’une position du contenu du
registre associé au code de condition C. Le bit de droite du registre reçoit le
code de condition C, ce
dernier reçoit comme nouvelle valeur le bit sorti du registre. Seul le témoin C
est affecté.
->
|
Témoin C
|
<-
|
Opérande
|
<-
|
Exemple :
LDA 0x385C,i ; NZVC = 0000 A = 385C
en binaire témoin C: 0 <-
0011 1000 0101 1100
ROLA ; NZVC = 0000 A = 70B8
en binaire témoin C: 0 <-
0111 0000 1011 1000
ROLA ; NZVC = 0000 A = E170
en binaire témoin C: 0 <-
1110 0001 0111 0000
ROLA ; NZVC = 0001 A = C2E0
en binaire témoin C: 1 <-
1100 0010 1110 0000
ROLA ; NZVC
= 0001 A = 85C1 en binaire
témoin C: 1 <- 1000 0101 1100
0001
Voir les
exemples complets: Instructions et directives:
rotations cycliques
Instruction RORr
L’instruction RORr effectue une rotation cyclique à droite (R
pour right) d’une position du registre
associé au code de condition C. Le bit de gauche du registre reçoit la valeur du
code de condition C et
ce dernier reçoit le bit de droite du registre comme nouvelle valeur. Seul le
témoin C est affecté.
<-
|
Opérande
|
->
|
Témoin C
|
->
|
Exemple :
LDA 0x1C2E,i ; NZVC = 0000 A = 1C2E
en binaire 0001 1100 0010 1110 -> témoin C:0
RORA ; NZVC = 0000 A = 0E17
en binaire 0000 1110 0001
0111 -> témoin C:0
RORA ; NZVC = 0001 A = 070B
en binaire 0000 0111 0000
1011 -> témoin C:1
RORA ; NZVC = 0001 A = 8385
en binaire 1000 0011 1000
0101 -> témoin C:1
RORA ; NZVC = 0001 A = C1C2
en binaire 1100 0001 1100 0010 ->
témoin C:1
Instruction CPr
L’instruction de comparaison CPr soustrait l’opérande de la
valeur contenue dans le registre et
affecte tous les témoins selon le résultat obtenu. Le contenu du registre ne
change pas.
exemple: compteur de bits égaux à "1":
prog76.txt
; Compter et afficher le nombre de bits égaux à "1" dans un mot mémoire.
; Lorne H. Bouchard (adapté par Ph. Gabrini mars 2006)
;
debut: DECI nbLu,d ;
CHARO '#',i ; cout << '#'
DECO nbLu,d ; << nbLu décimal
CHARO '=',i ; << '='
CHARO 'x',i ; << 'x'
LDA nbLu,d ;
STA -2,s ;
SUBSP 2,i ;
CALL HEXO ; << nbLu hexadécimal
CHARO '=',i ; << '=';
LDA nbLu,d ;
BRGE boucle ;
ANDA 0x7FFF,i ; on se débarrasse du bit de signe
STA nbLu,d ;
LDX 1,i ;
STX nombre1,d ; mais on le compte
boucle: LDA nbLu,d ;
BREQ fini ; il n'y a plus de "1"
ANDA 1,i ;
BREQ zero ; si le bit est "1"
LDA 1,i ;
ADDA nombre1,d ;
STA nombre1,d ; on compte le bit
zero: LDA nbLu,d ;
ASRA ; on passe au bit suivant
STA nbLu,d ;
BR boucle ;
fini: DECO nombre1,d ; cout << nombre de bits 1
STOP ;
;
; HEXO: routine qui affiche en hexadécimal
;
; IN: SP+0=nombre hexa à afficher
;
; OUT: rien
;
car: .EQUATE 0 ; caractère à afficher
sauveA: .EQUATE 1
sauveX: .EQUATE 3
retour: .EQUATE 5
nombre: .EQUATE 7 ; donnée à afficher
;
HEXO: SUBSP 5,i
STA sauveA,s
STX sauveX,s
LDX 3,i ; 4 caractères à afficher
boucleh: LDA nombre,s
ROLA ; déplacement du premier caractère vers la droite
ROLA ;
ROLA ;
ROLA ;
STA nombre,s ; prochaine position
ROLA ;
ANDA 0x000F,i ; élimination des 3 autres caractères
ADDA '0',i ; conversion en chiffre
CPA '9',i ; lettre ?
BRLE chiffre
ADDA 7,i ; conversion en lettre
chiffre: STBYTEA car,s ; caractère à afficher
CHARO car,s
SUBX 1,i ; caractère suivant
BRGE boucleh
LDA retour,s ; épilogue
STA nombre,s
LDA sauveA,s
LDX sauveX,s
ADDSP 7,i
RET0
;
nbLu: .WORD 0 ; nombre lu
nombre1: .WORD 0 ; nombre de "1" dans nbLu
.END
7.7 Instructions de branchement
Instruction BR
L’instruction de branchement inconditionnel BR place l’adresse
qui se trouve dans sa partie opérande
dans le compteur ordinal, forçant ainsi la prochaine instruction a être celle
dont l’adresse se trouve
dans l’instruction de branchement.
Exemple 1
Ce premier exemple illustre une possibilité offerte par la programmation de
bas niveau exploitée, il y a
bien longtemps, alors que les machines disposaient de très peu de mémoire (par
exemple un gros
« mainframe » de plusieurs millions de dollars avec une mémoire centrale de 64
Kmots de 36 bits!).
exemple:
programme IMPUR: impur.txt
Addr Code Symbol Mnemon Operand Comment
;Un programme impur (qui modifie ses instructions au cours de
;l'exécution) à ne pas émuler, mais à comprendre.
0000 C00000 LDA 0,i ; vider registre A
0003 D1001C Encore: LDBYTEA texte,d ;while(true){
0006 0A001B BREQ Arret ; if(caractère == 0) break;
0009 51001C CHARO texte,d ; else{ afficher caractère
000C C10004 LDA 0x0004,d ; copier opérande LDBYTEA
000F 700001 ADDA 1,i ; et l'augmenter
0012 E10004 STA 0x0004,d ; modifier opérande LDBYTEA
0015 E1000A STA 0x000A,d ; modifier opérande CHARO
0018 040003 BR Encore ; }//if
001B 00 Arret: STOP ;}//while
001C 556E20 texte: .ASCII "Un texte assez long....\x00"
746578
746520
617373
657A20
6C6F6E
672E2E
2E2E00
.END
Exemple 2
Ce programme est une seconde version de l’exemple précédent;
cette version peut être dite « pure »,
car le code n’est pas modifié au cours de l’instruction.
exemple:
programme PUR: pur.txt
Addr Code Symbol Mnemon Operand Comment
; Programme pur d'affichage d'une chaîne de caractères.
0000 C80000 LDX 0,i ; X = 0;
0003 C00000 LDA 0,i ; A = 0;
0006 D50016 Encore: LDBYTEA texte,x ; while(true) {
0009 0A0015 BREQ Arret ; if(texte[X] == 0) break;
000C 550016 CHARO texte,x ; else{ cout << texte[X];
000F 780001 ADDX 1,i ; X++;}
0012 040006 BR Encore ; }
0015 00 Arret: STOP
0016 556E20 texte: .ASCII "Un texte assez long.....\x00"
746578
746520
617373
657A20
6C6F6E
672E2E
2E2E2E
00
.END
Instruction BRLE
L’instruction de branchement conditionnel BRLE vérifie les codes
de condition et si Z ou N valent 1
produit un branchement à l’adresse comprise dans l’instruction. Sinon le
traitement se poursuit par
l’instruction suivant le BRLE.
Instruction BRLT
L’instruction de branchement conditionnel BRLT vérifie les codes
de condition et si N vaut 1 produit un
branchement à l’adresse comprise dans l’instruction. Sinon le traitement se
poursuit par l’instruction
suivant le BRLT.
Instruction BREQ
L’instruction de branchement conditionnel BREQ vérifie les codes
de condition et si Z vaut 1 produit un
branchement à l’adresse comprise dans l’instruction. Sinon le traitement se
poursuit par l’instruction
suivant le BREQ.
Instruction BRNE
L’instruction de branchement conditionnel BRNE vérifie les codes
de condition et si Z vaut 0 produit un
branchement à l’adresse comprise dans l’instruction. Sinon le traitement se
poursuit par l’instruction
suivant le BRNE.
Instruction BRGE
L’instruction de branchement conditionnel BRGE vérifie les codes
de condition et si N vaut 0 produit un
branchement à l’adresse comprise dans l’instruction. Sinon le traitement se
poursuit par l’instruction
suivant le BRGE.
Instruction BRGT
L’instruction de branchement conditionnel BRGT vérifie les codes
de condition et si Z et N valent 0
produit un branchement à l’adresse comprise dans l’instruction. Sinon le
traitement se poursuit par
l’instruction suivant le BRGT.
Instruction BRV
L’instruction de branchement conditionnel BRV vérifie le code de
condition V et, s’il vaut 1, produit un
branchement à l’adresse comprise dans l’instruction, sinon le traitement se
poursuit par l’instruction
suivant le BRV.
Exemple 3
Le programme qui suit vérifie le résultat d’une opération arithmétique.
La première opération est la soustraction du nombre négatif de
plus petite valeur absolue (0x8000) de la valeur zéro,
ce qui revient à simplement en changer le signe.
Comme la
valeur positive la plus grande est 0x7FFF, il y aura
débordement, vérifié par l’instruction BRV, laquelle affichera le message r=8000 V=1 avant
de revenir
à l’étiquette continue.
La seconde opération en est une d’addition de la plus petite valeur négative à
elle-même, ce qui produit un débordement, à nouveau détecté par l’instruction
BRV, laquelle affiche le
message : r=0000 V=1
exemple: opérations de débordement:
brv.txt
; Test de débordement
; Lorne H. Bouchard (adapté par Ph. Gabrini mars 2006)
;
debut: LDA 0,i ; 0
SUBA 0x8000,i ; - nombre (négatif) le plus petit
STA res,d ;
BRV deborde ;
continue:LDA 1,i ;
STA indic,d ;
LDA 0x8000,i ; nombre (négatif) le plus petit
ADDA 0x8000,i ; + nombre (négatif) le plus petit
STA res,d ;
BRV deborde ;
STOP ;
deborde: CHARO 'r',i ; cout << "r="
CHARO '=',i ;
LDA res,d ;
STA -2,s ;
SUBSP 2,i ;
CALL HEXO ; << valeur hexadécimale
CHARO ' ',i ;
CHARO 'V',i ; << " V=1"
CHARO '=',i ;
CHARO '1',i ;
CHARO 0x000A,i ; << endl;
LDA indic,d ;
BREQ continue ; if(indic == 0) continue
STOP ;
;
; HEXO: routine qui affiche en hexadécimal
;
; IN: SP+0=nombre hexa à afficher
;
; OUT: rien
;
car: .EQUATE 0 ; caractère à afficher
sauveA: .EQUATE 1
sauveX: .EQUATE 3
retour: .EQUATE 5
nombre: .EQUATE 7 ; donnée à afficher
;
HEXO: SUBSP 5,i
STA sauveA,s
STX sauveX,s
LDX 3,i ; 4 caractères à afficher
boucleh: LDA nombre,s
ROLA ; déplacement du premier caractère vers la droite
ROLA ;
ROLA ;
ROLA ;
STA nombre,s ; prochaine position
ROLA ;
ANDA 0x000F,i ; élimination des 3 autres caractères
ADDA '0',i ; conversion en chiffre
CPA '9',i ; lettre ?
BRLE chiffre
ADDA 7,i ; conversion en lettre
chiffre: STBYTEA car,s ; caractère à afficher
CHARO car,s
SUBX 1,i ; caractère suivant
BRGE boucleh
LDA retour,s ; épilogue
STA nombre,s
LDA sauveA,s
LDX sauveX,s
ADDSP 7,i
RET0
;
res: .WORD 0
indic: .WORD 0
.END
RÉSULTAT: r=0000 V=1
Exemple 4
Le programme ci-dessous effectue la
même tâche que le programme vu à la section 7.6,
lequel compte et affiche le nombre de bits égaux à 1 dans un mot mémoire donné.
exemple: compteur de bits "1":
prog77.txt
; Compter et afficher le nombre de bits égaux à "1"
dans un mot mémoire.
; Utilisation du code de condition C, touché par le décalage.
; Lorne H. Bouchard (adapté par Ph. Gabrini mars 2006)
;
debut: DECI nbLu,d ;
CHARO '#',i
;
DECO nbLu,d
;
CHARO '=',i
;
CHARO 'x',i
;
LDA
nbLu,d ;
STA
-2,s ;
SUBSP 2,i
;
CALL HEXO
;
CHARO '=',i
;
LDA
nbLu,d ;
BRGE boucle
; if(nbLu < 0)
ANDA 0x7FFF,i
; on se débarrasse du bit de signe
STA
nbLu,d ;
LDX 1,i
;
STX
nombre1,d ; et on le compte
boucle: LDA nbLu,d ;
while(encore des bits 1)
BREQ fini
;
ASRA ; décaler A dans C
STA nbLu,d ; conserver
BRC un ; if(C == 1){
BR boucle ;
un: LDA 1,i ;
ADDA nombre1,d ; nombre1++;
STA nombre1,d ; compter le bit
BR boucle ; }
fini: DECO nombre1,d ; cout << nombre1;
STOP ;
;
; HEXO: routine qui affiche en hexadécimal
;
; IN: SP+0=nombre hexa à afficher
;
; OUT: rien
;
car: .EQUATE 0 ; caractère à afficher
sauveA: .EQUATE 1
sauveX: .EQUATE 3
retour: .EQUATE 5
nombre: .EQUATE 7 ; donnée à afficher
;
HEXO: SUBSP 5,i
STA sauveA,s
STX sauveX,s
LDX 3,i ; 4 caractères à afficher
boucleh: LDA nombre,s
ROLA ; déplacement du premier caractère vers la droite
ROLA ;
ROLA ;
ROLA ;
STA nombre,s ; prochaine position
ROLA ;
ANDA 0x000F,i ; élimination des 3 autres caractères
ADDA '0',i ; conversion en chiffre
CPA '9',i ; lettre ?
BRLE chiffre
ADDA 7,i ; conversion en lettre
chiffre: STBYTEA car,s ; caractère à afficher
CHARO car,s
SUBX 1,i ; caractère suivant
BRGE boucleh
LDA retour,s ; épilogue
STA nombre,s
LDA sauveA,s
LDX sauveX,s
ADDSP 7,i
RET0
;
res: .WORD 0
indic: .WORD 0
nbLu: .WORD 0 ; nombre lu
nombre1: .WORD 0 ; nombre de "1" dans n
.END
Voir les exemples complets: Instructions et
directives:
branchements
7.8 Instructions liées aux sous-programmes
Instruction CALL
L’instruction CALL empile la valeur du compteur ordinal et place
l’adresse donnée dans l’instruction dans
le compteur ordinal, transférant ainsi le contrôle à la première instruction du
sous-programme. Son
mode d’adressage est soit direct, soit indexé. Les codes de condition ne sont
pas affectés.
Instruction RETn
L’instruction unaire RETn désempile n
octets de la pile (n occupe trois bits et doit être compris entre 0
et 7), donne au compteur ordinal la valeur du nouveau sommet de la pile qui est
alors désempilée. Les
codes de condition ne sont pas affectés.
7.9 Instructions non réalisées
Instruction NOPn
L’instruction NOPn est une
instruction unaire, qui n’a donc pas d’opérande autre que le nombre n. Ce
dernier occupe 2 bits et doit donc avoir une valeur entre 0 et trois.
L’exécution de cette instruction
engendre une interruption au niveau de la machine, mais elle peut être
utilisée comme toute autre
instruction Assembleur. Cette instruction ne fait rien (NOP = no operation),
mais elle pourrait être
remplacée par toute autre instruction utile, comme par exemple des
instructions de traitement des
valeurs réelles (voir chapitre 11). Les codes de condition ne sont pas
affectés.
Instruction NOP
L’instruction NOP est une instruction qui nécessite un opérande
en mode d’adressage immédiat. Cet
opérande peut être utilisé dans le traitement de l’instruction qui est basée sur
un code d’instruction non
réalisé. L’exécution de cette instruction engendre donc une interruption au
niveau de la machine, mais
elle peut être utilisée comme toute autre instruction Assembleur. Cette
instruction ne fait rien (NOP =
no operation), mais il est possible de modifier son traitement dans le système
d’exploitation pour
mettre en place d’autres instructions utiles (voir chapitre 11), comme par
exemple des instructions de
multiplication et de division entière. Les codes de condition ne sont pas
affectés.
7.10 Exemples d’application
Pages 71 à 80.
Exemple 5
Le programme ci-dessous lit
un ensemble de valeurs entières et les range dans un vecteur d’entiers.
Ensuite, il affiche ces valeurs à partir de la fin du tableau à raison d’une
par ligne, chaque valeur étant
précédée de son indice.
;Programme qui lit des données, les place dans un vecteur et les
;affiche à l’envers une par ligne, précédées de leur indice.
TAILLE: .EQUATE 12 ;taille du vecteur
LitVec: LDX 0,i ;int main() {
STX index,d ;
Boucle1: CPX TAILLE,i ; for(i = 0; i < TAILLE; i++){
BRGE FinBouc1 ;
ASLX ; //entier = 2 octets
DECI vecteur,x ; cin >> vector[i];
LDX index,d ;
ADDX 1,i ;
STX index,d ;
BR Boucle1 ; }
FinBouc1:LDX TAILLE,i ; for(i = TAILLE-1; i >= 0; i--){
SUBX 1,i ;
STX index,d ;
CHARO '\n',i ; cout << endl;
Boucle2: CPX 0,i ;
BRLT FinBouc2 ;
DECO index,d
CHARO ' ',i ; << ' '
ASLX ; //entier = 2 octets
DECO vecteur,x ; << vector[i]
CHARO '\n',i ; << endl;
LDX index,d ;
SUBX 1,i ;
STX index,d ;
BR Boucle2 ; }
FinBouc2:STOP ; return 0;}
vecteur: .BLOCK 24 ; #2d12a
index: .BLOCK 2 ; int index;
;Avec les données 39 25 54 46 51 42 21 18 11 14 23 49
.END