Etape 5 : Les alias, ou le jeu d'instruction du programmeur
Comme nous l'avons vu le jeu d'instruction précédemment décrit est minimaliste, il ne comporte que 20 instructions différentes pour réaliser l'ensemble des opérations du processeur. Nous allons donc maintenant décrire un second niveau de jeu d'instruction destiné au programmeur. Ce jeu étend simplement celui précédemment décrit en ajoutant des alias comme nous en avons déjà rencontré sur l'instruction ADDd Rdd, Rnn,-vv qui devient SUBd Rdd, Rnn, vv. Le but de cette description est de normaliser l'assembleur qui sera utilisé par les programmeurs.
Instructions de lecture / écriture :
LOADd Rdd, Dir16, mode :
LOADd Rdd,dir16 => LOADd Rdd,dir16,unsigned LOADds Rdd,dir16 => LOADd Rdd,dir16,signed LOADdl Rdd,dir16 => LOADd Rdd,dir16,low LOADdh Rdd,dir16 => LOADd Rdd,dir16,high
LOADm Rdd, &Rnn, mode :
LOADm Rdd, (uchar)&Rnn => LOADm Rdd,&Rmm,8u LOADm Rdd, (char)&Rnn => LOADm Rdd,&Rmm,8s LOADm Rdd, (uword)&Rnn => LOADm Rdd,&Rmm,16u LOADm Rdd, (word)&Rnn => LOADm Rdd,&Rmm,16s LOADm Rdd, &Rnn => LOADm Rdd,&Rmm,32
LOADr Rdd, Rnn, mode :
LOADr Rdd, (uchar)Rnn => LOADr Rdd,Rnn,8u LOADr Rdd, (char)Rnn => LOADr Rdd,Rnn,8s LOADr Rdd, (uword)Rnn => LOADr Rdd,Rnn,16u LOADr Rdd, (word)Rnn => LOADr Rdd,Rnn,16s LOADr Rdd, Rnn => LOADr Rdd,Rnn,32
STORE &Rdd, Rnn, mode :
STORE &Rmm, (char)Rnn => STORE &Rmm,Rnn,8 STORE &Rmm, (word)Rnn => STORE &Rmm,Rnn,16 STORE &Rmm, Rnn => STORE &Rmm,Rnn,32
Les rotations :
ROT Rdd, Rnn, step, dir, mode :
Pour toutes les rotations / décallage, l'absence de step dans un alias indique la valeur 1.
ROL Rdd, Rnn,step => ROT Rdd,Rnn,step,left,rot ROR Rdd, Rnn,step => ROT Rdd,Rnn,step,right,rot RZL Rdd, Rnn, step => ROT Rdd,Rnn,step,left,zero RZR Rdd, Rnn, step => ROT Rdd,Rnn,step,right,zero R1L Rdd, Rnn, step => ROT Rdd,Rnn,step,left,one R1R Rdd, Rnn, step => ROT Rdd,Rnn,step,right,one RCL Rdd, Rnn => ROT Rdd,Rnn,1,left,carry RCR Rdd, Rnn => ROT Rdd,Rnn,1,right,carry RSR Rdd, Rnn => ROT Rdd,Rnn,1,right,sign
Les opérateurs arithmétiques :
ADDr Rdd, Rnn, Rmm, mode :
ADDr Rdd, Rnn, Rmm => ADDr Rdd, Rnn, Rmm, + ADCr Rdd, Rnn, Rmm => ADDr Rdd, Rnn, Rmm, c+ SUBr Rdd, Rnn, Rmm => ADDr Rdd, Rnn, Rmm, - SUCr Rdd, Rnn, Rmm => ADDr Rdd, Rnn, Rmm, c- CPMr Rnn, Rmm => ADDr R02, Rnn, Rmm, c
ADDd Rdd, Rnn, dir16 :
SUBd Rdd, Rnn, dir16 => ADDd Rdd, Rnn, -dir16
MUL Rdd, Rnn, Rmm, mode :
MUL Rdd, Rnn, Rmm => MUL Rdd, Rnn, Rmm, unsigned MULs Rdd, Rnn, Rmm => MUL Rdd, Rnn, Rmm, signed
DIV Rdd, Rnn, Rmm, mode, type :
DIV Rdd, Rnn, Rmm => DIV Rdd, Rnn, Rmm, unsigned, normal DIVs Rdd, Rnn, Rmm => DIV Rdd, Rnn, Rmm, signed, normal IDIV Rdd, Rnn, Rmm => DIV Rdd, Rnn, Rmm, unsigned, result IDIVs Rdd, Rnn, Rmm => DIV Rdd, Rnn, Rmm, signed, result MOD Rdd, Rnn, Rmm => DIV Rdd, Rnn, Rmm, unsigned, rest MODs Rdd, Rnn, Rmm => DIV Rdd, Rnn, Rmm, signed, rest
Les sauts conditionnels :
JB mode, Rnn, bit, val, adresse :
Suite, principalement, à une comparaison :
- JSL : Saut si Rnn < Rmm avec Rnn et Rmm signés
- JSLE : Saut si Rnn <= Rmm avec Rnn et Rmm signés
- JSG : Saut si Rnn > Rmm avec Rnn et Rmm signés
- JSGE : Saut si Rnn >= Rmm avec Rnn et Rmm signés
- JL, JLE, JG, JGE : Idem avec Rmm et Rnn non signés
JB Rnn, bit, value, adresse => JB bit, Rnn, bit, value, adresse JZ adresse => JB bit, R02, 0, 1, adresse JNZ adresse => JB bit, R02, 0, 0, adresse JS adresse => JB bit, R02, 3, 1, adresse JNS adresse => JB bit, R02, 3, 0, adresse JC adresse => JB bit, R02, 9, 1, adresse JNC adresse => JB bit, R02, 9, 0, adresse JO adresse => JB bit, R02, 6, 1, adresse JNO adresse => JB bit, R02, 6, 0, adresse JSG adresse => JB G, R02, 0, 0, adresse JSGE adresse => JB G, R02, 11, 0, adresse JSL adresse => JB LE, R02, 11, 1, adresse JSLE adresse => JB LE, R02, 0, 1, adresse JG adresse => JB -Z, R02, 9, 0, adresse JGE adresse => JB bit, R02, 9, 0, adresse JL adresse => JB bit, R02, 9, 1, adresse JLE adresse => JB +Z, R02, 9, 1, adresse
Le retour d'une procedure :
RET :
RET => POP R00
C'est donc une soixantaine d'instructions en plus que le programmeur pourra utiliser pour écrire plus simplement ses programme. Nous sommes face (pour schématiser) à la différence qu'il y a entre langage machine (codage binaire des instructions) et assembleur (codage humain de ses mêmes instructions). Les assembleurs devront être capable de traduire toutes les instructions vues précédemment pour générer le code machine exécutable.
Maintenant, nous allons commencer à définir l'architecture matérielle du processeur SC91-A pour préparrer son implémentation.