2 Couche microprogrammée

2 Couche microprogrammée

2.1 Structure de la micromachine
- 2.1.1 Le chemin des données
- 2.1.2 Le bloc de contrôle
2.2 Les micro-instructions
- 2.2.1 Structure d'une micro-instruction
- 2.2.2 Exécution d'une micro-instruction
2.3 L'interprétation des instructions en langage machine
- 2.3.1 Les instructions du langage machine
- 2.3.2 Interprétation d'une instruction du langage machine

Dans ce chapitre, on considère une mémoire centrale de 2¹² mots de 16 bits, comportant une pile d'exécution, reliée à un bus d'adresses à 12 lignes et à un bus de données à 16 lignes. On suppose qu'un programme en langage machine est chargé dans cette mémoire centrale.

Le microprogramme est un programme qui réside dans une mémoire locale du (micro) processeur: c'est un interpréteur qui décode et exécute une par une les instructions en langage machine¹⁹, en répétant le schéma général suivant:

transfert d'une instruction de la mémoire centrale vers un registre spécifique du processeur (RI, comme Registre d'Instruction);
modification du compteur ordinal²⁰, qui est positionné à l'adresse suivante de la mémoire centrale;
décodage de l'instruction: extraction du code opération et éventuellement des adresses des données en mémoire centrale;
transfert éventuel des données de la mémoire centrale vers des registres spécifiques du processeur;
exécution proprement dite de l'instruction, qui peut utiliser l'UAL;
transfert éventuel du résultat vers la mémoire centrale.

Avant de revoir le détail de ces opérations, nous décrivons la structure d'une micromachine et les micro-instructions.

2.1 Structure de la micromachine

La micromachine contient deux parties: le chemin des données et le bloc de contrôle. Voir la figure 1.

Figure 1: Une machine microprogrammée

2.1.1 Le chemin des données

Il comprend (voir la partie gauche de la figure 1):

16 registres généraux à 16 bits. Chacun de ces registres peut soit être chargé par une donnée en provenance du bus C, soit transférer son contenu sur l'un ou l'autre des deux bus A et B. On compte les registres suivants:
- Les registres A, B, C, D, E, F sont des registres (vraiment) généraux.
- Le registre CO contient la valeur du Compteur Ordinal, c'est-à-dire l'adresse (en mémoire centrale) de l'instruction suivante du programme en langage machine.
- Le registre AC est un registre ACcumulateur, utilisé pour conserver provisoirement la valeur d'une donnée.
- Le registre PP contient le Pointeur de Pile, c'est-à-dire l'adresse du sommet de la pile d'exécution, située en mémoire centrale (la pile étant en général inversée, elle est d'autant plus grande que cette adresse est basse).
- Le registre RI (Registre d'Instruction) contient une copie de l'instruction en cours de décodage et d'exécution.
- Le registre RIT contient une copie plus ou moins exacte de RI²¹.
- Les registres 0, +1, et -1 contiennent les valeurs constantes correspondantes²².
- Le registre AMASQ est un masque d'adresse, il contient la constante 0x0fff, c'est-à-dire 0fff en hexadécimal, tandis que le registre PMASQ est un masque de pile, qui contient la constante 0x00ff²³.
Les registres généraux sont numérotés:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

CO AC PP RI RIT 0 +1 -1 AMASQ PMASQ A B C D E F
Un multiplexeur AMUX, qui sélectionne une entrée parmi deux, avec la commande A0. Les deux entrées possibles sont le contenu du tampon A, en sortie du bus A, et le registre RDO, registre de données qui assure le transfert de données entre le microprocesseur et la mémoire centrale.
Une UAL avec 4 opérations possibles (sur des mots de 16 bits). Une opération sur les entrées A (en sortie de AMUX) et B (provenant du tampon B) est sélectionnée par la configuration des deux lignes F0 et F1:

0 A+B

1 A ET B

2 A

3 NON A

Outre le résultat de l'opération, l'UAL comporte deux sorties Z et N qui valent 1 respectivement lorsque le résultat est nul ou lorsqu'il est négatif (c'est-à-dire lorsque le bit de poids fort de ce résultat vaut 1).

Les opérandes de l'UAL sont maintenus stables dans les deux tampons d'entrée A et B, dont le chargement (par les valeurs présentes sur les bus A et B) est commandé par les signaux L0 et L1.
Un décaleur avec deux commandes S0 et S1 dont la configuration indique le sens du décalage:

0 pas de décalage

1 décalage à droite

2 décalage à gauche

3 inutilisé
Deux registres qui réalisent la communication avec la mémoire centrale:
- Le registre d'adresses RAD à 12 bits, qui prend en entrée les 12 bits de poids faible de la donnée en provenance du tampon B, selon la commande M0, et dont le contenu peut être placé en sortie sur le bus d'adresses vers la mémoire centrale.
- Le registre de données RDO à 16 bits, qui peut être chargé par la donnée du bus C en sortie du décaleur (commande M1). L'écriture en mémoire centrale est réalisée par le positionnement du contenu de RDO sur le bus de données (commande M2 ou WR) tandis que la lecture en mémoire correspond au chargement de RDO par le bus de données (commande M3 ou RD).
  
  Remarquons que RDO est toujours positionné en sortie vers l'unité centrale, puisque la commande A0 du multiplexeur AMUX permet de choisir entre le contenu de RDO et celui du tampon A pour l'entrée A de l'UAL.
  
  0 tampon A
  
  1 RDO

2.1.2 Le bloc de contrôle

Il comprend (voir la partie droite de la figure 1):

Trois décodeurs 4 vers 16, sélectionnant un des 16 registres généraux pour les transferts avec les bus A, B, C.
Une horloge qui assure la synchronisation. Cette horloge comporte trois retards successifs, de façon à diviser un cycle en 4 sous-cycles, H1, H2, H3, H4.
Une mémoire de commande de 256 mots de 32 bits chacun, qui contient le microprogramme, c'est-à-dire une suite de micro-instructions (pas plus de 256) de 32 bits chacune.
Un registre MCO, micro-compteur ordinal, qui contient l'adresse de la micro-instruction suivante²⁴.
Un compteur incrémental, circuit qui ajoute 1 au contenu du registre MCO.
Un multiplexeur MMUX, qui choisit une entrée parmi:
- le résultat provenant du compteur incrémental, c'est-à-dire MCO+1 (adresse de la prochaine micro-instruction) et
- une autre adresse correspondant généralement à un saut dans le micro-programme. La commande de ce multiplexeur est constituée par la sortie d'un micro-séquenceur.
Un registre de micro-instruction, qui contient la micro-instruction en cours d'exécution. Ce registre comporte donc 32 bits et nous l'examinons maintenant en détail.

2.2 Les micro-instructions

2.2.1 Structure d'une micro-instruction

Une micro-instruction est donc un mot de 32 bits comportant 13 champs:

Le bit AMUX forme la commande A0 du multiplexeur de même nom.
Le champ COND comporte deux bits dont la valeur binaire permet de contrôler des sauts éventuels:

0 pas de saut

1 saut si N=1

2 saut si Z=1

3 saut sans condition
Les 2 bits du champ UAL correspondent aux commandes F0 et F1 de l'unité arithmétique et logique et permettent le choix de l'opération à effectuer.
Les 2 bits du champ DCAL sont reliés aux commandes S0 et S1 du décaleur.
Les 5 champs suivants contiennent chacun un bit et correspondent respectivement aux commandes suivantes:
- RDO: M1=1 autorise le chargement de RDO par la donnée du bus C.
- RAD: M0=1 autorise le chargement de RAD par la donnée du tampon B.
- RD: M3=1 autorise le chargement de RDO par le bus de données.
- WR: M2=1 autorise le transfert de RDO sur le bus de données.
- VALC: à 1, autorise le chargement d'un des 16 registres généraux par la donnée du bus C.
Les trois champs C, B, A comportent 4 bits chacun:
- Les 4 bits de C forment les entrées du décodeur C et sélectionnent un des 16 registres généraux où décharger la donnée du bus C.
- Les 4 bits de B (resp. de A) sont les entrées du décodeur B (resp. A) et sélectionnent un des 16 registres généraux dont le contenu est transféré sur B (resp. A).
Le champ ADDR contient une adresse de saut éventuel sur 8 bits.

La figure 2 montre quelques exemples de micro-instructions. La colonne de gauche indique de façon fonctionnelle (dans un langage de type Pascal) les opérations à effectuer et les colonnes suivantes contiennent les valeurs des bits de la micro-instruction correspondante.

C B A ADDR

rad:=co; rd; 0 0 2 0 0 1 1 0 0 0 0 0 00

rd; 0 0 2 0 0 0 1 0 0 0 0 0 00

ri:=rdo; 1 0 2 0 0 0 0 0 1 3 0 0 00

co:=co+1; 0 0 0 0 0 0 0 0 1 0 6 0 00

rad:=ri; rdo:=ac; wr; 0 0 2 0 1 1 0 1 0 0 3 1 00

ual:=rit; if n goto 15; 0 1 2 0 0 0 0 0 0 0 0 4 15

ac:=inv(rdo); 1 0 3 0 0 0 0 0 1 1 0 0 00

rit:=decalg(rit); if n goto 25; 0 1 2 2 0 0 0 0 1 4 0 4 25

ual:=ac; if z goto 25; 0 2 2 0 0 0 0 0 0 0 0 1 22

ac:=bet(ri,amasq); goto 0; 0 3 1 0 0 0 0 0 1 1 8 3 00

pp:=pp-1; rd; 0 0 0 0 0 0 1 0 1 2 2 7 00

rit:=decalg(ri+ri); if n goto 69; 0 1 0 2 0 0 0 0 1 4 3 3 69

Figure 2: Quelques exemples de micro-instructions

Dans la dernière ligne du tableau, par exemple, les opérations sont

rit:=decalg(ri+ri); if n goto 69;

La micro-instruction associée comporte donc:

ri+ri: les valeurs 3 dans les champs A et B commandent le transfert du contenu du registre RI (de numéro 3) sur les bus A et B, de façon à positionner ces valeurs en entrée de l'UAL.
En général, la valeur contenue par défaut dans un champ est 0, mais ici, la valeur 0 dans le champ UAL signifier l'exécution d'une addition, qui permet dans ce cas d'effectuer un premier décalage à gauche sur le contenu du registre RI.
decalg: la valeur 2 dans le champ DCAL permet d'obtenir le décalage à gauche.
rit:=: le bit 1 dans le champ VALC valide le déchargement du résultat (en sortie du décaleur) situé sur le bus C dans un des registres généraux (ici RIT.
La valeur 4 dans le champ C indique l'adresse du registre RIT (rappelons que les numéros de registre vont de 0 à 15) où déposer la donnée du bus C.
if n:la valeur 1 dans le champ COND commande un saut lorsque N est égal à 1. Si les bits sont numérotés de 0 à 15, le bit 15 étant celui de poids le plus fort, ceci se produit lorsque le bit numéro 14, qui est le bit de poids fort du résultat de l'addition ri+ri, vaut 1.
goto 69: la valeur 69 dans le champ ADDR contient l'adresse du saut (rappelons qu'il s'agit d'une adresse du micro-programme, donc de la mémoire de commande).

2.2.2 Exécution d'une micro-instruction

L'exécution est divisée en quatre étapes, correspondant chacune à un des quatre sous-cycles de l'horloge.

Pendant le premier sous-cycle, la micro-instruction est transférée de la mémoire de commande vers le registre de micro-instruction (RMI). Ainsi, pour la mémoire de commande, le registre RMI joue le rôle d'un registre de donnée, tandis que le registre MCO (micro-compteur ordinal) joue le rôle d'un registre d'adresse.
Pendant le deuxième sous-cycle, le compteur incrémental ajoute 1 au contenu de MCO et les valeurs des champs A et B sélectionnent, par l'intermédiaire des décodeurs, les registres généraux dont les contenus sont transférés sur les bus, puis sur les tampons A et B.
Pendant le troisième sous-cycle, les opérations sont exécutées par l'UAL et le décaleur, avec comme opérandes d'une part le tampon B et d'autre part la sortie du multiplexeur qui est soit le tampon A soit le contenu du registre de donnée RDO. Lorsque le champ RAD est à 1, la donnée du tampon B est transférée dans le registre d'adresse RAD.
Pendant le quatrième sous-cycle, la donnée du bus C en sortie du décaleur peut être déchargée dans un des registres généraux (désigné par le champ C), lorsque VALC vaut 1, et dans RDO, si le champ RDO vaut 1. le décodeur C est donc relié à la fois aux champs C et VALC de la micro-instruction et au quatrième signal d'horloge CK4.

2.3 L'interprétation des instructions en langage machine

2.3.1 Les instructions du langage machine

Un ensemble d'instructions est représenté dans le tableau de la figure 3.

Binaire Symbole Instruction Opération

0000 xxxx xxxx xxxx LODD Chargement ac:=m[x]

mode direct

0001 xxxx xxxx xxxx STOD Rangement m[x]:=ac

mode direct

0010 xxxx xxxx xxxx ADDD Addition ac:=ac+m[x]

mode direct

0011 xxxx xxxx xxxx SUBD Soustraction ac:=ac−m[x]

mode direct

0100 xxxx xxxx xxxx JPOS Saut si >0 if (ac>0) co:=x

0101 xxxx xxxx xxxx JZER Saut si =0 if (ac=0) co:=x

0110 xxxx xxxx xxxx JUMP Saut co:=x

0111 xxxx xxxx xxxx LOCO Chargement ac:=x (0≤ x≤ 4 095)

constante

1000 xxxx xxxx xxxx LODL Chargement ac:=m[pp+x]

mode local

1001 xxxx xxxx xxxx STOL Rangement m[pp+x]:=ac

mode local

1010 xxxx xxxx xxxx ADDL Addition ac:=ac+m[pp+x]

mode local

1011 xxxx xxxx xxxx SUBL Addition ac:=ac−m[pp+x]

mode local

1100 xxxx xxxx xxxx JNEG Saut si <0 if (ac<0) co:=x

1101 xxxx xxxx xxxx JNZE Saut si ≠ 0 if (ac≠ 0) co:=x

1110 xxxx xxxx xxxx CALL Appel procédure pp:=pp−1; m[pp]:=co; co:=x

1111 0000 0000 0000 PSHI Empilement pp:=pp−1; m[pp]:=m[ac]

indirect

1111 0010 0000 0000 POPI Dépilement m[ac]:=m[pp]; pp:=pp+1

indirect

1111 0100 0000 0000 PUSH Empilement pp:=pp−1; m[pp]:=ac

1111 0110 0000 0000 POP Dépilement ac:=m[pp]; pp:=pp+1

indirect

1111 1000 0000 0000 RETN Retour co:=m[pp]; pp:=pp+1

1111 1010 0000 0000 SWAP Échange tmp:=ac; ac:=pp; pp:=tmp

AC et pile

1111 1100 yyyy yyyy INSP Incrémentation pp:=pp+y (0≤ y≤ 255)

de PP

1111 1110 yyyy yyyy DESP Décrémentation pp:=pp−y (0≤ y≤ 255)

de PP

Figure 3: Instructions du langage machine

La première colonne de ce tableau contient le code binaire de l'instruction. Remarquons que les instructions sont rangées par ordre croissant suivant leur code. Ce code est en général divisé en deux parties, la première représentant l'opération proprement dite et la seconde une adresse de la mémoire centrale ou une constante. Dans la deuxième colonne figure le symbole correspondant, tandis que la troisième colonne contient le nom de l'instruction et la quatrième une description fonctionnelle de cette instruction dans un langage du type Pascal. Dans cette colonne, le mot de la mémoire centrale d'adresse x est noté m[x].

Considérons par exemple l'instruction de symbole JUMP. Le code binaire de cette opération commence par 0110, suivi de l'adresse en mémoire centrale (sur 12 bits) où le branchement doit avoir lieu. La description fonctionnelle consiste simplement en une instruction: co:=x, qui signifie que cette adresse de la mémoire centrale doit être copiée dans le compteur ordinal.

Certaines opérations ont un code opération sur 16 bits, car elles ne nécessitent pas d'information supplémentaire: par exemple l'instruction PUSH ajoute le contenu du registre AC au sommet de la pile d'exécution. La pile considérée dans ce chapitre est située à des adresses décroissantes de la mémoire centrale, il faut donc décrémenter de 1 l'adresse du sommet de pile pour y ajouter une donnée: pp:=pp−1; m[pp]:=ac.

On peut observer dans ce tableau trois modes d'adressage:

L'adressage direct: le code opération est suivu d'une adresse mémoire sur 12 bits. L'instruction JUMP vue précédemment se situe dans cette catégorie, ainsi par exemple que le chargement en mode direct LODD: ac:=m[x], qui charge le mot à l'adresse x de la mémoire centrale dans le registre AC.
L'adressage indirect: l'adresse en mémoire centrale est d'abord chargée dans AC. Par exemple POPI est une instruction qui dépile en mode indirect: m[ac]:=m[pp]; pp:=pp+1.
L'adressage local: l'adresse est relative au pointeur de pile. Par exemple STOL est une instruction de rangement en mode local, qui copie le contenu de AC en mémoire centrale à l'adresse pp+x (où pp est la valeur du registre PP), c'est-à-dire dans la pile, à la distance x du sommet: m[pp+x]:=ac.

Indépendamment du mode d'adressage, les instructions se divisent en plusieurs catégories:

Les transferts de données entre le processeur (registre AC) et la mémoire centrale (éventuellement la pile), parfois assortis d'opérations arithmétiques.
Les branchements, avec ou sans condition.
L'appel et le retour de procédure: le paramètre de l'appel est l'adresse de la procédure appelée, qui est placée dans le compteur ordinal CO. La valeur précédente est sauvegardée au sommet de la pile d'exécution et sera à nouveau copiée dans le registre CO lors du retour.

2.3.2 Interprétation d'une instruction du langage machine

Les figures 4, 5, et 6 montrent un exemple de micro-programme. Un micro-programme est donc une suite de micro-instructions, qui sont ici décrites de manière fonctionnelle pour des raisons de lisibilité, mais qu'il faudrait en fait traduire par les 32 bits correspondants, comme cela a été fait dans la figure 2. Le micro-programme est formé d'une boucle, comprenant trois étapes:

Recherche de l'instruction en langage machine en mémoire centrale et copie de cette instruction dans le registre RI.
Analyse des bits de poids forts de l'instruction, permettant d'obtenir le code de l'opération.
Traitement de l'instruction.

La première étape est réalisée par les micro-instructions 0, 1, et 2 du micro-programme.

0: le contenu du compteur ordinal, représentant l'adresse de la prochaine instruction en langage machine, est placé dans le registre d'adresse et le signal RD est diffusé puisqu'une lecture de la mémoire centrale va être réalisée.
1: le compteur ordinal est incrémenté.
2: l'instruction en provenance de la mémoire centrale se trouve maintenant dans le registre de données RDO et elle est copiée dans le registre d'instruction RI. Numérotons ses bits de 15 à 0, le bit numéro 15 étant celui de poids le plus fort. Remarquons que la copie ne peut être effectuée qu'en faisant transiter la donnée par l'UAL, puis sur le bus C. Il est donc possible de tester son bit de poids fort, qui est contenu dans la sortie N de l'UAL. Ainsi, la deuxième étape commence dès cette micro-instruction. Si le bit de poids fort vaut 1, il s'agit d'une des 15 dernières instructions du tableau de la figure 3 et le micro-programme contient donc un branchement vers la première micro-instruction qui les analyse (numéro 28). Dans le cas contraire, il s'agit d'une des 8 premières instructions.

Les deux étapes suivantes sont réalisées par tous les groupes de micro-instructions qui précèdent le retour au début de la boucle, représenté par un branchement sur la première micro-instruction: goto 0;.

Fin de la deuxième étape: supposons par exemple que les micro-instructions exécutées soient celles de numéros 3, 4, et 5.

3: une micro-instruction de ce type a été examinée lors de l'étude de la structure d'une micro-instruction. L'instruction en langage machine, initialement dans RI, est recopiée dans RIT après avoir été privée de ses deux bits de poids fort. Au passage, le bit numéro 14 est testé et l'on suppose ici qu'il vaut 0.
4: la partie de l'instruction présente dans le registre RIT est à nouveau privée de son bit de poids fort par le décalage à gauche. Ce bit, qui est le numéro 13 pour l'instruction complète, est testé et l'on suppose encore qu'il vaut 0.
5: la variable ual est utilisée pour indiquer que la donnée contenue dans RIT ne fait que transiter par l'UAL sans être modifiée, pour qu'il soit possible de tester le bit numéro 12. Si ce bit vaut 0, l'instruction en langage machine commence par 0000, c'est donc un LODD, traité par les micro-instructions 6, 7, et 8. Si au contraire ce bit vaut 1, il s'agit d'un STOD, traité par les instructions 9 et 10.

Troisième étape: supposons que l'instruction STOD ait été détectée. Il faut transférer la donnée contenue dans le registre AC en mémoire centrale à l'adresse spécifiée par les 12 bits restants de l'instruction.

9: ces 12 bits sont copiés dans le registre d'adresse RAD par rad:=ri;. On peut supposer que, puisque ce registre comporte 12 bits, ce sont les bits de poids faible qui y sont placés. De plus, le contenu de AC est copié dans le registre de données RDO et le signal wr; est diffusé, pour signaler une écriture dans la mémoire centrale.
10: le signal wr; continue à être diffusé car l'écriture n'est pas instantanée et le retour en début de boucle est exécuté.

Exercice Citer et expliquer la suite des micro-instructions exécutées lors d'un appel de procédure et retour.

0: rad:=co; rd; programme principal

1: co:=co+1; rd; incrémentation de CO

2: ri:=rdo; if n goto 28; analyse et sauvegarde de RDO

3: rit:=decalg(ri+ri); if n goto 19; 00xx ou 01xx?

4: rit:=decalg(rit); if n goto 11; 000x ou 001x?

5: ual:=rit; if n goto 9; 0000 ou 0001?

6: rad:=ri; rd; 0000=LODD

7: rd;

8: ac:=rdo; goto 0;

9: rad:=ri; rdo:=ac; wr; 0001=STOD

10: wr; goto 0;

11: ual:=rit; if n goto 15; 0010 ou 0011?

12: rad:=ri; rd; 0010=ADDD

13: rd;

14: ac:=rdo+ac; goto 0;

15: rad:=ri; rd; 0011=SUBD

16: ac:=ac+1; rd;

17: a:=inv(rdo);

18: ac:=ac+a; goto 0;

19: rit:=decalg(rit); if n goto 25; 010x ou 011x?

20: ual:=rit; if n goto 23; 0100 ou 0101?

21: ual:=ac; if n goto 0; 0100=JPOS

22: co:=bet(ri,amasq); goto 0;

23: ual:=ac; if z goto 0; 0101=JZER

24: goto 0;

25: ual:=rit; if n goto 27; 0110 ou 0111?

26: co:=bet(ri,amasq); goto 0; 0110=JUMP

27: ac:=bet(ri,amasq); goto 0; 0111=LOCO

28: rit:=decalg(ri+ri); if n goto 40; 10xx ou 11xx?

29: rit:=decalg(ri); if n goto 35; 100x ou 101x?

30: ual:=rit; if n goto 33; 1000 ou 1001?

31: a:=ri+pp; 1000=LODL

32: rad:=a; rd; goto 7;

33: a:=ri+pp; 1001=STOL

34: rad:=a; rdo:=ac; wr; goto 10;

Figure 4: Un exemple de micro-programme

35: ual:=rit; if n goto 38; 1010 ou 1011?

36: a:=ri+pp; 1010=ADDL

37: rad:=a; rd; goto 13;

38: a:=ri+pp; 1011=SUBL

39: rad:=a; rd; goto 16;

40: rit:=decalg(rit); if n goto 46; 110x ou 111x?

41: ual:=rit; if n goto 44; 1100 ou 1101?

42: ual:=ac; if n goto 22; 1100=JNEG

43: goto 0;

44: ual:=ac; if z goto 0; 1101=JNZE

45: co:=bet(ri,amasq); goto 0;

46: rit:=decalg(rit); if n goto 50;

47: pp:=pp-1; 1110=CALL

48: rad:=pp; rdo:=co; wr;

49: co:=bet(ri,amasq); wr; goto 0;

50: rit:=decalg(rit); if n goto 65; 1111, adresse?

51: rit:=decalg(rit); if n goto 59;

52: ual:=rit; if n goto 56;

53: rad:=ac; rd; 1111 000=PSHI

54: pp:=pp-1; rd;

55: rad:=pp; wr; goto 10;

56: rad:=pp; pp:=pp+1; rd; 1111 001=POPI

57: rd;

58: rad:=ac: wr: goto 10;

59: ual:=rit; if n goto 62;

60: pp:=pp-1; 1111 010=PUSH

61: rad:=pp; rdo:=ac; wr; goto 10;

62: rad:=pp; pp:=pp+1; rd; 1111 011=POP

63: rd;

64: ac:=rdo; goto 0;

65: rit:=decalg(rit); if n goto 73;

66: ual:=rit; if n goto 70;

67: rad:=pp; pp:=pp+1; rd; 1111 100=RETN

68: rd;

69: co:=rdo; goto 0;

Figure 5: Un exemple de micro-programme (suite)

70: a:=ac; 1111 101=SWAP

71: ac:=pp;

72: pp:=a; goto 0;

73: ual:=rit; if n goto 76;

74: a:=bet(ri,smasq); 1111 110=INSP

75: pp:=pp+a; goto 0;

76: a:=bet(ri,smasq); 1111 111=DESP

77: a:=inv(a);

78: a:=a+1; goto 75;

Figure 6: Un exemple de micro-programme (fin)

0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
CO	AC	PP	RI	RIT	0	+1	-1	AMASQ	PMASQ	A	B	C	D	E	F

0	pas de décalage
1	décalage à droite
2	décalage à gauche
3	inutilisé

Binaire	Symbole	Instruction	Opération
0000 xxxx xxxx xxxx	LODD	Chargement	ac:=m[x]
		mode direct
0001 xxxx xxxx xxxx	STOD	Rangement	m[x]:=ac
		mode direct
0010 xxxx xxxx xxxx	ADDD	Addition	ac:=ac+m[x]
		mode direct
0011 xxxx xxxx xxxx	SUBD	Soustraction	ac:=ac−m[x]
		mode direct
0100 xxxx xxxx xxxx	JPOS	Saut si >0	if (ac>0) co:=x
0101 xxxx xxxx xxxx	JZER	Saut si =0	if (ac=0) co:=x
0110 xxxx xxxx xxxx	JUMP	Saut	co:=x
0111 xxxx xxxx xxxx	LOCO	Chargement	ac:=x (0≤ x≤ 4 095)
		constante
1000 xxxx xxxx xxxx	LODL	Chargement	ac:=m[pp+x]
		mode local
1001 xxxx xxxx xxxx	STOL	Rangement	m[pp+x]:=ac
		mode local
1010 xxxx xxxx xxxx	ADDL	Addition	ac:=ac+m[pp+x]
		mode local
1011 xxxx xxxx xxxx	SUBL	Addition	ac:=ac−m[pp+x]
		mode local
1100 xxxx xxxx xxxx	JNEG	Saut si <0	if (ac<0) co:=x
1101 xxxx xxxx xxxx	JNZE	Saut si ≠ 0	if (ac≠ 0) co:=x
1110 xxxx xxxx xxxx	CALL	Appel procédure	pp:=pp−1; m[pp]:=co; co:=x
1111 0000 0000 0000	PSHI	Empilement	pp:=pp−1; m[pp]:=m[ac]
		indirect
1111 0010 0000 0000	POPI	Dépilement	m[ac]:=m[pp]; pp:=pp+1
		indirect
1111 0100 0000 0000	PUSH	Empilement	pp:=pp−1; m[pp]:=ac
1111 0110 0000 0000	POP	Dépilement	ac:=m[pp]; pp:=pp+1
		indirect
1111 1000 0000 0000	RETN	Retour	co:=m[pp]; pp:=pp+1
1111 1010 0000 0000	SWAP	Échange	tmp:=ac; ac:=pp; pp:=tmp
		AC et pile
1111 1100 yyyy yyyy	INSP	Incrémentation	pp:=pp+y (0≤ y≤ 255)
		de PP
1111 1110 yyyy yyyy	DESP	Décrémentation	pp:=pp−y (0≤ y≤ 255)
		de PP

0:	`rad:=co; rd;`	programme principal
1:	`co:=co+1; rd;`	incrémentation de CO
2:	`ri:=rdo; if n goto 28;`	analyse et sauvegarde de RDO
3:	`rit:=decalg(ri+ri); if n goto 19;`	00xx ou 01xx?
4:	`rit:=decalg(rit); if n goto 11;`	000x ou 001x?
5:	`ual:=rit; if n goto 9;`	0000 ou 0001?
6:	`rad:=ri; rd;`	0000=LODD
7:	`rd;`
8:	`ac:=rdo; goto 0;`
9:	`rad:=ri; rdo:=ac; wr;`	0001=STOD
10:	`wr; goto 0;`
11:	`ual:=rit; if n goto 15;`	0010 ou 0011?
12:	`rad:=ri; rd;`	0010=ADDD
13:	`rd;`
14:	`ac:=rdo+ac; goto 0;`
15:	`rad:=ri; rd;`	0011=SUBD
16:	`ac:=ac+1; rd;`
17:	`a:=inv(rdo);`
18:	`ac:=ac+a; goto 0;`
19:	`rit:=decalg(rit); if n goto 25;`	010x ou 011x?
20:	`ual:=rit; if n goto 23;`	0100 ou 0101?
21:	`ual:=ac; if n goto 0;`	0100=JPOS
22:	`co:=bet(ri,amasq); goto 0;`
23:	`ual:=ac; if z goto 0;`	0101=JZER
24:	`goto 0;`
25:	`ual:=rit; if n goto 27;`	0110 ou 0111?
26:	`co:=bet(ri,amasq); goto 0;`	0110=JUMP
27:	`ac:=bet(ri,amasq); goto 0;`	0111=LOCO
28:	`rit:=decalg(ri+ri); if n goto 40;`	10xx ou 11xx?
29:	`rit:=decalg(ri); if n goto 35;`	100x ou 101x?
30:	`ual:=rit; if n goto 33;`	1000 ou 1001?
31:	`a:=ri+pp;`	1000=LODL
32:	`rad:=a; rd; goto 7;`
33:	`a:=ri+pp;`	1001=STOL
34:	`rad:=a; rdo:=ac; wr; goto 10;`

35:	`ual:=rit; if n goto 38;`	1010 ou 1011?
36:	`a:=ri+pp;`	1010=ADDL
37:	`rad:=a; rd; goto 13;`
38:	`a:=ri+pp;`	1011=SUBL
39:	`rad:=a; rd; goto 16;`
40:	`rit:=decalg(rit); if n goto 46;`	110x ou 111x?
41:	`ual:=rit; if n goto 44;`	1100 ou 1101?
42:	`ual:=ac; if n goto 22;`	1100=JNEG
43:	`goto 0;`
44:	`ual:=ac; if z goto 0;`	1101=JNZE
45:	`co:=bet(ri,amasq); goto 0;`
46:	`rit:=decalg(rit); if n goto 50;`
47:	`pp:=pp-1;`	1110=CALL
48:	`rad:=pp; rdo:=co; wr;`
49:	`co:=bet(ri,amasq); wr; goto 0;`
50:	`rit:=decalg(rit); if n goto 65;`	1111, adresse?
51:	`rit:=decalg(rit); if n goto 59;`
52:	`ual:=rit; if n goto 56;`
53:	`rad:=ac; rd;`	1111 000=PSHI
54:	`pp:=pp-1; rd;`
55:	`rad:=pp; wr; goto 10;`
56:	`rad:=pp; pp:=pp+1; rd;`	1111 001=POPI
57:	`rd;`
58:	`rad:=ac: wr: goto 10;`
59:	`ual:=rit; if n goto 62;`
60:	`pp:=pp-1;`	1111 010=PUSH
61:	`rad:=pp; rdo:=ac; wr; goto 10;`
62:	`rad:=pp; pp:=pp+1; rd;`	1111 011=POP
63:	`rd;`
64:	`ac:=rdo; goto 0;`
65:	`rit:=decalg(rit); if n goto 73;`
66:	`ual:=rit; if n goto 70;`
67:	`rad:=pp; pp:=pp+1; rd;`	1111 100=RETN
68:	`rd;`
69:	`co:=rdo; goto 0;`

70:	`a:=ac;`	1111 101=SWAP
71:	`ac:=pp;`
72:	`pp:=a; goto 0;`
73:	`ual:=rit; if n goto 76;`
74:	`a:=bet(ri,smasq);`	1111 110=INSP
75:	`pp:=pp+a; goto 0;`
76:	`a:=bet(ri,smasq);`	1111 111=DESP
77:	`a:=inv(a);`
78:	`a:=a+1; goto 75;`

0	tampon A
1	RDO

0	pas de saut
1	saut si N=1
2	saut si Z=1
3	saut sans condition