4. Étape 4 : Un processeur RISC

L’architecture actuelle ne sait effectuer que des calculs linéaires (suite fixe d’instructions), sur des données potentiellement inconnues (mais dont les adresses en mémoire sont connues)

Nous allons maintenant lui ajouter des instructions de saut conditionnels (et, tant qu’on y est, inconditionnels)

4.1 Flags (ou drapeaux...)

Chaque opération (logique ou arithmétique) va positionner deux signaux appelés Flags (ou drapeaux) devant être mémorisés pour l’instruction suivante.

Ces drapeaux ne doivent être modifiés que si on modifie l’accumulateur. Ils sont nommés:

  • C (comme carry) :
    • mis à 1 si l’opération courante est une opération arithmétique et donne lieu à une retenue,
    • mis à 0 si l’opération courante est une opération arithmétique et ne donne pas lieu à une retenue,
    • mis à 0 si on fait un load
  • Z (comme zéro) :
    • mis à 1 si on charge 0 dans l’accumulateur
    • mis à 0 dans tous les autres cas.

Question 6: Implémenter la gestion des drapeaux, et rajouter deux opérations ADDC et SUBC, prenant en compte la retenue C de l’opération précédente (pour implémenter des additions / soustractions sur des grands nombres par exemple).

4.2 Sauts

Pour implémenter les sauts, on définit trois instructions supplémentaires :

  • JMP : saut inconditionnel.
    L’exécution de cette instruction fait sauter l’exécution du programme directement à une adresse donnée (passée comme opérande).
  • JNC : saut si C est nul.
    Idem à JMP, mais seulement si C est nul. Sinon, équivalent à NOP (on continue à l’adresse suivante)
  • JNZ : saut si Z est nul.
    Idem à JMP, mais seulement si Z est nul. Sinon, équivalent à NOP (on continue à l’adresse suivante)

Question 7: Modifier l’architecture du processeur pour implémenter les sauts.

Tant qu’on y est, pour disposer de pauses, on définit l’instruction NOP, qui ne fait rien.

Question 8: Comment l’implémenter de façon simple ?

On ajoute aussi deux instructions, de rotation de bits (vers la droite ou vers la gauche en incluant le bit de retenue) :

  • ROL : ACC[7:0] devient ACC[6:0],C et C devient ACC[7]
  • ROR : ACC[7:0] devient C, ACC[7:1] et C devient ACC[0]

De plus, pour tester ce processeur lors du TP, on ajoute un port de sortie : c’est un ensemble de broches dont on veut pouvoir piloter l’état (passer certaines d’entre elles à l’état haut ou bas). Pour nous, il s’agit de piloter un buzzer, donc une seule sortie suffira.

Le jeu d’instruction devient donc (tableau 1.4) :

Tableau 1.4: Nouveau jeu d'instructions
code
(binaire 8 bits)
instruction effet explication
00000000 NOP   ne fait rien !
00000001 XOR Acc = Acc XOR (AD) effectue un XOR bit à bit entre le contenu de l’accumulateur et une donnée en RAM, le résultat est stocké dans l’accumulateur
00000010 AND Acc = Acc AND (AD) effectue un ET bit à bit entre le contenu de l’accumulateur et une donnée en RAM, le résultat est stocké dans l’accumulateur
00000011 OR Acc = Acc OR (AD) effectue un OU bit à bit entre le contenu de l’accumulateur et une donnée en RAM, le résultat est stocké dans l’accumulateur
00000100 ADD Acc = Acc + (AD) additionne le contenu de l’accumulateur à une donnée en RAM, le résultat est stocké dans l’accumulateur
00000101 ADC Acc = Acc + (AD) + C additionne le contenu de l’accumulateur à une donnée en RAM et à la carry C, le résultat est stocké dans l’accumulateur
00000110 SUB Acc = Acc - (AD) soustrait du contenu de l’accumulateur une donnée en RAM, le résultat est stocké dans l’accumulateur
00000111 SBC Acc = Acc - (AD) - C soustrait du contenu de l’accumulateur une donnée en RAM et la carry C, le résultat est stocké dans l’accumulateur
00001000 ROL Acc = {Acc[6:0], C} et C = Acc[7] effectue une rotation vers la gauche des bits de l’accumulateur
00001001 ROR Acc = {C, Acc[7:1] } et C devient Acc[0] effectue une rotation vers la droite des bits de l’accumulateur
00001010 LDA Acc = (AD) charge dans l’accumulateur une donnée en RAM
00001011 STA (AD) = Acc stocke le contenu de l’accumulateur en RAM
00001100 OUT BZ = (AD)[0] Sort sur la broche BZ le bit de poids faible de la donnée en RAM, stockée à l’adresse opérande
00001101 JMP PC = AD saute à l’adresse opérande
00001110 JNC PC = AD si C=0 saute à l’adresse opérande si C est nul, ne fait rien sinon
00001111 JNZ PC = AD si Z=0 saute à l’adresse opérande si Z est nul, ne fait rien sinon

Remarques :

  • AD est le deuxième octet (en RAM) de l’instruction
  • (AD) est la valeur en RAM stockée à l’adresse AD

Question 9: Finir le processeur…