French
DeutschPDP-11 — Wikipédia
Cet article ne cite pas suffisamment ses sources ().
Si vous disposez d'ouvrages ou d'articles de référence ou si vous connaissez des sites web de qualité traitant du thème abordé ici, merci de compléter l'article en donnant les références utiles à sa vérifiabilité et en les liant à la section « Notes et références ».
En pratique : Quelles sources sont attendues ? Comment ajouter mes sources ?
Un PDP-11 est un modèle d'ordinateur de la gamme des PDP (Programmable Data Processor) construit par Digital Equipment Corporation (DEC) entre 1970 et 1993.
Tous les PDP-11 sont 16 bits et entrent dans la classe des mini-ordinateurs. Ils furent extrêmement populaires car ils alliaient modularité et un excellent rapport qualité/prix. De fait, leur utilisation n'était pas cantonnée à un seul secteur d'application : on les retrouvait aussi bien dans les laboratoires de physique pour faire de l'acquisition de données que dans les cabinets comptables. Enfin, le monde universitaire a aussi fait l'acquisition d'un nombre important de ces machines.
Cette gamme est aussi populaire car elle a servi de base au développement du système d'exploitation Unix et du langage C. La pré-incrémentation (++i) et la post-incrémentation (i++) du C permettaient en particulier d'exploiter cette possibilité du langage-machine du PDP-11.
Elle arriva également quand l'IBM 1130 lancé en 1965, qui équipait beaucoup de laboratoires et d'écoles d'ingénieurs dans le monde, commençait à prendre de l'âge sans avoir de successeur proposé par IBM. Hormis son immense bibliothèque contributive de logiciels gratuits, le 1130 ne possédait pas d'avantage particulier sur le PDP-11 ni en vitesse, ni en coût.
Comme beaucoup d'autres, cette gamme a disparu car son espace d'adressage mémoire était trop limité (16 à 18 bits, 22 au maximum). Elle fut remplacée par les VAX, qui signifie Virtual Address eXtension (Extension de l'adressage virtuel), 32 bits. Les VAX possèdent un mode de fonctionnement « compatible PDP-11 ».
Architecture[modifier | modifier le code]
Bus[modifier | modifier le code]
Les premiers PDP-11 étaient architecturés autour du bus UNIBUS. Les derniers modèles, avec le jeu d'instruction compris sur quelques puces, et appelés LSI-11, sont basés sur le bus (moins large) appelé Q-BUS.
Registres[modifier | modifier le code]
Le processeur du PDP-11 est doté de 8 registres, dont deux ont des utilisations spéciales : le registre 7, le PC (pour Program Counter ou compteur ordinal) et le registre 6, le pointeur de pile (SP, pour Stack Pointer ). Les autres registres R0, R1, ..., R5 et sont d'un usage général. Le dernier registre est le registre d'état.
15 0 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | R0 | +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | R1 | +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | R2 | +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | R3 | +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | R4 | +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | R5 | +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | R6 (SP) | +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | R7 (PC) | +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ \_____________________________________________________________/ registres (16 bits)
15 0 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | CM | PM | R | | PRI | T | N | Z | V | C | +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ \_____________________________________________________________/ registre d'état(16 bits)
La signification des drapeaux du registre d'état sont :
- CM Current Mode, utilisateur (00), superviseur (01), noyau (11)
- PM Previous Mode, mêmes codes que ci-dessus
- R (ensemble de) Registres, utilisateur (0), superviseur (1)
- PRI niveau de priorité, entre 0 et 7
- T Trace
- NZVC codes conditions :
- N Négatif
- Z Zero
- V (oVerflow) débordement
- C (Carry) retenue
Tous les modèles de PDP-11 ne possèdent pas exactement le même type de registres d'état, celui présenté ici correspond aux modèles les plus avancés.
Types des données[modifier | modifier le code]
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
- très nombreux formats différents...
Jeux d'instructions[modifier | modifier le code]
Il y a trois jeux d'instructions possibles :
- le jeu standard d'instruction PDP-11, dont on peut classer les instructions qui le composent en sept catégories :
- Opérande unique
- Double opérande
- Branchement
- Sauts et sous-programmes
- Trappes
- Instructions diverses
- Codes conditions
- le jeu d'instructions pour l'arithmétique flottante pour le calcul scientifique (en option)
- 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.
Format des instructions[modifier | modifier le code]
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[modifier | modifier le code]
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. Puis, 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 indirect :
- 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[modifier | modifier le code]
15 6 5 3 2 0 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | code opération | mode | Rn | +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ \_____________________/ destination
Exemple : CLR (R0) 005010
Les instructions à deux opérandes[modifier | modifier le code]
15 11 9 8 6 5 3 2 0 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | code opération| mode | Rn | mode | Rn | +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ \_____________________/ \_____________________/ source destination
Exemple : ADD R0, (R1)
N.B. : certaines 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[modifier | modifier le code]
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[modifier | modifier le code]
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[modifier | modifier le code]
EMT, TRAP, BPT, IOT, CSM, RTI, RTT : pas de format particulier.
Codes conditions[modifier | modifier le code]
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[modifier | modifier le code]
HALT, WAIT, RESET, MTPD, MTPI, MFPD, MFPI, MTPS, MFPS, MFPT : pas de format particulier.
Jeu d'instructions nombres flottants[modifier | modifier le code]
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[modifier | modifier le code]
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 ».
Simulateurs[modifier | modifier le code]
- SIMH est un très bon émulateur de PDP11 (modèle 11/73 sans l'option CIS).
- Ersatz-11 un autre émulateur, produit commercial sauf pour une utilisation personnelle (pédagogique).
