Instructions arithmétiques et logiques
Gameboj – Étape 4

2.2.1 Conseils de programmation

1. Gestion des instructions préfixées
   

   Certaines des instructions à traiter dans le cadre de cette étape sont préfixées, c-à-d que leur encodage commence par un octet constant et valant CB₁₆ (le préfixe) suivi de l'octet qui constitue l'opcode réel de l'instruction.

   Cela complique légèrement le processus de décodage d'une instruction, car il n'est plus possible de l'effectuer uniquement au moyen du premier octet. En effet, si celui-ci est égal au préfixe, il faut utiliser le second octet.

   Cela dit, une fois cette petite distinction faite, il est aussi possible d'utiliser une table pour trouver l'objet Opcode correspondant à une instructions préfixée. En effet, l'énumération Opcode contient également des éléments correspondant aux instructions préfixées, qui sont identifiés par leur sorte (kind), qui vaut PREFIXED. Pour ces instructions, la valeur stockée dans l'attribut encoding est bien entendu le second octet de leur encodage, celui qui suit le préfixe.

   Si vous avez suivi nos conseils de programmation donnés à l'étape précédente, une table dédiée aux instructions préfixées peut se construire très facilement ainsi :

   private static final Opcode[] PREFIXED_OPCODE_TABLE =
     buildOpcodeTable(Opcode.Kind.PREFIXED);
   

2. Augmentation de la méthode dispatch
   

   Bien entendu, la gestion des nouvelles instructions se fait en augmentant le switch de la méthode dispatch afin d'y ajouter les familles d'instructions décrites plus bas. Pour faciliter votre travail, nous vous fournissons ci-dessous la liste des cas à traiter pour cette étape sous la forme de code Java que vous pouvez simplement copier dans votre projet.

   // Add
   case ADD_A_R8: {
   } break;
   case ADD_A_N8: {
   } break;
   case ADD_A_HLR: {
   } break;
   case INC_R8: {
   } break;
   case INC_HLR: {
   } break;
   case INC_R16SP: {
   } break;
   case ADD_HL_R16SP: {
   } break;
   case LD_HLSP_S8: {
   } break;
   
   // Subtract
   case SUB_A_R8: {
   } break;
   case SUB_A_N8: {
   } break;
   case SUB_A_HLR: {
   } break;
   case DEC_R8: {
   } break;
   case DEC_HLR: {
   } break;
   case CP_A_R8: {
   } break;
   case CP_A_N8: {
   } break;
   case CP_A_HLR: {
   } break;
   case DEC_R16SP: {
   } break;
   
   // And, or, xor, complement
   case AND_A_N8: {
   } break;
   case AND_A_R8: {
   } break;
   case AND_A_HLR: {
   } break;
   case OR_A_R8: {
   } break;
   case OR_A_N8: {
   } break;
   case OR_A_HLR: {
   } break;
   case XOR_A_R8: {
   } break;
   case XOR_A_N8: {
   } break;
   case XOR_A_HLR: {
   } break;
   case CPL: {
   } break;
   
   // Rotate, shift
   case ROTCA: {
   } break;
   case ROTA: {
   } break;
   case ROTC_R8: {
   } break;
   case ROT_R8: {
   } break;
   case ROTC_HLR: {
   } break;
   case ROT_HLR: {
   } break;
   case SWAP_R8: {
   } break;
   case SWAP_HLR: {
   } break;
   case SLA_R8: {
   } break;
   case SRA_R8: {
   } break;
   case SRL_R8: {
   } break;
   case SLA_HLR: {
   } break;
   case SRA_HLR: {
   } break;
   case SRL_HLR: {
   } break;
   
   // Bit test and set
   case BIT_U3_R8: {
   } break;
   case BIT_U3_HLR: {
   } break;
   case CHG_U3_R8: {
   } break;
   case CHG_U3_HLR: {
   } break;
   
   // Misc. ALU
   case DAA: {
   } break;
   case SCCF: {
   } break;
   

3. Familles
   

   Dans le but de simplifier la mise en œuvre de la classe Cpu, les instructions ont été regroupées en familles, comme cela a été expliqué à l'étape précédente. Les familles qui ne requièrent pas d'explication particulière sont listées dans la table ci-dessous, similaire à celle donnée à l'étape précédente.

   Famille	Instruction(s) en assembleur
   INC_R8	INC A / INC B / … / INC L
   INC_HLR	INC [HL]
   INC_R16SP	INC BC / INC DE / INC HL / INC SP
   ADD_HL_R16SP	ADD HL, BC / ADD HL, DE / … / ADD HL, SP
   DEC_R8	DEC A / DEC B / … / DEC L
   DEC_HLR	DEC [HL]
   DEC_R16SP	DEC BC / DEC DE / DEC HL / DEC SP
   CP_A_N8	CP A, 0 / CP A, 1 / … / CP A, $FF
   CP_A_R8	CP A, A / CP A, B / … / CP A, L
   CP_A_HLR	CP A, [HL]
   AND_A_N8	AND A, 0 / AND A, 1 / … / AND A, $FF
   AND_A_R8	AND A, A / AND A, B / … / AND A, L
   AND_A_HLR	AND A, [HL]
   OR_A_N8	OR A, 0 / OR A, 1 / … / OR A, $FF
   OR_A_R8	OR A, A / OR A, B / … / OR A, L
   OR_A_HLR	OR A, [HL]
   XOR_A_N8	XOR A, 0 / XOR A, 1 / … / XOR A, $FF
   XOR_A_R8	XOR A, A / XOR A, B / … / XOR A, L
   XOR_A_HLR	XOR A, [HL]
   CPL	CPL
   ROTCA	RLCA / RRCA
   ROTA	RLA / RRA
   ROTC_R8	RLC A / RRC A / … / RLC L / RRC L
   ROT_R8	RL A / RR A / … / RL L / RR L
   ROTC_HLR	RLC [HL] / RRC [HL]
   ROT_HLR	RL [HL] / RR [HL]
   SWAP_R8	SWAP A / SWAP B / … / SWAP L
   SWAP_HLR	SWAP [HL]
   SLA_R8	SLA A / SLA B / … / SLA L
   SRA_R8	SRA A / SRA B / … / SRA L
   SRL_R8	SRL A / SRL B / … / SRL L
   SLA_HLR	SLA [HL]
   SRA_HLR	SRA [HL]
   SRL_HLR	SRL [HL]
   BIT_U3_R8	BIT 0, A / BIT 1, A / … / BIT 7, L
   BIT_U3_HLR	BIT 0, [HL] / BIT 1, [HL] / … / BIT 7, [HL]
   DAA	DAA

   Les familles restantes sont décrites plus en détail dans les sections suivantes.

4. Familles des additions et soustractions
   

   Les familles des additions et soustractions contiennent à la fois les instructions d'additions/soustractions « normales » et celles avec retenue/emprunt. Par exemple, la famille ADD_A_N8 contient les deux instructions suivantes :

   ADD A, n8
   ADC A, n8
   

   La raison de ce choix est que toutes les deux peuvent être mises en œuvre au moyen d'un appel à la méthode add de la classe Alu qui prend trois arguments. La valeur du dernier de ces arguments, qui représente la valeur initiale de la retenue, peut être déterminé au moyen de deux bits : le bit 3 de l'encodage l'opcode, et le fanion C.

   En effet, en comparant l'encodage de l'opcode des deux instructions susmentionnées, vous verrez qu'il ne diffère qu'au niveau du bit 3, qui vaut 0 pour l'instruction ADD et 1 pour l'instruction ADC. Dès lors, la valeur du dernier argument à passer à la méthode add est donnée par la table suivante, où les colonnes représentent les deux valeurs possibles du bit 3 de l'opcode et les lignes représentent les deux valeurs possibles du fanion C.

   	0	1
   0	0	0
   1	0	1

   Cette propriété est également vraie pour les instructions de soustraction et s'applique donc aux familles ADD_A_R8, ADD_A_N8, ADD_A_HLR, SUB_A_R8, SUB_A_N8 et SUB_A_HLR.

5. Famille des instructions de manipulation du fanion C
   

   Une propriété très similaire à celle des instructions d'addition et de soustraction existe pour les instructions qui manipulent le fanion C, à savoir SCF et CCF. Pour cette raison, elles ont également été regroupées dans une famille, nommée SCCF.

   En comparant l'encodage de leur opcode, vous verrez que la nouvelle valeur du fanion C peut se déterminer en fonction du bit 3 de l'opcode et de la valeur actuelle du fanion C, selon la table suivante :

   	0	1
   0	1	1
   1	1	0

   Observez que cette table est l'exact complément de la précédente.

6. Famille des additions aux pointeur de pile
   

   La famille LD_HLSP_S8 contient les deux instructions suivantes :

   ADD SP, e8
   LD HL, SP + e8
   

   On pourrait penser que ces instructions sont totalement différentes, mais ce n'est pas le cas car les deux :

   1. lisent la valeur 8 bits suivant leur opcode,
   2. interprétent cette valeur comme une valeur signée, en complément à deux (!),
   3. ajoutent cette valeur signée à la valeur actuelle du registre SP,
   4. modifient les fanions selon le schéma 00HC, où la valeur des fanions H et C est celle correspondant à l'addition des 8 bits de poids faible des deux arguments,
   5. stockent le résultat de cette addition.

   La seule différence est que l'instruction ADD stocke le résultat dans le registre SP, tandis que LD le stocke dans la paire de registres HL. En comparant l'encodage de l'opcode de ces deux instructions, on constate que le bit 4 permet de déterminer si le résultat doit être stocké dans SP (s'il vaut 0) ou HL (s'il vaut 1).

7. Famille des modifications de bits
   

   Les instruction RES et SET permettent respectivement de mettre à 0 ou à 1 un bit donné d'une valeur. Vu leur similarité, il paraît raisonnable de les placer dans des familles communes, que nous avons choisi de nommer CHG (pour change). Il existe deux de ces familles, la première qui modifie un bit d'une valeur stockée dans un registre, la seconde qui modifie un bit d'une valeur stockée en mémoire. La table ci-dessous les décrit.

   Famille	Instruction(s) en assembleur
   CHG_U3_R8	RES 0, A / SET 0, A / … / SET 7, L
   CHG_U3_HLR	RES 0, [HL] / SET 0, [HL] / … / SET 7, [HL]

   En examinant l'encodage des instructions RES et SET, vous verrez que le bit 6 de leur opcode est celui qui permet de les distinguer : il vaut 0 pour les instructions RES, 1 pour les instructions SET.

8. Gestion des fanions
   

   La gestion des fanions stockés dans le registre F constitue l'une des principales difficultés de cette étape. En effet, la manière dont les fanions produits par l'UAL doivent être combinés avec ceux stockés dans le registre F est complexe et varie d'une instruction à l'autre.

   Pour mémoire, l'UAL est modélisée dans ce projet par la classe Alu dont les méthodes retournent conceptuellement une paire composée du résultat de l'opération et des 4 fanions. Les éléments de cette paire sont empaquetés dans un entier de type int. Il est donc avantageux d'offrir, dans la classe Cpu, des méthodes privées prenant un tel entier et stockant certains de ses éléments à différents endroits. Les méthodes suivantes couvrent les cas les plus fréquents (l'argument vf est toujours un entier contenant une paire valeur/fanions retournée par l'une des méthodes de la classe Alu) :

   • void setRegFromAlu(Reg r, int vf), qui extrait la valeur stockée dans la paire donnée et la place dans le registre donné,
   • void setFlags(int valueFlags), qui extrait les fanions stockés dans la paire donnée et les place dans le registre F,
   • void setRegFlags(Reg r, int vf), qui combine les effets de setRegFromAlu et setFlags,
   • void write8AtHlAndSetFlags(int vf), qui extrait la valeur stockée dans la paire donnée et l'écrit sur le bus à l'adresse contenue dans la paire de registres HL, puis extrait les fanions stockés dans la paire et les place dans le registre F.

   Ces méthodes ne sont malheureusement pas utilisables directement pour les instructions qui ne modifient qu'un sous-ensemble des fanions stockés dans le registre F. Pour ces instructions-là, il est utile d'offrir une méthode permettant de combiner arbitrairement les 4 fanions retournés par l'UAL avec ceux stockés dans le registre F, en ayant de plus la possibilité de les forcer à une valeur donnée. Cette méthode pourrait ressembler à :

   • void combineAluFlags(int vf, FlagSrc z, FlagSrc n, FlagSrc h, FlagSrc c), qui combine les fanions stockés dans le registre F avec ceux contenus dans la paire vf, en fonction des quatre derniers paramètres, qui correspondent chacun à un fanion, et stocke le résultat dans le registre F.

   Le type FlagSrc est un type énuméré contenant 4 valeurs qui correspondent aux 4 sources possible d'un fanion, et qui sont :

   • V0, qui force le fanion à 0,
   • V1, qui force le fanion à 1,
   • ALU, qui utilise le fanion fourni par l'UAL (contenu dans vf),
   • CPU, qui utilise le fanion du processeur (contenu dans le registre F).

   Par exemple l'appel

   combineAluFlags(vf,
   		FlagSrc.ALU,    // Z
   		FlagSrc.V1,     // N
   		FlagSrc.ALU,    // H
   		FlagSrc.CPU);   // C
   

   modifie le registre F pour que le fanion N vaille 1, les fanions Z et H soient ceux contenus dans vf, tandis que le fanion C est laissé à sa valeur actuelle. Un tel appel est utile dans la mise en œuvre de toute instruction dont l'effet sur les fanions est décrit par Z1H- selon la notation utilisée plus haut, par exemple DEC [HL].

9. Extraction de paramètres
   

   Tout comme pour l'étape précédente, il est conseillé de définir des méthodes permettant d'extraire certains paramètres d'un ou plusieurs bits de l'opcode d'une instruction. Pour les familles d'instructions décrites ci-dessus, des méthodes permettant d'extraire les informations suivantes sont utiles :

   • la direction de rotation (bit 3), pour toutes les familles regroupant des instructions de rotation à gauche et à droite,
   • l'index du bit à tester ou modifier (bits 3 à 5), pour les instructions BIT, RES et SET,
   • la valeur à attribuer au bit (bit 6) à modifier, pour les instructions RES et SET.

   De plus, écrire une fonction permettant de combiner le fanion C et le bit 3 de l'opcode selon l'une des deux tables données plus haut (aux §2.2.1.4 et §2.2.1.5) permet de simplifier la gestion des instructions d'addition, de soustraction et de manipulation du fanion C.