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.