PDP-11 - Définition

Jeux d'instructions

Il y a trois jeux d'instructions possibles :

1. le jeu standard d'instruction PDP-11, dont on peut classer les instructions qui le compose en 7 catégories :
   1. Opérande unique
   2. Double opérande
   3. Branchement
   4. Sauts et sous-programmes
   5. Trappes
   6. Instructions diverses
   7. Codes conditions
2. le jeu d'instructions pour l'arithmétique flottante pour le calcul scientifique (en option)
3. le jeu d'instructions pour l'informatique de gestion (en option)

Chaque instruction spécifie une opération à effectuer, éventuellement des opérandes (registres etc.) et un mode d'adressage.

Types des données

On distingue trois classes :

• les entiers :

octet (8 bits)

mot (16 bits)

entier long (32 bits, deux registres)

• les nombres flottants (pour les modèles dotés de l'extension adéquate) :

simple précision

double précision

• chaînes de caractères

très nombreux formats différents...

Simulateurs

• SIMH est un très bon émulateur de PDP11 (modèle 11/73 sans l'option CIS).
• Ersazt-11 un autre émulateur, produit commercial sauf pour une utilisation personnelle (pédagogique).

Format des instructions

Le PDP-11 définit 7 formats. Dans tous les formats décrit ci-dessous :

• Rn désigne un registre
• mode décrit le mode d'adressage du registre Rn suivant
• source ou destination exprime lequel des opérandes sera accédé en lecture (respectivement en écriture).

Interprétation du champ mode

Le champ mode tient sur 3 bits. Par exemple une instruction à deux opérandes contient deux champs registres et deux champs mode, chacun décrivant comment interpréter le champ registre.

Si l'on considère uniquement les bits les plus à gauche (le troisième est le bit d'indirection, voir plus bas) :

• 000 adressage direct Rn : le paramètre est contenu dans le registre.
• 010 autoincrémentation (Rn)+ : le registre est interprété comme un pointeur vers une donnée en mémoire. Pui, il est incrémenté de 1 si l'instruction stipule un octet, ou de 2 si elle stipule un mot de 16 bits. Il est incrémenté de 2 pour les registres 6 et 7. (SP et PC).
• 100 autodécrémentation -(Rn). Comme ci dessus, sauf que le registre est d'abord décrémenté avant d'être utilisé comme un pointeur.
• 110 adressage indexé X(Rn) X est ajouté à Rn pour produire l'adresse de l'opérande. Cette valeur index, X, est toujours placé à l'adresse qui suit l'instruction.

Le bit le plus à droite du mode est le bit d'indirection : si ce bit est à un, l'adressage sera indirecte :

• 001 adressage indirect @Rn ou (Rn) : le registre contient l'adresse de l'opérande.
• 011 indirect autoincrémenté @(Rn)+ : le registre est utilisé comme un pointeur vers un mot contenant l'adresse de l'opérande. Le registre est incrémenté de 2.
• 101 indirect autodécrémenté @-(Rn) : comme ci dessus, sauf que le registre est préalablement décrémenté de 2.
• 111 adressage indirect indexé @X(Rn) : la valeur de X (stockée juste après l'instruction) est ajouté au contenu du registre Rn pour former l'adresse du mot contenant l'adresse de l'opérande. Ni X ni Rn ne sont modifiés.

On notera qu'il n'y a pas de mode « immédiat » : celui-ci est accompli en utilisant le mode 2 (autoincrémentation). En effet, le PC pointe vers le mot qui suit l'instruction, et la postincrémentation le fait passer à l'instruction suivante après que la valeur immédiate suivant l'instruction en cours d'exécution est chargée par le processeur.
L'utilisation du PC comme registre crée donc 4 nouveaux modes :

• 010 adressage immédiat #n : l'opérande littéral n est contenu dans le mot suivant l'instruction.
• 011 adressage absolu @#A : l'adresse A est contenu dans le mot suivant l'instruction.
• 110 adressage relatif A : on ajoute à PC + 4 la valeur du mot qui suit l'instruction.
• 111 adressage relatif indirect @A : on ajoute à PC + 4 la valeur du mot qui suit l'instruction, valeur qui sera considérée comme un pointeur vers l'opérande.

Les modes d'adressage postincrémenté et prédécrementé seront particulièrement utilisé associé au pointeur de pile SP : -(SP) permettant l'empilement et (SP)+ le dépilement.

Les instructions à un opérande

       15                                   6   5       3   2       0      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+      |             code opération            |    mode   |     Rn    |      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+                                               \_____________________/                                                     destination      

Exemple : CLR (R0) 005010

Les instructions à deux opérandes

       15               11      9   8       6   5       3   2       0      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+      | code opération|    mode   |     Rn    |    mode   |     Rn    |      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+                        \_____________________/ \_____________________/                                source               destination      

Exemple : ADD R0, (R1)

N.B. : certains instructions (ASH, ASHC, MUL, DIV) ne peuvent avoir qu'un registre comme source, dans ce cas le code opération s'étend du bit 9 au bit 15 :

       15               11      9   8       6   5       3   2       0      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+      |     code opération        |     Rn    |    mode   |     Rn    |      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+                                    \_________/ \_____________________/                                      source         destination      

Les branchements

       15                           8   7                            0      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+      | code opération|               |         déplacement           |      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+       

Le champ déplacement est signé, autorisant donc un décalage de -128 à +127 octets.

Les sauts et appels/retours de sous-programmes

Pour l'instruction JSR (Jump to Subroutine) :

       15                       9   8       6   5       3   2       0      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+      |      code opération       |     Rn    |    mode   |     Rn    |      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+                                    \_________/ \_____________________/                                      lien           destination      

Pour l'instruction RTS (Return from Subroutine) :

       15                                               3   2       0      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+      |      code opération                               |     Rn    |      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+                                                           \_________/                                                               lien       

Trappes et Interruptions

EMT, TRAP, BPT, IOT, CSM, RTI, RTT : pas de format particulier.

Codes conditions

CLC, CLV, CLZ, CLN, CCC, SEC, SEV, SEZ, SEN, SEC : pas de format particulier.

       15                                       5       3   2   1   0      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+      |                 code opération            | O | N | Z | V | C |      +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+       

• Le bit 4, O, est à un pour les instructions SET (qui positionnent les drapeaux à 1) et 0 pour les instructions CLEAR qui les mettent à zéro.
• Les quatre bits de 0 à 3 sont un masque : un 1 à une position donnée indique que l'opération (SET ou CLEAR) doit être effectuée sur ce bit.

Instructions diverses

HALT, WAIT, RESET, MTPD, MTPI, MFPD, MFPI, MTPS, MFPS, MFPT : pas de format particulier.

Jeu d'instructions nombres flottants

Cette option est appelée FPP ou FP-11, FP pour Floating Point. Elle ajoute 6 nouveaux registres 64 bits (deux fois 32) pour les calculs, ainsi que quelques autres spécialisés (comme un registre d'état). Le fonctionnement du processeur flottant est distinct du processeur standard du PDP-11 : hormis un léger retard au moment où le processeur flottant va chercher l'instruction en mémoire, les deux processeurs calculent indépendamment.

Ce nouveau jeu d'instructions est disponible par modification du microcode.

Jeu d'instructions de gestion

Appelé CIS, pour Commercial Instruction Set, ce jeu d'instructions principalement axé sur la gestion de chaînes de caractères est étudié pour accélérer les opérations habituellement demandées par les programmes de gestion (écrit en COBOL par exemple).

Il permet la conversion de la représentation de nombres sous forme de caractères vers des valeurs binaires (et inversement) ou les calculs directement sur les représentations « chaîne de caractères ».