Le jeu d'instructions correspond à toutes les instructions machines qu'un processeur est capable d’exécuter. Il définit quelles sont les instructions supportées par le processeur et quels sont les registres du processeur manipulables par le programmeur.

La plupart des programmes sont écrit dans des langages de haut niveau (Python, Java, C++, ...). Ces programmes sont traduits en langage machine directement exécutable par le processeur (010001110 ...) par l'intermédiaire d'un langage assembleur (jeu d'instructions). Il existe aussi un intermédiaire binaire supplémentaire appelé bytecode pour certains langage de haut-niveau comme le Python, on parle alors de langages semi-interprétés.

Ces instructions permettent d'effectuer des opérations élémentaires (circuits logiques et leur association, ... ) ou plus complexes.

 

 

Opérations élémentaires

 

Fonctions booléennes élémentaires (algèbre de Boole)

 

Un booléen est une variable qui ne peut prendre que 2 valeurs VRAI (1 en binaire) ou FAUX (0 en binaire) ce qui correspond donc à un bit.

Une fonction booléenne est une fonction prend en paramètres (opérandes) des booléens (entrée) et renvoie un ou des booléens (sortie).

 

On définit les fonctions suivantes avec VRAI=1 et FAUX=0 . Les opérandes sont A et B .

 

  • AND (ET) : renvoie 1 si A=1 ET B=1 (sinon renvoie 0)
  • OR (OU) : renvoie 1 si au moins A=1 OU B=1 (sinon renvoie 0)
  • XOR(OU exclusif) : renvoie 1 si A=1 et B=0 OU B=1 et A=0 (sinon renvoie 0)
  • NON : renvoie 1 si A=0, 0 si A=1 (1 seul booléen d’entrée)
  • NAND (NON-ET) : renvoie 1 si au moins A=0 OU B=0 (sinon renvoie 0)
  • NOR (NON-OU) : renvoie 1 si A=0 ET B=0 (sinon renvoie 0)
  • XNOR (identité) : renvoie 1 si les 2 booléens sont identiques

 

 

On peut représenter ces règles de manière arithmétique sous forme de table de vérité :

 

 

Circuits logiques

 

On représente également ces fonctions booléennes sous forme graphique que l'on peut combiner pour créer des fonctions plus complexes.

 

 

Ces circuits sont combinatoires, leurs résultats ne dépendent que des des données entrées.

Si les résultats dépendent également de  l'état antérieur des données entrées, ces circuits sont séquentiels.

Ces circuits séquentiels sont utilisés pour les mémoires d'ordinateur, ce sont les bascules.

 

Reprenons l'exemple de l'addition de deux nombres binaires également vu dans la partie algorithmes :

 

 

Représentez le circuit logique qui donne le résultat de l'addition des 2 bits de poids le plus faible (rang 0) ainsi que la retenue.

Complétez ce circuit avec le rang 1 et la nouvelle retenue.

 

 

Les langages informatiques

 

Il existe plusieurs catégories de langages informatiques :

 

  • langages de haut-niveau

Les langages de haut-niveau peuvent être interprétés comme le PHP (programmes transformés en langage machine en cours d'exécution) ou compilé comme le C++ (programmes transformés en langage machine avant l'exécution). Le langage Python est semi-interprété car le code passe par un intermédiaire binaire supplémentaire : le bytecode.

 

  • langages assembleur

Les langages assembleur, de bas-niveau, sont propres à chaque type de processeur. Ils sont écrits à l'aide de notations symboliques qui remplacent des séquences binaire (LD pour load, STO pour store, XOR (fonction logique) ...).

L'ensemble de ces notations forme le jeu d'instruction. L'exécution d'une instruction se déroule en 3 temps : chargement, décodage, exécution. Les opérations sont réalisés par UAL (unité arithmétique et logique).

 

  • langage machine

Le langage machine (niveau le plus bas) est écrit à l'aide de séquence binaire (0001101001111 ...)

 

 

 

 

Les langages assembleur - Jeu d'instructions

 

Chaque processeur, ou unité de contrôle UC, possède son jeu d'instructions. Les opérations sont exécutées par l'UAL (unité arithmétiques et logiques).

 

Les exemples qui vont suivre correspondent au vieux processeur MOTOROLA 6809 (UC de la fin des années 1970) qui  possède peu instructions par rapport aux processeurs récents.

Les processeurs récents sont plus complexes mais reposent sur les mêmes principes.

 

À tire indicatif, le 6809 possède 59 instructions (plus de 1460 instructions avec toutes les combinaisons) et il comprend 2 bus et 9 registres accessibles par l'utilisateur, l'instruction est stockée dans un registre instruction :

  • Un bus Data (bus de données) sur 8 bits
  • Un bus d'adresse sur 16 bits permettant un adressage mémoire de 64 Ko
  • Deux registres accumulateurs (servent à stocker les intermédiaires entre le bus de données et l'UAL) de 8 bits "A" et "B" transformables en 1 accumulateur de 16 bits "D"
  • Deux registres d'adressage ou d'index  de 16 bits "X" et "Y". Ils servent à stocker les adresses mémoire vive des cases qui contiennent ou qui serviront à contenir des données. On dit qu'il pointe des données.
  • Deux registres de commande  pointeur de pile "U" (utilisateur) et "S" (système). S est utilisé par le processeur lui-même pour gérer la sauvegarde de ses registres pendant l'éxecution de sous programmes (fonctions) et U par le programmeur pour le passage d'arguments vers des sous-programmes.
  • Un registre pointeur de page "DP" de 8 bits servant à l'adressage direct de la mémoire sous contrôle du logiciel et pas du processeur.
  • Un registre de commande d'état "CC" sur 8 bits. Par exemple,le bit de rang 2 (dit Z) est mis à 1 si le résultat de la dernière opération est nulle, le bit de rang 3 (dit N) est mis à 1 si le résultat est négatif.
  • Un registre pointeur compteur de programme sur 16 bits "PC" pointant toujours sur l'adresse de l'instruction que le microprocesseur doit exécuter. Il donne la séquence d'instructions à exécuter.

 

Les lectures et écritures en mémoire vive et dans les registres sont synchronisées par l'horloge.

 

Si l'accumulateur B doit stocker la donnée stockée en mémoire vive à l'adresse 101, le bus d'adresse se met dans l'état correspondant à 101. Les cases mémoires comparent leur adresse à cette dernière lorsque l'horloge en donne le signal. La case d'adresse 101 se reconnaît et le bus de données se met dans l'état correspondant à son contenu. Ce contenu est alors stocké dans l'accumulateur B.

 

Les instructions sont appelées mnémoniques car leur noms permettent de retrouver facilement ce qu'elles effectuent (en anglais cependant).

 

Il existe plusieurs catégories d'instructions. En s'inspirant du processeur 6809, on peut citer entre autres :

 

  • exemples d'instructions de transfert de données

Les instructions de transferts de données permettent ces derniers entre les registres internes, entre les registres internes et la mémoire vive, entre les registres d'adressages (pointeurs)

 

Quelques exemples :

L'instruction LDR X (de l'anglais load) permet par exemple de charger une donnée à l'adresse X de la mémoire dans un registre R.

Exemple : LDA 101 charge dans le registre A la donnée stockée à l'adresse 101 de la mémoire.

 

L'instruction STR X (de l'anglais store) permet de stocker la donnée d'un registre R à l'adresse X de la mémoire.

Exemple : STB 111 stocke la donnée du registre B à l'adresse 111 de la mémoire.

 

 

  • exemples d'instructions de traitement de données

Les instructions de traitement de données comprennent entre autres : les opérations arithmétiques, les opérations logiques, les opérations de déplacement de bits dans un registre

 

Quelques exemples :

L'instruction ADDR X permet par exemple l'addition du contenu stocké à l'adresse X au contenu du registre R. Le résultat est stocké dans le registre Y.

Exemple : ADDB 10 additionne le contenu stocké dans la mémoire à l'adresse 10 au contenu du registre B. Le résultat est stocké dans le registre B.

 

L'instruction AR1 R2 permet l'addition du contenu du registre R1 au contenu du registre R2. Le résultat est stocké dans le registre R2.

Exemple : AA B additionne le contenu du registre A au contenu du registre B. Le résultat est stocké dans le registre B.

 

L'instruction EORR X permet l'opération logique XOR du contenu du registre R avec le contenu stocké en mémoire à l'adresse X. Le résultat est stocké dans le registre R.

 

 

  • exemples d'instructions de décrémentation (-1), d'incrémentation (+1) et de remise à zéro

 

Quelques exemples :

L'instruction CLR R remet à zéro le registre R.

Exemple : CLR B remet à zéro le registre B.

 

L'instruction INC R incrémente le (ajoute 1 au) contenu du registre R

Exemple : INC A incrémente le contenu du registre A.

 

L'instruction DEC R décrémente le (retranche 1 au) contenu du registre R

Exemple : DEC A décrémente le contenu du registre A.

 

  • exemples d'instructions de branchement (ou saut)

Une instruction de branchement donne l'adresse mémoire où il faut aller ("sauter pour") chercher une instruction.

 

Quelques exemples :

L'instruction JMP X effectue un branchement (ou saut) à l'instruction stockée en mémoire vive à l'adresse X

Exemple : JMP 146 effectue un branchement à l'instruction stockée en mémoire à l'adresse 146 (146 est bien entendu donné en binaire).

 

L'instruction BEQ X effectue un branchement (ou saut) à l'instruction stockée en mémoire vive à l'adresse X si le résultat de la dernière instruction est égale à zéro. Le bit Z du registre CC est donc égale à 1.

Exemple : BEQ 111 effectue un branchement à l'instruction stockée en mémoire à l'adresse 111 si le résultat de la dernière instruction est égale à zéro (si le bit Z du registre CC est égale à 1).

 

L'instruction BNE X effectue un branchement (ou saut) à l'instruction stockée en mémoire vive à l'adresse X si le résultat de la dernière instruction est différent de zéro. Le bit Z du registre CC est donc égale à 0.

Exemple : BNE 101 effectue un branchement à l'instruction stockée en mémoire à l'adresse 101 si le résultat de la dernière instruction est différent de zéro (si le bit Z du registre CC est égale à 0).

 

 

Le langage machine

 

Tout ce que nous avons précédemment doit être traduit en binaire : les adresses mémoires (gérées par les registres X,Y,U et S), les données (dans les registres A et B ou en mémoire vive) et les instructions (pointées par le registre PC).

Il faut donc numéroter chaque registre et chaque instruction. De cette, manière tout ne sera que binaire (registres, instructions et données elle-même codé en binaire que ce soit des nombres, des caractères, des images, ... )

Par exemple, nous pourrions imaginer pour le processeur 6809, en utilisant une numérotation décimale choisie arbitrairement pour l'exemple pour davantage de clarté :

- registres :

1 pour le registre A , 2 pour le registre B

- instructions :

Dans l'ordre des exemples de la partie précédente : 221 pour LDA, 222 pour LDB, 223 pour STA, 224 pour STB, 225 pour ADDA, 226 pour ADDB , 227 pour AA, 228 pour AB , 229 pour EORA, 230 pour EORB, 231 pour CLR,  232 pour INC, 233 pour DEC, 234 pour JMP, 235 pour BEQ, 236 pour BNE.

 

Le processeur va par exemple, pour dérouler une séquence, prendre une instruction à une adresse (donnée par PC), prendre comme argument de l'instruction ce qui est stocké aux n adresses (certaines instructions ont n opérandes suivant leur type) qui suivent directement et recommencer de la même manière à l'adresse PC+n+1 si l'instruction n'est pas un branchement (ou saut) et ainsi de suite. Cela donne :

- chargement dans le registre instruction du contenu stocké en mémoire à l'adresse donnée par le registre PC et dans les registres A et/ou B des contenus (les opérandes) n adresses après PC.

- décodage du contenu du registre  instruction et du contenu du registre B comme son argument.

- exécution de l'instruction.

- incrémentation de PC de 2 si l'instruction n'est pas un saut.

 

Nous allons voir comment nous passons de l'algorithme d'un langage de haut-niveau à son équivalent en assembleur puis en langage machine (en décimale avec le choix arbitraire fait plus haut).

 

  • algorithme :

Additionner la valeur stockée en mémoire vive à l'adresse 134 à la valeur stockée en mémoire vive à l'adresse 143. Si le résultat est 1, ajouter le contenu stockée à l'adresse 189, sinon ajouter le contenu stockée à l'adresse 177. Sockée le nouveau résultat à l'adresse 150.

 

  • assembleur :

valeur de PC - instruction à l'adresse PC - argument à l'adresse PC + 1 (Rappel : PC est le registre qui pointe vers l'instruction à exécuter)

1 LDA 134 charge dans le registre A le contenu stocké à l'adresse 134

3 ADDA 143 ajoute au contenu du registre A le contenu stocké à l'adresse 143. Le résultat est stocké dans A. (on effectue la première addition)

5 DEC retranche 1 au contenu du registre A. (Si le résultat de l'addition est 1, on a maintenant 0 dans A)

7 BEQ 15 saut à l'instruction à l'adresse 15 si le résultat de la dernière instruction est 0 (et donc, si le résultat de l'instruction à l'adresse 3 est 1)

9 INC A rajoute la valeur 1 qui avait été enlevé à l'instruction à l'adresse 5

11 LDB 177 charge dans le registre B le contenu stocké à l'adresse 177          Les instructions des adresses 9 et 11 sont exécutées si le résultat de l'adresse 3 est différent de 1

13 JMP 19 saut  inconditionnel à l'instruction à l'adresse 19

15 INC A rajoute la valeur 1 qui avait été enlevé à l'instruction à l'adresse 5

17 LDB 189 charge dans le registre B le contenu stocké à l'adresse 189          Les instructions des adresses 15 et 17 sont exécutées si le résultat de l'adresse 3 est différent de 1

19 AA B additionne le contenu de B et A. Le résultat est stocké dans le registre B. (on effectue la deuxième addition)

21 STB 150 stocke le contenu de B dans la mémoire vive à l'adresse 150

 

 

  •  langage machine (avec le choix arbitraire fait plus haut et à écrire en binaire normalement)

Rappel des numérotations :

- registres :

1 pour le registre A , 2 pour le registre B

- instructions :

Dans l'ordre des exemples de la partie précédente : 221 pour LDA, 222 pour LDB, 223 pour STA, 224 pour STB, 225 pour ADDA, 226 pour ADDB , 227 pour AA, 228 pour AB , 229 pour EORA, 230 pour EORB, 231 pour CLR,  232 pour INC, 233 pour DEC, 234 pour JMP, 235 pour BEQ, 236 pour BNE.

 

valeur de PC - instruction à l'adresse PC - argument à l'adresse PC + 1

221 134

225 143

233 1

235 15

232 1

11 222 177

13 234 19

15 232 1

17 222 189

19 227 2

21 224 150

 

Free Joomla! template by L.THEME