From 2df91ddef7a750f07b8b4b86deb10886351b945c Mon Sep 17 00:00:00 2001 From: Lukas Krickl Date: Mon, 19 Feb 2024 17:39:40 +0100 Subject: [PATCH] Fixed naming for sm83 --- src/archs.c | 389 ++++++++++++++++++++++++++-------------------------- src/archs.h | 51 ++++--- 2 files changed, 220 insertions(+), 220 deletions(-) diff --git a/src/archs.c b/src/archs.c index 82507c2..74a593e 100644 --- a/src/archs.c +++ b/src/archs.c @@ -3,83 +3,84 @@ /** * Instruction table + * for SM83 */ // define r8, r8 -#define ULAS_INSTR_R8R8(name, base_op, reg_left, reg_right) \ +#define ULAS_INSTRSM83_R8R8(name, base_op, reg_left, reg_right) \ { \ (name), {(reg_left), ',', (reg_right), 0}, { base_op, 0 } \ } -#define ULAS_INSTR_R16R16(name, op, reg_left, reg_right) \ - ULAS_INSTR_R8R8(name, op, reg_left, reg_right) +#define ULAS_INSTRSM83_R16R16(name, op, reg_left, reg_right) \ + ULAS_INSTRSM83_R8R8(name, op, reg_left, reg_right) -#define ULAS_INSTR_R8R8D(name, base_op, reg_left) \ - ULAS_INSTR_R8R8(name, base_op, reg_left, ULAS_REG_B), \ - ULAS_INSTR_R8R8(name, (base_op) + 1, reg_left, ULAS_REG_C), \ - ULAS_INSTR_R8R8(name, (base_op) + 2, reg_left, ULAS_REG_D), \ - ULAS_INSTR_R8R8(name, (base_op) + 3, reg_left, ULAS_REG_E), \ - ULAS_INSTR_R8R8(name, (base_op) + 4, reg_left, ULAS_REG_H), \ - ULAS_INSTR_R8R8(name, (base_op) + 5, reg_left, ULAS_REG_L), \ +#define ULAS_INSTRSM83_R8R8D(name, base_op, reg_left) \ + ULAS_INSTRSM83_R8R8(name, base_op, reg_left, ULAS_REGSM83_B), \ + ULAS_INSTRSM83_R8R8(name, (base_op) + 1, reg_left, ULAS_REGSM83_C), \ + ULAS_INSTRSM83_R8R8(name, (base_op) + 2, reg_left, ULAS_REGSM83_D), \ + ULAS_INSTRSM83_R8R8(name, (base_op) + 3, reg_left, ULAS_REGSM83_E), \ + ULAS_INSTRSM83_R8R8(name, (base_op) + 4, reg_left, ULAS_REGSM83_H), \ + ULAS_INSTRSM83_R8R8(name, (base_op) + 5, reg_left, ULAS_REGSM83_L), \ {(name), \ - {(reg_left), ',', '[', ULAS_REG_HL, ']', 0}, \ + {(reg_left), ',', '[', ULAS_REGSM83_HL, ']', 0}, \ {(base_op) + 6, 0}}, \ - ULAS_INSTR_R8R8(name, (base_op) + 7, reg_left, ULAS_REG_A) + ULAS_INSTRSM83_R8R8(name, (base_op) + 7, reg_left, ULAS_REGSM83_A) // a, r8 -#define ULAS_INSTR_ALUR8D(name, base_op) \ - ULAS_INSTR_R8R8D(name, base_op, ULAS_REG_A) +#define ULAS_INSTRSM83_ALUR8D(name, base_op) \ + ULAS_INSTRSM83_R8R8D(name, base_op, ULAS_REGSM83_A) -#define ULAS_INSTR_R8_EXPR8(name, op, reg_left) \ +#define ULAS_INSTRSM83_R8_EXPR8(name, op, reg_left) \ { \ (name), {(reg_left), ',', ULAS_E8, 0}, { (op), ULAS_E8, 0 } \ } // r16, e16 -#define ULAS_INSTR_R16E16(name, op, reg_left) \ +#define ULAS_INSTRSM83_R16E16(name, op, reg_left) \ { \ (name), {(reg_left), ',', ULAS_E16, 0}, { (op), ULAS_E16, 0 } \ } // reg -#define ULAS_INSTR_REG(name, op, reg) \ +#define ULAS_INSTRSM83_REG(name, op, reg) \ { \ (name), {(reg), 0}, { (op), 0x00 } \ } // prefixed reg -#define ULAS_INSTR_PRER8(name, base_op, reg_right) \ +#define ULAS_INSTRSM83_PRER8(name, base_op, reg_right) \ { \ (name), {(reg_right), 0}, { 0xCB, base_op, 0 } \ } -#define ULAS_INSTR_PRER8D(name, base_op) \ - ULAS_INSTR_PRER8(name, (base_op), ULAS_REG_B), \ - ULAS_INSTR_PRER8(name, (base_op) + 1, ULAS_REG_C), \ - ULAS_INSTR_PRER8(name, (base_op) + 2, ULAS_REG_D), \ - ULAS_INSTR_PRER8(name, (base_op) + 3, ULAS_REG_E), \ - ULAS_INSTR_PRER8(name, (base_op) + 4, ULAS_REG_H), \ - ULAS_INSTR_PRER8(name, (base_op) + 5, ULAS_REG_L), \ - {(name), {'[', ULAS_REG_HL, ']', 0}, {0xCB, (base_op) + 6, 0}}, \ - ULAS_INSTR_PRER8(name, (base_op) + 7, ULAS_REG_A) +#define ULAS_INSTRSM83_PRER8D(name, base_op) \ + ULAS_INSTRSM83_PRER8(name, (base_op), ULAS_REGSM83_B), \ + ULAS_INSTRSM83_PRER8(name, (base_op) + 1, ULAS_REGSM83_C), \ + ULAS_INSTRSM83_PRER8(name, (base_op) + 2, ULAS_REGSM83_D), \ + ULAS_INSTRSM83_PRER8(name, (base_op) + 3, ULAS_REGSM83_E), \ + ULAS_INSTRSM83_PRER8(name, (base_op) + 4, ULAS_REGSM83_H), \ + ULAS_INSTRSM83_PRER8(name, (base_op) + 5, ULAS_REGSM83_L), \ + {(name), {'[', ULAS_REGSM83_HL, ']', 0}, {0xCB, (base_op) + 6, 0}}, \ + ULAS_INSTRSM83_PRER8(name, (base_op) + 7, ULAS_REGSM83_A) // prefixed , reg -#define ULAS_INSTR_PREBITR8(name, base_op, bit, reg_right) \ +#define ULAS_INSTRSM83_PREBITR8(name, base_op, bit, reg_right) \ { \ (name), {(bit), ',', (reg_right), 0}, { 0xCB, base_op, 0 } \ } -#define ULAS_INSTR_PREBITR8D(name, base_op, bit) \ - ULAS_INSTR_PREBITR8(name, base_op, bit, ULAS_REG_B), \ - ULAS_INSTR_PREBITR8(name, (base_op) + 1, bit, ULAS_REG_C), \ - ULAS_INSTR_PREBITR8(name, (base_op) + 2, bit, ULAS_REG_D), \ - ULAS_INSTR_PREBITR8(name, (base_op) + 3, bit, ULAS_REG_E), \ - ULAS_INSTR_PREBITR8(name, (base_op) + 4, bit, ULAS_REG_H), \ - ULAS_INSTR_PREBITR8(name, (base_op) + 5, bit, ULAS_REG_L), \ +#define ULAS_INSTRSM83_PREBITR8D(name, base_op, bit) \ + ULAS_INSTRSM83_PREBITR8(name, base_op, bit, ULAS_REGSM83_B), \ + ULAS_INSTRSM83_PREBITR8(name, (base_op) + 1, bit, ULAS_REGSM83_C), \ + ULAS_INSTRSM83_PREBITR8(name, (base_op) + 2, bit, ULAS_REGSM83_D), \ + ULAS_INSTRSM83_PREBITR8(name, (base_op) + 3, bit, ULAS_REGSM83_E), \ + ULAS_INSTRSM83_PREBITR8(name, (base_op) + 4, bit, ULAS_REGSM83_H), \ + ULAS_INSTRSM83_PREBITR8(name, (base_op) + 5, bit, ULAS_REGSM83_L), \ {(name), \ - {(bit), ',', '[', ULAS_REG_HL, ']', 0}, \ + {(bit), ',', '[', ULAS_REGSM83_HL, ']', 0}, \ {0xCB, (base_op) + 6, 0}}, \ - ULAS_INSTR_PREBITR8(name, (base_op) + 7, bit, ULAS_REG_A) + ULAS_INSTRSM83_PREBITR8(name, (base_op) + 7, bit, ULAS_REGSM83_A) // all instructions // when name is NULL list ended @@ -105,206 +106,206 @@ const struct ulas_instr ULASINSTRS_SM83[] = { {"rra", {0}, {0x1F, 0x00}}, // ld r8, r8 - ULAS_INSTR_R8R8D("ld", 0x40, ULAS_REG_B), - ULAS_INSTR_R8R8D("ld", 0x48, ULAS_REG_C), - ULAS_INSTR_R8R8D("ld", 0x50, ULAS_REG_D), - ULAS_INSTR_R8R8D("ld", 0x58, ULAS_REG_E), - ULAS_INSTR_R8R8D("ld", 0x60, ULAS_REG_H), - ULAS_INSTR_R8R8D("ld", 0x68, ULAS_REG_L), - ULAS_INSTR_R8R8D("ld", 0x78, ULAS_REG_A), + ULAS_INSTRSM83_R8R8D("ld", 0x40, ULAS_REGSM83_B), + ULAS_INSTRSM83_R8R8D("ld", 0x48, ULAS_REGSM83_C), + ULAS_INSTRSM83_R8R8D("ld", 0x50, ULAS_REGSM83_D), + ULAS_INSTRSM83_R8R8D("ld", 0x58, ULAS_REGSM83_E), + ULAS_INSTRSM83_R8R8D("ld", 0x60, ULAS_REGSM83_H), + ULAS_INSTRSM83_R8R8D("ld", 0x68, ULAS_REGSM83_L), + ULAS_INSTRSM83_R8R8D("ld", 0x78, ULAS_REGSM83_A), // ld [r16], a - {"ld", {'[', ULAS_REG_BC, ']', ',', ULAS_REG_A, 0}, {0x02, 0}}, - {"ld", {'[', ULAS_REG_DE, ']', ',', ULAS_REG_A, 0}, {0x12, 0}}, - {"ld", {'[', ULAS_REG_HL, ']', ',', ULAS_REG_A, 0}, {0x77, 0}}, - {"ld", {'[', ULAS_REG_HL, '+', ']', ',', ULAS_REG_A, 0}, {0x22, 0}}, - {"ld", {'[', ULAS_REG_HL, '-', ']', ',', ULAS_REG_A, 0}, {0x32, 0}}, - {"ld", {'[', ULAS_REG_HL, ']', ',', ULAS_E8, 0}, {0x36, ULAS_E8, 0x00}}, + {"ld", {'[', ULAS_REGSM83_BC, ']', ',', ULAS_REGSM83_A, 0}, {0x02, 0}}, + {"ld", {'[', ULAS_REGSM83_DE, ']', ',', ULAS_REGSM83_A, 0}, {0x12, 0}}, + {"ld", {'[', ULAS_REGSM83_HL, ']', ',', ULAS_REGSM83_A, 0}, {0x77, 0}}, + {"ld", {'[', ULAS_REGSM83_HL, '+', ']', ',', ULAS_REGSM83_A, 0}, {0x22, 0}}, + {"ld", {'[', ULAS_REGSM83_HL, '-', ']', ',', ULAS_REGSM83_A, 0}, {0x32, 0}}, + {"ld", {'[', ULAS_REGSM83_HL, ']', ',', ULAS_E8, 0}, {0x36, ULAS_E8, 0x00}}, // ld a, [r16] - {"ld", {ULAS_REG_A, ',', '[', ULAS_REG_BC, ']', 0}, {0x0A, 0}}, - {"ld", {ULAS_REG_A, ',', '[', ULAS_REG_DE, ']', 0}, {0x1A, 0}}, - {"ld", {ULAS_REG_A, ',', '[', ULAS_REG_HL, '+', ']', 0}, {0x2A, 0}}, - {"ld", {ULAS_REG_A, ',', '[', ULAS_REG_HL, '-', ']', 0}, {0x3A, 0}}, + {"ld", {ULAS_REGSM83_A, ',', '[', ULAS_REGSM83_BC, ']', 0}, {0x0A, 0}}, + {"ld", {ULAS_REGSM83_A, ',', '[', ULAS_REGSM83_DE, ']', 0}, {0x1A, 0}}, + {"ld", {ULAS_REGSM83_A, ',', '[', ULAS_REGSM83_HL, '+', ']', 0}, {0x2A, 0}}, + {"ld", {ULAS_REGSM83_A, ',', '[', ULAS_REGSM83_HL, '-', ']', 0}, {0x3A, 0}}, - {"ld", {'[', ULAS_E16, ']', ',', ULAS_REG_SP, 0}, {0x08, ULAS_E16, 0}}, + {"ld", {'[', ULAS_E16, ']', ',', ULAS_REGSM83_SP, 0}, {0x08, ULAS_E16, 0}}, - {"ld", {'[', ULAS_E16, ']', ',', ULAS_REG_A, 0}, {0xEA, ULAS_E16, 0}}, - {"ld", {ULAS_REG_A, ',', '[', ULAS_E16, ']', 0}, {0xFA, ULAS_E16, 0}}, + {"ld", {'[', ULAS_E16, ']', ',', ULAS_REGSM83_A, 0}, {0xEA, ULAS_E16, 0}}, + {"ld", {ULAS_REGSM83_A, ',', '[', ULAS_E16, ']', 0}, {0xFA, ULAS_E16, 0}}, {"ld", - {ULAS_REG_HL, ',', ULAS_REG_SP, '+', ULAS_E8, 0}, + {ULAS_REGSM83_HL, ',', ULAS_REGSM83_SP, '+', ULAS_E8, 0}, {0xF8, ULAS_E8, 0}}, - {"ldh", {'[', ULAS_REG_C, ']', ',', ULAS_REG_A, 0}, {0xE2, 0}}, - {"ldh", {ULAS_REG_A, ',', '[', ULAS_REG_C, ']', 0}, {0xF2, 0}}, + {"ldh", {'[', ULAS_REGSM83_C, ']', ',', ULAS_REGSM83_A, 0}, {0xE2, 0}}, + {"ldh", {ULAS_REGSM83_A, ',', '[', ULAS_REGSM83_C, ']', 0}, {0xF2, 0}}, - {"ldh", {'[', ULAS_A8, ']', ',', ULAS_REG_A, 0}, {0xE0, ULAS_A8, 0}}, - {"ldh", {ULAS_REG_A, ',', '[', ULAS_A8, ']', 0}, {0xF0, ULAS_A8, 0}}, + {"ldh", {'[', ULAS_A8, ']', ',', ULAS_REGSM83_A, 0}, {0xE0, ULAS_A8, 0}}, + {"ldh", {ULAS_REGSM83_A, ',', '[', ULAS_A8, ']', 0}, {0xF0, ULAS_A8, 0}}, // ld r8, e8 - ULAS_INSTR_R8_EXPR8("ld", 0x06, ULAS_REG_B), - ULAS_INSTR_R8_EXPR8("ld", 0x16, ULAS_REG_D), - ULAS_INSTR_R8_EXPR8("ld", 0x26, ULAS_REG_H), + ULAS_INSTRSM83_R8_EXPR8("ld", 0x06, ULAS_REGSM83_B), + ULAS_INSTRSM83_R8_EXPR8("ld", 0x16, ULAS_REGSM83_D), + ULAS_INSTRSM83_R8_EXPR8("ld", 0x26, ULAS_REGSM83_H), - ULAS_INSTR_R8_EXPR8("ld", 0x0E, ULAS_REG_C), - ULAS_INSTR_R8_EXPR8("ld", 0x1E, ULAS_REG_E), - ULAS_INSTR_R8_EXPR8("ld", 0x2E, ULAS_REG_L), - ULAS_INSTR_R8_EXPR8("ld", 0x3E, ULAS_REG_A), + ULAS_INSTRSM83_R8_EXPR8("ld", 0x0E, ULAS_REGSM83_C), + ULAS_INSTRSM83_R8_EXPR8("ld", 0x1E, ULAS_REGSM83_E), + ULAS_INSTRSM83_R8_EXPR8("ld", 0x2E, ULAS_REGSM83_L), + ULAS_INSTRSM83_R8_EXPR8("ld", 0x3E, ULAS_REGSM83_A), // ld r16, e16 - ULAS_INSTR_R16E16("ld", 0x01, ULAS_REG_BC), - ULAS_INSTR_R16E16("ld", 0x11, ULAS_REG_DE), - ULAS_INSTR_R16E16("ld", 0x21, ULAS_REG_HL), - ULAS_INSTR_R16E16("ld", 0x31, ULAS_REG_SP), + ULAS_INSTRSM83_R16E16("ld", 0x01, ULAS_REGSM83_BC), + ULAS_INSTRSM83_R16E16("ld", 0x11, ULAS_REGSM83_DE), + ULAS_INSTRSM83_R16E16("ld", 0x21, ULAS_REGSM83_HL), + ULAS_INSTRSM83_R16E16("ld", 0x31, ULAS_REGSM83_SP), // jr - ULAS_INSTR_R8_EXPR8("jr", 0x20, ULAS_REG_NOT_ZERO), - ULAS_INSTR_R8_EXPR8("jr", 0x30, ULAS_REG_NOT_CARRY), - ULAS_INSTR_R8_EXPR8("jr", 0x28, ULAS_REG_ZERO), - ULAS_INSTR_R8_EXPR8("jr", 0x38, ULAS_REG_CARRY), + ULAS_INSTRSM83_R8_EXPR8("jr", 0x20, ULAS_REGSM83_NOT_ZERO), + ULAS_INSTRSM83_R8_EXPR8("jr", 0x30, ULAS_REGSM83_NOT_CARRY), + ULAS_INSTRSM83_R8_EXPR8("jr", 0x28, ULAS_REGSM83_ZERO), + ULAS_INSTRSM83_R8_EXPR8("jr", 0x38, ULAS_REGSM83_CARRY), {"jr", {ULAS_E8, 0}, {0x18, ULAS_E8, 0x00}}, // ret - ULAS_INSTR_REG("ret", 0xC0, ULAS_REG_NOT_ZERO), - ULAS_INSTR_REG("ret", 0xD0, ULAS_REG_NOT_CARRY), - ULAS_INSTR_REG("ret", 0xC8, ULAS_REG_ZERO), - ULAS_INSTR_REG("ret", 0xD8, ULAS_REG_CARRY), + ULAS_INSTRSM83_REG("ret", 0xC0, ULAS_REGSM83_NOT_ZERO), + ULAS_INSTRSM83_REG("ret", 0xD0, ULAS_REGSM83_NOT_CARRY), + ULAS_INSTRSM83_REG("ret", 0xC8, ULAS_REGSM83_ZERO), + ULAS_INSTRSM83_REG("ret", 0xD8, ULAS_REGSM83_CARRY), {"ret", {0}, {0xC9, 0x00}}, {"reti", {0}, {0xD9, 0x00}}, // jp - ULAS_INSTR_R16E16("jp", 0xC2, ULAS_REG_NOT_ZERO), - ULAS_INSTR_R16E16("jp", 0xD2, ULAS_REG_NOT_CARRY), - ULAS_INSTR_R16E16("jp", 0xCA, ULAS_REG_ZERO), - ULAS_INSTR_R16E16("jp", 0xDA, ULAS_REG_CARRY), - {"jp", {ULAS_REG_HL, 0}, {0xE9, 0x00}}, + ULAS_INSTRSM83_R16E16("jp", 0xC2, ULAS_REGSM83_NOT_ZERO), + ULAS_INSTRSM83_R16E16("jp", 0xD2, ULAS_REGSM83_NOT_CARRY), + ULAS_INSTRSM83_R16E16("jp", 0xCA, ULAS_REGSM83_ZERO), + ULAS_INSTRSM83_R16E16("jp", 0xDA, ULAS_REGSM83_CARRY), + {"jp", {ULAS_REGSM83_HL, 0}, {0xE9, 0x00}}, {"jp", {ULAS_E16, 0}, {0xC3, ULAS_E16, 0x00}}, // call - ULAS_INSTR_R16E16("call", 0xC4, ULAS_REG_NOT_ZERO), - ULAS_INSTR_R16E16("call", 0xD4, ULAS_REG_NOT_CARRY), - ULAS_INSTR_R16E16("call", 0xCC, ULAS_REG_ZERO), - ULAS_INSTR_R16E16("call", 0xDC, ULAS_REG_CARRY), + ULAS_INSTRSM83_R16E16("call", 0xC4, ULAS_REGSM83_NOT_ZERO), + ULAS_INSTRSM83_R16E16("call", 0xD4, ULAS_REGSM83_NOT_CARRY), + ULAS_INSTRSM83_R16E16("call", 0xCC, ULAS_REGSM83_ZERO), + ULAS_INSTRSM83_R16E16("call", 0xDC, ULAS_REGSM83_CARRY), {"call", {ULAS_E16, 0}, {0xCD, ULAS_E16, 0x00}}, // rst - ULAS_INSTR_REG("rst", 0xC7, ULAS_VEC00), - ULAS_INSTR_REG("rst", 0xD7, ULAS_VEC10), - ULAS_INSTR_REG("rst", 0xE7, ULAS_VEC20), - ULAS_INSTR_REG("rst", 0xF7, ULAS_VEC30), - ULAS_INSTR_REG("rst", 0xCF, ULAS_VEC08), - ULAS_INSTR_REG("rst", 0xDF, ULAS_VEC18), - ULAS_INSTR_REG("rst", 0xEF, ULAS_VEC28), - ULAS_INSTR_REG("rst", 0xFF, ULAS_VEC38), + ULAS_INSTRSM83_REG("rst", 0xC7, ULAS_VECSM83_00), + ULAS_INSTRSM83_REG("rst", 0xD7, ULAS_VECSM83_10), + ULAS_INSTRSM83_REG("rst", 0xE7, ULAS_VECSM83_20), + ULAS_INSTRSM83_REG("rst", 0xF7, ULAS_VECSM83_30), + ULAS_INSTRSM83_REG("rst", 0xCF, ULAS_VECSM83_08), + ULAS_INSTRSM83_REG("rst", 0xDF, ULAS_VECSM83_18), + ULAS_INSTRSM83_REG("rst", 0xEF, ULAS_VECSM83_28), + ULAS_INSTRSM83_REG("rst", 0xFF, ULAS_VECSM83_38), // inc/dec - ULAS_INSTR_REG("inc", 0x03, ULAS_REG_BC), - ULAS_INSTR_REG("inc", 0x13, ULAS_REG_DE), - ULAS_INSTR_REG("inc", 0x23, ULAS_REG_HL), - ULAS_INSTR_REG("inc", 0x33, ULAS_REG_SP), - - ULAS_INSTR_REG("inc", 0x04, ULAS_REG_B), - ULAS_INSTR_REG("inc", 0x14, ULAS_REG_D), - ULAS_INSTR_REG("inc", 0x24, ULAS_REG_H), - {"inc", {'[', ULAS_REG_HL, ']', 0}, {0x34, 0x00}}, - - ULAS_INSTR_REG("dec", 0x05, ULAS_REG_B), - ULAS_INSTR_REG("dec", 0x15, ULAS_REG_D), - ULAS_INSTR_REG("dec", 0x25, ULAS_REG_H), - {"dec", {'[', ULAS_REG_HL, ']', 0}, {0x35, 0x00}}, - - ULAS_INSTR_REG("dec", 0x0B, ULAS_REG_BC), - ULAS_INSTR_REG("dec", 0x1B, ULAS_REG_DE), - ULAS_INSTR_REG("dec", 0x2B, ULAS_REG_HL), - ULAS_INSTR_REG("dec", 0x3B, ULAS_REG_SP), - - ULAS_INSTR_REG("inc", 0x0C, ULAS_REG_C), - ULAS_INSTR_REG("inc", 0x1C, ULAS_REG_E), - ULAS_INSTR_REG("inc", 0x2C, ULAS_REG_L), - ULAS_INSTR_REG("inc", 0x3C, ULAS_REG_A), - - ULAS_INSTR_REG("dec", 0x0D, ULAS_REG_C), - ULAS_INSTR_REG("dec", 0x1D, ULAS_REG_E), - ULAS_INSTR_REG("dec", 0x2D, ULAS_REG_L), - ULAS_INSTR_REG("dec", 0x3D, ULAS_REG_A), + ULAS_INSTRSM83_REG("inc", 0x03, ULAS_REGSM83_BC), + ULAS_INSTRSM83_REG("inc", 0x13, ULAS_REGSM83_DE), + ULAS_INSTRSM83_REG("inc", 0x23, ULAS_REGSM83_HL), + ULAS_INSTRSM83_REG("inc", 0x33, ULAS_REGSM83_SP), + + ULAS_INSTRSM83_REG("inc", 0x04, ULAS_REGSM83_B), + ULAS_INSTRSM83_REG("inc", 0x14, ULAS_REGSM83_D), + ULAS_INSTRSM83_REG("inc", 0x24, ULAS_REGSM83_H), + {"inc", {'[', ULAS_REGSM83_HL, ']', 0}, {0x34, 0x00}}, + + ULAS_INSTRSM83_REG("dec", 0x05, ULAS_REGSM83_B), + ULAS_INSTRSM83_REG("dec", 0x15, ULAS_REGSM83_D), + ULAS_INSTRSM83_REG("dec", 0x25, ULAS_REGSM83_H), + {"dec", {'[', ULAS_REGSM83_HL, ']', 0}, {0x35, 0x00}}, + + ULAS_INSTRSM83_REG("dec", 0x0B, ULAS_REGSM83_BC), + ULAS_INSTRSM83_REG("dec", 0x1B, ULAS_REGSM83_DE), + ULAS_INSTRSM83_REG("dec", 0x2B, ULAS_REGSM83_HL), + ULAS_INSTRSM83_REG("dec", 0x3B, ULAS_REGSM83_SP), + + ULAS_INSTRSM83_REG("inc", 0x0C, ULAS_REGSM83_C), + ULAS_INSTRSM83_REG("inc", 0x1C, ULAS_REGSM83_E), + ULAS_INSTRSM83_REG("inc", 0x2C, ULAS_REGSM83_L), + ULAS_INSTRSM83_REG("inc", 0x3C, ULAS_REGSM83_A), + + ULAS_INSTRSM83_REG("dec", 0x0D, ULAS_REGSM83_C), + ULAS_INSTRSM83_REG("dec", 0x1D, ULAS_REGSM83_E), + ULAS_INSTRSM83_REG("dec", 0x2D, ULAS_REGSM83_L), + ULAS_INSTRSM83_REG("dec", 0x3D, ULAS_REGSM83_A), // alu r8, r8 - ULAS_INSTR_ALUR8D("add", 0x80), - ULAS_INSTR_ALUR8D("adc", 0x88), - ULAS_INSTR_ALUR8D("sub", 0x90), - ULAS_INSTR_ALUR8D("sbc", 0x98), - ULAS_INSTR_ALUR8D("and", 0xA0), - ULAS_INSTR_ALUR8D("xor", 0xA8), - ULAS_INSTR_ALUR8D("or", 0xB0), - ULAS_INSTR_ALUR8D("cp", 0xB8), - - ULAS_INSTR_R8_EXPR8("add", 0xC6, ULAS_REG_A), - ULAS_INSTR_R8_EXPR8("sub", 0xD6, ULAS_REG_A), - ULAS_INSTR_R8_EXPR8("and", 0xE6, ULAS_REG_A), - ULAS_INSTR_R8_EXPR8("or", 0xF6, ULAS_REG_A), - - ULAS_INSTR_R8_EXPR8("adc", 0xCE, ULAS_REG_A), - ULAS_INSTR_R8_EXPR8("suc", 0xDE, ULAS_REG_A), - ULAS_INSTR_R8_EXPR8("xor", 0xEE, ULAS_REG_A), - ULAS_INSTR_R8_EXPR8("cp", 0xFE, ULAS_REG_A), - - ULAS_INSTR_R8_EXPR8("add", 0xE8, ULAS_REG_SP), + ULAS_INSTRSM83_ALUR8D("add", 0x80), + ULAS_INSTRSM83_ALUR8D("adc", 0x88), + ULAS_INSTRSM83_ALUR8D("sub", 0x90), + ULAS_INSTRSM83_ALUR8D("sbc", 0x98), + ULAS_INSTRSM83_ALUR8D("and", 0xA0), + ULAS_INSTRSM83_ALUR8D("xor", 0xA8), + ULAS_INSTRSM83_ALUR8D("or", 0xB0), + ULAS_INSTRSM83_ALUR8D("cp", 0xB8), + + ULAS_INSTRSM83_R8_EXPR8("add", 0xC6, ULAS_REGSM83_A), + ULAS_INSTRSM83_R8_EXPR8("sub", 0xD6, ULAS_REGSM83_A), + ULAS_INSTRSM83_R8_EXPR8("and", 0xE6, ULAS_REGSM83_A), + ULAS_INSTRSM83_R8_EXPR8("or", 0xF6, ULAS_REGSM83_A), + + ULAS_INSTRSM83_R8_EXPR8("adc", 0xCE, ULAS_REGSM83_A), + ULAS_INSTRSM83_R8_EXPR8("suc", 0xDE, ULAS_REGSM83_A), + ULAS_INSTRSM83_R8_EXPR8("xor", 0xEE, ULAS_REGSM83_A), + ULAS_INSTRSM83_R8_EXPR8("cp", 0xFE, ULAS_REGSM83_A), + + ULAS_INSTRSM83_R8_EXPR8("add", 0xE8, ULAS_REGSM83_SP), // alu r16, r16 - ULAS_INSTR_R16R16("add", 0x09, ULAS_REG_HL, ULAS_REG_BC), - ULAS_INSTR_R16R16("add", 0x19, ULAS_REG_HL, ULAS_REG_DE), - ULAS_INSTR_R16R16("add", 0x29, ULAS_REG_HL, ULAS_REG_HL), - ULAS_INSTR_R16R16("add", 0x39, ULAS_REG_HL, ULAS_REG_SP), + ULAS_INSTRSM83_R16R16("add", 0x09, ULAS_REGSM83_HL, ULAS_REGSM83_BC), + ULAS_INSTRSM83_R16R16("add", 0x19, ULAS_REGSM83_HL, ULAS_REGSM83_DE), + ULAS_INSTRSM83_R16R16("add", 0x29, ULAS_REGSM83_HL, ULAS_REGSM83_HL), + ULAS_INSTRSM83_R16R16("add", 0x39, ULAS_REGSM83_HL, ULAS_REGSM83_SP), // pop - ULAS_INSTR_REG("pop", 0xC1, ULAS_REG_BC), - ULAS_INSTR_REG("pop", 0xD1, ULAS_REG_DE), - ULAS_INSTR_REG("pop", 0xE1, ULAS_REG_HL), - ULAS_INSTR_REG("pop", 0xF1, ULAS_REG_AF), + ULAS_INSTRSM83_REG("pop", 0xC1, ULAS_REGSM83_BC), + ULAS_INSTRSM83_REG("pop", 0xD1, ULAS_REGSM83_DE), + ULAS_INSTRSM83_REG("pop", 0xE1, ULAS_REGSM83_HL), + ULAS_INSTRSM83_REG("pop", 0xF1, ULAS_REGSM83_AF), // push - ULAS_INSTR_REG("push", 0xC5, ULAS_REG_BC), - ULAS_INSTR_REG("push", 0xD5, ULAS_REG_DE), - ULAS_INSTR_REG("push", 0xE5, ULAS_REG_HL), - ULAS_INSTR_REG("push", 0xF5, ULAS_REG_AF), + ULAS_INSTRSM83_REG("push", 0xC5, ULAS_REGSM83_BC), + ULAS_INSTRSM83_REG("push", 0xD5, ULAS_REGSM83_DE), + ULAS_INSTRSM83_REG("push", 0xE5, ULAS_REGSM83_HL), + ULAS_INSTRSM83_REG("push", 0xF5, ULAS_REGSM83_AF), // prefixed - ULAS_INSTR_PRER8D("swap", 0x30), - ULAS_INSTR_PRER8D("rlc", 0x00), - ULAS_INSTR_PRER8D("rrc", 0x08), - ULAS_INSTR_PRER8D("rl", 0x10), - ULAS_INSTR_PRER8D("rr", 0x18), - ULAS_INSTR_PRER8D("sla", 0x10), - ULAS_INSTR_PRER8D("sra", 0x18), - ULAS_INSTR_PRER8D("srl", 0x38), - - ULAS_INSTR_PREBITR8D("bit", 0x40, '0'), - ULAS_INSTR_PREBITR8D("bit", 0x48, '1'), - ULAS_INSTR_PREBITR8D("bit", 0x50, '2'), - ULAS_INSTR_PREBITR8D("bit", 0x58, '3'), - ULAS_INSTR_PREBITR8D("bit", 0x60, '4'), - ULAS_INSTR_PREBITR8D("bit", 0x68, '5'), - ULAS_INSTR_PREBITR8D("bit", 0x70, '6'), - ULAS_INSTR_PREBITR8D("bit", 0x78, '7'), - - ULAS_INSTR_PREBITR8D("res", 0x80, '0'), - ULAS_INSTR_PREBITR8D("res", 0x88, '1'), - ULAS_INSTR_PREBITR8D("res", 0x90, '2'), - ULAS_INSTR_PREBITR8D("res", 0x98, '3'), - ULAS_INSTR_PREBITR8D("res", 0xA0, '4'), - ULAS_INSTR_PREBITR8D("res", 0xA8, '5'), - ULAS_INSTR_PREBITR8D("res", 0xB0, '6'), - ULAS_INSTR_PREBITR8D("res", 0xB8, '7'), - - ULAS_INSTR_PREBITR8D("set", 0xC0, '0'), - ULAS_INSTR_PREBITR8D("set", 0xC8, '1'), - ULAS_INSTR_PREBITR8D("set", 0xD0, '2'), - ULAS_INSTR_PREBITR8D("set", 0xD8, '3'), - ULAS_INSTR_PREBITR8D("set", 0xE0, '4'), - ULAS_INSTR_PREBITR8D("set", 0xE8, '5'), - ULAS_INSTR_PREBITR8D("set", 0xF0, '6'), - ULAS_INSTR_PREBITR8D("set", 0xF8, '7'), + ULAS_INSTRSM83_PRER8D("swap", 0x30), + ULAS_INSTRSM83_PRER8D("rlc", 0x00), + ULAS_INSTRSM83_PRER8D("rrc", 0x08), + ULAS_INSTRSM83_PRER8D("rl", 0x10), + ULAS_INSTRSM83_PRER8D("rr", 0x18), + ULAS_INSTRSM83_PRER8D("sla", 0x10), + ULAS_INSTRSM83_PRER8D("sra", 0x18), + ULAS_INSTRSM83_PRER8D("srl", 0x38), + + ULAS_INSTRSM83_PREBITR8D("bit", 0x40, '0'), + ULAS_INSTRSM83_PREBITR8D("bit", 0x48, '1'), + ULAS_INSTRSM83_PREBITR8D("bit", 0x50, '2'), + ULAS_INSTRSM83_PREBITR8D("bit", 0x58, '3'), + ULAS_INSTRSM83_PREBITR8D("bit", 0x60, '4'), + ULAS_INSTRSM83_PREBITR8D("bit", 0x68, '5'), + ULAS_INSTRSM83_PREBITR8D("bit", 0x70, '6'), + ULAS_INSTRSM83_PREBITR8D("bit", 0x78, '7'), + + ULAS_INSTRSM83_PREBITR8D("res", 0x80, '0'), + ULAS_INSTRSM83_PREBITR8D("res", 0x88, '1'), + ULAS_INSTRSM83_PREBITR8D("res", 0x90, '2'), + ULAS_INSTRSM83_PREBITR8D("res", 0x98, '3'), + ULAS_INSTRSM83_PREBITR8D("res", 0xA0, '4'), + ULAS_INSTRSM83_PREBITR8D("res", 0xA8, '5'), + ULAS_INSTRSM83_PREBITR8D("res", 0xB0, '6'), + ULAS_INSTRSM83_PREBITR8D("res", 0xB8, '7'), + + ULAS_INSTRSM83_PREBITR8D("set", 0xC0, '0'), + ULAS_INSTRSM83_PREBITR8D("set", 0xC8, '1'), + ULAS_INSTRSM83_PREBITR8D("set", 0xD0, '2'), + ULAS_INSTRSM83_PREBITR8D("set", 0xD8, '3'), + ULAS_INSTRSM83_PREBITR8D("set", 0xE0, '4'), + ULAS_INSTRSM83_PREBITR8D("set", 0xE8, '5'), + ULAS_INSTRSM83_PREBITR8D("set", 0xF0, '6'), + ULAS_INSTRSM83_PREBITR8D("set", 0xF8, '7'), {NULL}}; diff --git a/src/archs.h b/src/archs.h index f0a59b7..7a5342c 100644 --- a/src/archs.h +++ b/src/archs.h @@ -1,39 +1,38 @@ #ifndef ARCHS_H_ #define ARCHS_H_ -// TODO: rename reg constants so that they contain SM83 enum ulas_asmregs_sm83 { // r8 - ULAS_REG_B = 1, - ULAS_REG_C = 2, - ULAS_REG_D = 3, - ULAS_REG_E = 4, - ULAS_REG_H = 5, - ULAS_REG_L = 6, - ULAS_REG_A = 7, + ULAS_REGSM83_B = 1, + ULAS_REGSM83_C = 2, + ULAS_REGSM83_D = 3, + ULAS_REGSM83_E = 4, + ULAS_REGSM83_H = 5, + ULAS_REGSM83_L = 6, + ULAS_REGSM83_A = 7, // r16 - ULAS_REG_BC = 8, - ULAS_REG_DE = 9, - ULAS_REG_HL = 10, - ULAS_REG_AF = 16, + ULAS_REGSM83_BC = 8, + ULAS_REGSM83_DE = 9, + ULAS_REGSM83_HL = 10, + ULAS_REGSM83_AF = 16, // flags - ULAS_REG_NOT_ZERO = 11, - ULAS_REG_ZERO = 12, - ULAS_REG_NOT_CARRY = 13, - ULAS_REG_CARRY = 14, + ULAS_REGSM83_NOT_ZERO = 11, + ULAS_REGSM83_ZERO = 12, + ULAS_REGSM83_NOT_CARRY = 13, + ULAS_REGSM83_CARRY = 14, // misc - ULAS_REG_SP = 15, - ULAS_VEC00 = 17, - ULAS_VEC08 = 18, - ULAS_VEC10 = 19, - ULAS_VEC18 = 20, - ULAS_VEC20 = 21, - ULAS_VEC28 = 22, - ULAS_VEC30 = 23, - ULAS_VEC38 = 24, + ULAS_REGSM83_SP = 15, + ULAS_VECSM83_00 = 17, + ULAS_VECSM83_08 = 18, + ULAS_VECSM83_10 = 19, + ULAS_VECSM83_18 = 20, + ULAS_VECSM83_20 = 21, + ULAS_VECSM83_28 = 22, + ULAS_VECSM83_30 = 23, + ULAS_VECSM83_38 = 24, ULAS_SM83_REGS_LEN }; @@ -43,7 +42,7 @@ enum ulas_archs { ULAS_ARCH_SM83 }; struct ulas_arch { const char **regs_names; unsigned long regs_len; - + const struct ulas_instr *instrs; }; -- 2.30.2