[Z8] Fix CALL #IA parsing

Author: tgtakaoka

src/asm_z8.cpp

@@ -342,8 +342,10 @@ void AsmZ8::encodeRegAddr(AsmInsn &insn, OprPos pos, const Operand &op) const {
 }
 
 void AsmZ8::encodeImmediate(AsmInsn &insn, AddrMode mode, OprPos pos, const Operand &op) const {
-    if (mode == M_IM && overflowUint8(op.val16))
+    if ((mode == M_IM || mode == M_IA) && overflowUint8(op.val16))
         insn.setErrorIf(op, OVERFLOW_RANGE);
+    if (mode == M_IA && op.val16 % 2)
+        insn.setErrorIf(op, OPERAND_NOT_ALIGNED);
     auto val16 = op.val16;
     if (insn.opCode() == TableZ8::SRP) {
         const auto postFormat = insn.postFormat();
@@ -374,6 +376,7 @@ void AsmZ8::encodeOperand(AsmInsn &insn, AddrMode mode, OprPos pos, const Operan
     case M_IM:
     case M_IMb:
     case M_IML:
+    case M_IA:
         encodeImmediate(insn, mode, pos, op);
         break;
     case M_r:

src/dis_z8.cpp

@@ -246,12 +246,14 @@ void DisZ8::decodeImmediate(DisInsn &insn, StrBuffer &out, Operand &op) const {
         if (postFormat == PF2_0 || postFormat == PF2_1 || postFormat == PF2_2)
             op.val16 &= ~3;
     }
+    if (op.mode == M_IA && op.val16 % 2)
+        insn.setErrorIf(out, OPERAND_NOT_ALIGNED);
     out.letter('#');
     if (op.getError())
         insn.setErrorIf(out, op);
     if (op.mode == M_IMb)
         op.val16 >>= 1;
-    const auto bits = op.mode == M_IM ? 8 : (op.mode == M_IMb ? 3 : 16);
+    const auto bits = (op.mode == M_IM || op.mode == M_IA) ? 8 : (op.mode == M_IMb ? 3 : 16);
     outHex(out, op.val16, bits);
 }
 
@@ -289,6 +291,7 @@ void DisZ8::decodeOperand(DisInsn &insn, StrBuffer &out, Operand &op) const {
     case M_IM:
     case M_IMb:
     case M_IML:
+    case M_IA:
         decodeImmediate(insn, out, op);
         break;
     case M_r:

src/entry_z8.h

@@ -44,11 +44,12 @@ enum AddrMode : uint8_t {
     M_XS = 15,   // Indexed Short: nn(rrn)
     M_XL = 16,   // Indexed Long: nnnn(rrn)
     M_cc = 17,   // Condition Code: cc
-    // Those (18-) happen only in assembler internal.
-    M_W = 18,    // Register or Working register: Rxy x==RP
-    M_IW = 19,   // Indirect Register or Working register: @Rxy x==RP
-    M_WW = 20,   // Register or Working register pair: RRxy: x=RP
-    M_IWW = 21,  // Indirect Register Pair or Working register Pair: @RRxy x==RP
+    M_IA = 18,   // Indirect address for CALL #IA
+    // Those (19-) happen only in assembler internal.
+    M_W = 19,    // Register or Working register: Rxy x==RP
+    M_IW = 20,   // Indirect Register or Working register: @Rxy x==RP
+    M_WW = 21,   // Register or Working register pair: RRxy: x=RP
+    M_IWW = 22,  // Indirect Register Pair or Working register Pair: @RRxy x==RP
 };
 
 // Post byte format

src/table_z8.cpp

@@ -321,7 +321,7 @@ static constexpr Entry TABLE_SUPER8[] PROGMEM = {
     E0(0x5F, TEXT_SB1,    PF_NONE),
     E1(0xF6, TEXT_CALL,   PF_NONE, M_DA,  OP_W1BE),
     E1(0xF4, TEXT_CALL,   PF_NONE, M_IRR, OP_BYT1),
-    E1(0xD4, TEXT_CALL,   PF_NONE, M_IM,  OP_BYT1),
+    E1(0xD4, TEXT_CALL,   PF_NONE, M_IA,  OP_BYT1),
     E2(0x87, TEXT_LD,     PF_NONE, M_r,   M_X,   OP_B1HI, OP_BYT2), // x: OP_B1LO
     E2(0x97, TEXT_LD,     PF_NONE, M_X,   M_r,   OP_BYT2, OP_B1HI), // x: OP_B1LO
     E2(0xC7, TEXT_LD,     PF_NONE, M_r,   M_Ir,  OP_B1HI, OP_B1LO),
@@ -500,7 +500,7 @@ static bool acceptMode(AddrMode opr, AddrMode table) {
     if (opr == table)
         return true;
     if (opr == M_IM)
-        return table == M_IMb || table == M_IML;
+        return table == M_IMb || table == M_IML || table == M_IA;
     if (opr == M_DA)
         return table == M_RA;
     if (opr == M_R)

test/test_asm_z8.cpp

@@ -364,6 +364,7 @@ static void test_one_operand() {
     TZ88("CALL @RR2", 0xF4, R(2));
     EZ86("CALL #%D6", OPERAND_NOT_ALLOWED, "#%D6");
     TZ88("CALL #%D6", 0xD4, 0xD6);
+    EZ88("CALL #%D7", OPERAND_NOT_ALIGNED, "#%D7", 0xD4, 0xD7);
     TEST("SRP  #%30", 0x31, 0x30);
     ERRT("SRP  #%38", OPERAND_NOT_ALLOWED, "#%38", 0x31, 0x38);
     EZ86("SRP0 #%30", UNKNOWN_INSTRUCTION, "SRP0 #%30");

test/test_dis_z8.cpp

@@ -332,6 +332,7 @@ static void test_one_operand() {
         TEST("CALL", "@%D6", 0xF4, 0xD6);
         TEST("CALL", "@RR2", 0xF4, R(2));
         TEST("CALL", "#%D6", 0xD4, 0xD6);
+        ERRT("CALL", "#%D7", OPERAND_NOT_ALIGNED, "#%D7", 0xD4, 0xD7);
         NMEM("CALL", "#0", "0", 0xD4);
     }
 }