--- hatari/src/falcon/dsp_disasm.c 2019/04/01 07:14:53 1.1.1.2 +++ hatari/src/falcon/dsp_disasm.c 2019/04/09 08:58:15 1.1.1.10 @@ -15,8 +15,8 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + along with this program; if not, write to the Free Software Foundation, + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */ #ifdef HAVE_CONFIG_H @@ -24,12 +24,15 @@ #endif #include +#include +#include +#include #include "dsp_core.h" #include "dsp_cpu.h" #include "dsp_disasm.h" +#include "profile.h" -#define DEBUG 0 /* More disasm infos, if wanted */ #define DSP_DISASM_REG_PC 0 @@ -38,20 +41,29 @@ * Defines **********************************/ -#define BITMASK(x) ((1<<(x))-1) - /********************************** * Variables **********************************/ /* Current instruction */ static Uint32 cur_inst; +static Uint16 disasm_cur_inst_len; +static char str_instr[50]; +static char str_instr2[120]; +static char parallelmove_name[64]; -static dsp_core_t *dsp_core; - -void dsp56k_disasm_init(dsp_core_t *my_dsp_core) -{ - dsp_core = my_dsp_core; +/* Previous instruction */ +static Uint32 prev_inst_pc; +static bool isLooping; + +/* Used to display dc instead of unknown instruction for illegal opcodes */ +static bool isInDisasmMode; + +void dsp56k_disasm_init(void) +{ + prev_inst_pc = 0x10000; /* Init to an invalid value */ + isLooping = false; + isInDisasmMode = false; } /********************************** @@ -59,7 +71,6 @@ void dsp56k_disasm_init(dsp_core_t *my_d **********************************/ static Uint32 registers_save[64]; -static Uint32 registers_changed[64]; #if DSP_DISASM_REG_PC static Uint32 pc_save; #endif @@ -86,95 +97,6 @@ static const char *registers_name[64]={ "ssh","ssl","la","lc" }; -void dsp56k_disasm_reg_read(void) -{ - memcpy(registers_save, dsp_core->registers , sizeof(registers_save)); - memset(registers_changed, 0, sizeof(registers_changed)); -#if DSP_DISASM_REG_PC - pc_save = dsp_core->pc; -#endif -} - -void dsp56k_disasm_reg_compare(void) -{ - int i; - - for (i=0;i<64;i++) { - if (!registers_changed[i]) { - continue; - } - - switch(i) { - case DSP_REG_X0: - case DSP_REG_X1: - case DSP_REG_Y0: - case DSP_REG_Y1: - case DSP_REG_A0: - case DSP_REG_A1: - case DSP_REG_B0: - case DSP_REG_B1: - fprintf(stderr,"Dsp: Reg: %s: 0x%06x -> 0x%06x\n", registers_name[i], registers_save[i] & BITMASK(24), dsp_core->registers[i] & BITMASK(24)); - break; - case DSP_REG_R0: - case DSP_REG_R1: - case DSP_REG_R2: - case DSP_REG_R3: - case DSP_REG_R4: - case DSP_REG_R5: - case DSP_REG_R6: - case DSP_REG_R7: - case DSP_REG_M0: - case DSP_REG_M1: - case DSP_REG_M2: - case DSP_REG_M3: - case DSP_REG_M4: - case DSP_REG_M5: - case DSP_REG_M6: - case DSP_REG_M7: - case DSP_REG_N0: - case DSP_REG_N1: - case DSP_REG_N2: - case DSP_REG_N3: - case DSP_REG_N4: - case DSP_REG_N5: - case DSP_REG_N6: - case DSP_REG_N7: - case DSP_REG_SR: - case DSP_REG_LA: - case DSP_REG_LC: - fprintf(stderr,"Dsp: Reg: %s: 0x%04x -> 0x%04x\n", registers_name[i], registers_save[i] & BITMASK(16), dsp_core->registers[i] & BITMASK(16)); - break; - case DSP_REG_A2: - case DSP_REG_B2: - case DSP_REG_OMR: - case DSP_REG_SP: - case DSP_REG_SSH: - case DSP_REG_SSL: - fprintf(stderr,"Dsp: Reg: %s: 0x%02x -> 0x%02x\n", registers_name[i], registers_save[i] & BITMASK(8), dsp_core->registers[i] & BITMASK(8)); - break; - case DSP_REG_A: - case DSP_REG_B: - { - fprintf(stderr,"Dsp: Reg: %s: 0x%02x:%06x:%06x -> 0x%02x:%06x:%06x\n", - registers_name[i], - registers_save[DSP_REG_A2+(i & 1)] & BITMASK(8), - registers_save[DSP_REG_A1+(i & 1)] & BITMASK(24), - registers_save[DSP_REG_A0+(i & 1)] & BITMASK(24), - dsp_core->registers[DSP_REG_A2+(i & 1)] & BITMASK(8), - dsp_core->registers[DSP_REG_A1+(i & 1)] & BITMASK(24), - dsp_core->registers[DSP_REG_A0+(i & 1)] & BITMASK(24) - ); - } - break; - } - } -#if DSP_DISASM_REG_PC - if (pc_save != dsp_core->pc) { - fprintf(stderr,"Dsp: Reg: pc: 0x%04x -> 0x%04x\n", pc_save, dsp_core->pc); - } -#endif -} - /********************************** * Opcode disassembler **********************************/ @@ -184,12 +106,6 @@ static Uint32 read_memory(Uint32 currPc) typedef void (*dsp_emul_t)(void); static void opcode8h_0(void); -static void opcode8h_1(void); -static void opcode8h_4(void); -static void opcode8h_6(void); -static void opcode8h_8(void); -static void opcode8h_a(void); -static void opcode8h_b(void); static int dsp_calc_ea(Uint32 ea_mode, char *dest); static void dsp_calc_cc(Uint32 cc_mode, char *dest); @@ -197,30 +113,55 @@ static void dsp_undefined(void); /* Instructions without parallel moves */ static void dsp_andi(void); -static void dsp_bchg(void); -static void dsp_bclr(void); -static void dsp_bset(void); -static void dsp_btst(void); +static void dsp_bchg_aa(void); +static void dsp_bchg_ea(void); +static void dsp_bchg_pp(void); +static void dsp_bchg_reg(void); +static void dsp_bclr_aa(void); +static void dsp_bclr_ea(void); +static void dsp_bclr_pp(void); +static void dsp_bclr_reg(void); +static void dsp_bset_aa(void); +static void dsp_bset_ea(void); +static void dsp_bset_pp(void); +static void dsp_bset_reg(void); +static void dsp_btst_aa(void); +static void dsp_btst_ea(void); +static void dsp_btst_pp(void); +static void dsp_btst_reg(void); static void dsp_div(void); -static void dsp_do(void); static void dsp_enddo(void); static void dsp_illegal(void); -static void dsp_jcc(void); -static void dsp_jclr(void); -static void dsp_jmp(void); -static void dsp_jscc(void); -static void dsp_jsclr(void); -static void dsp_jset(void); -static void dsp_jsr(void); -static void dsp_jsset(void); +static void dsp_jcc_imm(void); +static void dsp_jcc_ea(void); +static void dsp_jclr_aa(void); +static void dsp_jclr_ea(void); +static void dsp_jclr_pp(void); +static void dsp_jclr_reg(void); +static void dsp_jmp_ea(void); +static void dsp_jmp_imm(void); +static void dsp_jscc_ea(void); +static void dsp_jscc_imm(void); +static void dsp_jsclr_aa(void); +static void dsp_jsclr_ea(void); +static void dsp_jsclr_pp(void); +static void dsp_jsclr_reg(void); +static void dsp_jset_aa(void); +static void dsp_jset_ea(void); +static void dsp_jset_pp(void); +static void dsp_jset_reg(void); +static void dsp_jsr_ea(void); +static void dsp_jsr_imm(void); +static void dsp_jsset_aa(void); +static void dsp_jsset_ea(void); +static void dsp_jsset_pp(void); +static void dsp_jsset_reg(void); static void dsp_lua(void); -static void dsp_movec(void); -static void dsp_movem(void); -static void dsp_movep(void); +static void dsp_movem_ea(void); +static void dsp_movem_aa(void); static void dsp_nop(void); static void dsp_norm(void); static void dsp_ori(void); -static void dsp_rep(void); static void dsp_reset(void); static void dsp_rti(void); static void dsp_rts(void); @@ -228,24 +169,24 @@ static void dsp_stop(void); static void dsp_swi(void); static void dsp_tcc(void); static void dsp_wait(void); - -static void dsp_do_0(void); -static void dsp_do_2(void); -static void dsp_do_4(void); -static void dsp_do_c(void); -static void dsp_movec_7(void); -static void dsp_movec_9(void); -static void dsp_movec_b(void); -static void dsp_movec_d(void); +static void dsp_do_ea(void); +static void dsp_do_aa(void); +static void dsp_do_imm(void); +static void dsp_do_reg(void); +static void dsp_rep_aa(void); +static void dsp_rep_ea(void); +static void dsp_rep_imm(void); +static void dsp_rep_reg(void); +static void dsp_movec_aa(void); +static void dsp_movec_ea(void); +static void dsp_movec_imm(void); +static void dsp_movec_reg(void); static void dsp_movep_0(void); static void dsp_movep_1(void); -static void dsp_movep_2(void); -static void dsp_rep_1(void); -static void dsp_rep_3(void); -static void dsp_rep_5(void); -static void dsp_rep_d(void); +static void dsp_movep_23(void); /* Parallel moves */ +static void dsp_pm_class2(void); static void dsp_pm(void); static void dsp_pm_0(void); static void dsp_pm_1(void); @@ -253,331 +194,134 @@ static void dsp_pm_2(void); static void dsp_pm_4(void); static void dsp_pm_8(void); -/* Instructions with parallel moves */ -static void dsp_abs(void); -static void dsp_adc(void); -static void dsp_add(void); -static void dsp_addl(void); -static void dsp_addr(void); -static void dsp_and(void); -static void dsp_asl(void); -static void dsp_asr(void); -static void dsp_clr(void); -static void dsp_cmp(void); -static void dsp_cmpm(void); -static void dsp_eor(void); -static void dsp_lsl(void); -static void dsp_lsr(void); -static void dsp_mac(void); -static void dsp_macr(void); -static void dsp_move(void); -static void dsp_move_nopm(void); -static void dsp_mpy(void); -static void dsp_mpyr(void); -static void dsp_neg(void); -static void dsp_not(void); -static void dsp_or(void); -static void dsp_rnd(void); -static void dsp_rol(void); -static void dsp_ror(void); -static void dsp_sbc(void); -static void dsp_sub(void); -static void dsp_subl(void); -static void dsp_subr(void); -static void dsp_tfr(void); -static void dsp_tst(void); - -static dsp_emul_t opcodes8h[16]={ - opcode8h_0, - opcode8h_1, - dsp_tcc, - dsp_tcc, - opcode8h_4, - dsp_movec, - opcode8h_6, - dsp_movem, - opcode8h_8, - opcode8h_8, - opcode8h_a, - opcode8h_b, - dsp_jmp, - dsp_jsr, - dsp_jcc, - dsp_jscc -}; -static dsp_emul_t opcodes_0809[16]={ - dsp_move_nopm, - dsp_move_nopm, - dsp_move_nopm, - dsp_move_nopm, - - dsp_movep, - dsp_movep, - dsp_movep, - dsp_movep, - - dsp_move_nopm, - dsp_move_nopm, - dsp_move_nopm, - dsp_move_nopm, - - dsp_movep, - dsp_movep, - dsp_movep, - dsp_movep +static const dsp_emul_t opcodes8h[512] = { + /* 0x00 - 0x3f */ + opcode8h_0, dsp_undefined, dsp_undefined, dsp_undefined, opcode8h_0, dsp_andi, dsp_undefined, dsp_ori, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_andi, dsp_undefined, dsp_ori, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_andi, dsp_undefined, dsp_ori, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_andi, dsp_undefined, dsp_ori, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_undefined, dsp_div, dsp_div, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_norm, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + + /* 0x40 - 0x7f */ + dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + + /* 0x80 - 0xbf */ + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_lua, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_movec_reg, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_movec_reg, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_movec_aa, dsp_undefined, dsp_movec_aa, dsp_undefined, dsp_movec_imm, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_movec_ea, dsp_undefined, dsp_movec_ea, dsp_undefined, dsp_movec_imm, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_movec_aa, dsp_undefined, dsp_movec_aa, dsp_undefined, dsp_movec_imm, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_movec_ea, dsp_undefined, dsp_movec_ea, dsp_undefined, dsp_movec_imm, dsp_undefined, dsp_undefined, + + /* 0xc0 - 0xff */ + dsp_do_aa, dsp_rep_aa, dsp_do_aa, dsp_rep_aa, dsp_do_imm, dsp_rep_imm, dsp_undefined, dsp_undefined, + dsp_do_ea, dsp_rep_ea, dsp_do_ea, dsp_rep_ea, dsp_do_imm, dsp_rep_imm, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_do_imm, dsp_rep_imm, dsp_undefined, dsp_undefined, + dsp_do_reg, dsp_rep_reg, dsp_undefined, dsp_undefined, dsp_do_imm, dsp_rep_imm, dsp_undefined, dsp_undefined, + dsp_movem_aa, dsp_movem_aa, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_movem_ea, dsp_movem_ea, dsp_undefined, dsp_undefined, + dsp_movem_aa, dsp_movem_aa, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_movem_ea, dsp_movem_ea, dsp_undefined, dsp_undefined, + + /* 0x100 - 0x13f */ + dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, + dsp_movep_0, dsp_movep_0, dsp_movep_1, dsp_movep_1, dsp_movep_23, dsp_movep_23, dsp_movep_23, dsp_movep_23, + dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, + dsp_movep_0, dsp_movep_0, dsp_movep_1, dsp_movep_1, dsp_movep_23, dsp_movep_23, dsp_movep_23, dsp_movep_23, + dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, + dsp_movep_0, dsp_movep_0, dsp_movep_1, dsp_movep_1, dsp_movep_23, dsp_movep_23, dsp_movep_23, dsp_movep_23, + dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, + dsp_movep_0, dsp_movep_0, dsp_movep_1, dsp_movep_1, dsp_movep_23, dsp_movep_23, dsp_movep_23, dsp_movep_23, + + /* 0x140 - 0x17f */ + dsp_bclr_aa, dsp_bset_aa, dsp_bclr_aa, dsp_bset_aa, dsp_jclr_aa, dsp_jset_aa, dsp_jclr_aa, dsp_jset_aa, + dsp_bclr_ea, dsp_bset_ea, dsp_bclr_ea, dsp_bset_ea, dsp_jclr_ea, dsp_jset_ea, dsp_jclr_ea, dsp_jset_ea, + dsp_bclr_pp, dsp_bset_pp, dsp_bclr_pp, dsp_bset_pp, dsp_jclr_pp, dsp_jset_pp, dsp_jclr_pp, dsp_jset_pp, + dsp_jclr_reg, dsp_jset_reg, dsp_bclr_reg, dsp_bset_reg, dsp_jmp_ea, dsp_jcc_ea, dsp_undefined, dsp_undefined, + dsp_bchg_aa, dsp_btst_aa, dsp_bchg_aa, dsp_btst_aa, dsp_jsclr_aa, dsp_jsset_aa, dsp_jsclr_aa, dsp_jsset_aa, + dsp_bchg_ea, dsp_btst_ea, dsp_bchg_ea, dsp_btst_ea, dsp_jsclr_ea, dsp_jsset_ea, dsp_jsclr_ea, dsp_jsset_ea, + dsp_bchg_pp, dsp_btst_pp, dsp_bchg_pp, dsp_btst_pp, dsp_jsclr_pp, dsp_jsset_pp, dsp_jsclr_pp, dsp_jsset_pp, + dsp_jsclr_reg, dsp_jsset_reg, dsp_bchg_reg, dsp_btst_reg, dsp_jsr_ea, dsp_jscc_ea, dsp_undefined, dsp_undefined, + + /* 0x180 - 0x1bf */ + dsp_jmp_imm, dsp_jmp_imm, dsp_jmp_imm, dsp_jmp_imm, dsp_jmp_imm, dsp_jmp_imm, dsp_jmp_imm, dsp_jmp_imm, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_jsr_imm, dsp_jsr_imm, dsp_jsr_imm, dsp_jsr_imm, dsp_jsr_imm, dsp_jsr_imm, dsp_jsr_imm, dsp_jsr_imm, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, + + /* 0x1c0 - 0x1ff */ + dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, + dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, + dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, + dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, + dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, + dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, + dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, + dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, }; -static dsp_emul_t opcodes_0a[32]={ - dsp_bclr, - dsp_bset, - dsp_bclr, - dsp_bset, - dsp_jclr, - dsp_jset, - dsp_jclr, - dsp_jset, - - dsp_bclr, - dsp_bset, - dsp_bclr, - dsp_bset, - dsp_jclr, - dsp_jset, - dsp_jclr, - dsp_jset, - - dsp_bclr, - dsp_bset, - dsp_bclr, - dsp_bset, - dsp_jclr, - dsp_jset, - dsp_jclr, - dsp_jset, - - dsp_jclr, - dsp_jset, - dsp_bclr, - dsp_bset, - dsp_jmp, - dsp_jcc, - dsp_undefined, - dsp_undefined +static const char* opcodes_alu[256] = { + /* 0x00 - 0x3f */ + "move" , "tfr b,a", "addr b,a", "tst a", "undefined", "cmp b,a" , "subr b,a", "cmpm b,a", + "undefined", "tfr a,b", "addr a,b", "tst b", "undefined", "cmp a,b" , "subr a,b", "cmpm a,b", + "add b,a" , "rnd a" , "addl b,a", "clr a", "sub b,a" , "undefined", "subl b,a", "not a", + "add a,b" , "rnd b" , "addl a,b", "clr b", "sub a,b" , "undefined", "subl a,b", "not b", + "add x,a" , "adc x,a", "asr a" , "lsr a", "sub x,a" , "sbc x,a" , "abs a" , "ror a", + "add x,b" , "adc x,b", "asr b" , "lsr b", "sub x,b" , "sbc x,b" , "abs b" , "ror b", + "add y,a" , "adc y,a", "asl a" , "lsl a", "sub y,a" , "sbc y,a" , "neg a" , "rol a", + "add y,b" , "adc y,b", "asl b" , "lsl b", "sub y,b" , "sbc y,b" , "neg b" , "rol b", + + /* 0x40 - 0x7f */ + "add x0,a", "tfr x0,a", "or x0,a", "eor x0,a", "sub x0,a", "cmp x0,a", "and x0,a", "cmpm x0,a", + "add x0,b", "tfr x0,b", "or x0,b", "eor x0,b", "sub x0,b", "cmp x0,b", "and x0,b", "cmpm x0,b", + "add y0,a", "tfr y0,a", "or y0,a", "eor y0,a", "sub y0,a", "cmp y0,a", "and y0,a", "cmpm y0,a", + "add y0,b", "tfr y0,b", "or y0,b", "eor y0,b", "sub y0,b", "cmp y0,b", "and y0,b", "cmpm y0,b", + "add x1,a", "tfr x1,a", "or x1,a", "eor x1,a", "sub x1,a", "cmp x1,a", "and x1,a", "cmpm x1,a", + "add x1,b", "tfr x1,b", "or x1,b", "eor x1,b", "sub x1,b", "cmp x1,b", "and x1,b", "cmpm x1,b", + "add y1,a", "tfr y1,a", "or y1,a", "eor y1,a", "sub y1,a", "cmp y1,a", "and y1,a", "cmpm y1,a", + "add y1,b", "tfr y1,b", "or y1,b", "eor y1,b", "sub y1,b", "cmp y1,b", "and y1,b", "cmpm y1,b", + + /* 0x80 - 0xbf */ + "mpy +x0,x0,a", "mpyr +x0,x0,a", "mac +x0,x0,a", "macr +x0,x0,a", "mpy -x0,x0,a", "mpyr -x0,x0,a", "mac -x0,x0,a", "macr -x0,x0,a", + "mpy +x0,x0,b", "mpyr +x0,x0,b", "mac +x0,x0,b", "macr +x0,x0,b", "mpy -x0,x0,b", "mpyr -x0,x0,b", "mac -x0,x0,b", "macr -x0,x0,b", + "mpy +y0,y0,a", "mpyr +y0,y0,a", "mac +y0,y0,a", "macr +y0,y0,a", "mpy -y0,y0,a", "mpyr -y0,y0,a", "mac -y0,y0,a", "macr -y0,y0,a", + "mpy +y0,y0,b", "mpyr +y0,y0,b", "mac +y0,y0,b", "macr +y0,y0,b", "mpy -y0,y0,b", "mpyr -y0,y0,b", "mac -y0,y0,b", "macr -y0,y0,b", + "mpy +x1,x0,a", "mpyr +x1,x0,a", "mac +x1,x0,a", "macr +x1,x0,a", "mpy -x1,x0,a", "mpyr -x1,x0,a", "mac -x1,x0,a", "macr -x1,x0,a", + "mpy +x1,x0,b", "mpyr +x1,x0,b", "mac +x1,x0,b", "macr +x1,x0,b", "mpy -x1,x0,b", "mpyr -x1,x0,b", "mac -x1,x0,b", "macr -x1,x0,b", + "mpy +y1,y0,a", "mpyr +y1,y0,a", "mac +y1,y0,a", "macr +y1,y0,a", "mpy -y1,y0,a", "mpyr -y1,y0,a", "mac -y1,y0,a", "macr -y1,y0,a", + "mpy +y1,y0,b", "mpyr +y1,y0,b", "mac +y1,y0,b", "macr +y1,y0,b", "mpy -y1,y0,b", "mpyr -y1,y0,b", "mac -y1,y0,b", "macr -y1,y0,b", + + /* 0xc0 - 0xff */ + "mpy +x0,y1,a", "mpyr +x0,y1,a", "mac +x0,y1,a", "macr +x0,y1,a", "mpy -x0,y1,a", "mpyr -x0,y1,a", "mac -x0,y1,a", "macr -x0,y1,a", + "mpy +x0,y1,b", "mpyr +x0,y1,b", "mac +x0,y1,b", "macr +x0,y1,b", "mpy -x0,y1,b", "mpyr -x0,y1,b", "mac -x0,y1,b", "macr -x0,y1,b", + "mpy +y0,x0,a", "mpyr +y0,x0,a", "mac +y0,x0,a", "macr +y0,x0,a", "mpy -y0,x0,a", "mpyr -y0,x0,a", "mac -y0,x0,a", "macr -y0,x0,a", + "mpy +y0,x0,b", "mpyr +y0,x0,b", "mac +y0,x0,b", "macr +y0,x0,b", "mpy -y0,x0,b", "mpyr -y0,x0,b", "mac -y0,x0,b", "macr -y0,x0,b", + "mpy +x1,y0,a", "mpyr +x1,y0,a", "mac +x1,y0,a", "macr +x1,y0,a", "mpy -x1,y0,a", "mpyr -x1,y0,a", "mac -x1,y0,a", "macr -x1,y0,a", + "mpy +x1,y0,b", "mpyr +x1,y0,b", "mac +x1,y0,b", "macr +x1,y0,b", "mpy -x1,y0,b", "mpyr -x1,y0,b", "mac -x1,y0,b", "macr -x1,y0,b", + "mpy +y1,x1,a", "mpyr +y1,x1,a", "mac +y1,x1,a", "macr +y1,x1,a", "mpy -y1,x1,a", "mpyr -y1,x1,a", "mac -y1,x1,a", "macr -y1,x1,a", + "mpy +y1,x1,b", "mpyr +y1,x1,b", "mac +y1,x1,b", "macr +y1,x1,b", "mpy -y1,x1,b", "mpyr -y1,x1,b", "mac -y1,x1,b", "macr -y1,x1,b" }; -static dsp_emul_t opcodes_0b[32]={ - dsp_bchg, - dsp_btst, - dsp_bchg, - dsp_btst, - dsp_jsclr, - dsp_jsset, - dsp_jsclr, - dsp_jsset, - - dsp_bchg, - dsp_btst, - dsp_bchg, - dsp_btst, - dsp_jsclr, - dsp_jsset, - dsp_jsclr, - dsp_jsset, - - dsp_bchg, - dsp_btst, - dsp_bchg, - dsp_btst, - dsp_jsclr, - dsp_jsset, - dsp_jsclr, - dsp_jsset, - - dsp_jsclr, - dsp_jsclr, - dsp_bchg, - dsp_btst, - dsp_jsr, - dsp_jscc, - dsp_undefined, - dsp_undefined -}; -static dsp_emul_t opcodes_alu003f[64]={ - /* 0x00 - 0x0f */ - dsp_move, - dsp_tfr, - dsp_addr, - dsp_tst, - dsp_undefined, - dsp_cmp, - dsp_subr, - dsp_cmpm, - dsp_undefined, - dsp_tfr, - dsp_addr, - dsp_tst, - dsp_undefined, - dsp_cmp, - dsp_subr, - dsp_cmpm, - - /* 0x10 - 0x1f */ - dsp_add, - dsp_rnd, - dsp_addl, - dsp_clr, - dsp_sub, - dsp_undefined, - dsp_subl, - dsp_not, - dsp_add, - dsp_rnd, - dsp_addl, - dsp_clr, - dsp_sub, - dsp_undefined, - dsp_subl, - dsp_not, - - /* 0x20 - 0x2f */ - dsp_add, - dsp_adc, - dsp_asr, - dsp_lsr, - dsp_sub, - dsp_sbc, - dsp_abs, - dsp_ror, - dsp_add, - dsp_adc, - dsp_asr, - dsp_lsr, - dsp_sub, - dsp_sbc, - dsp_abs, - dsp_ror, - - /* 0x30 - 0x3f */ - dsp_add, - dsp_adc, - dsp_asl, - dsp_lsl, - dsp_sub, - dsp_sbc, - dsp_neg, - dsp_rol, - dsp_add, - dsp_adc, - dsp_asl, - dsp_lsl, - dsp_sub, - dsp_sbc, - dsp_neg, - dsp_rol -}; -static dsp_emul_t opcodes_alu407f[16]={ - dsp_add, - dsp_tfr, - dsp_or, - dsp_eor, - dsp_sub, - dsp_cmp, - dsp_and, - dsp_cmpm, - dsp_add, - dsp_tfr, - dsp_or, - dsp_eor, - dsp_sub, - dsp_cmp, - dsp_and, - dsp_cmpm -}; - -static dsp_emul_t opcodes_alu80ff[4]={ - dsp_mpy, - dsp_mpyr, - dsp_mac, - dsp_macr -}; - -static dsp_emul_t opcodes_do[16]={ - dsp_do_0, - dsp_undefined, - dsp_do_2, - dsp_undefined, - - dsp_do_4, - dsp_undefined, - dsp_do_2, - dsp_undefined, - - dsp_undefined, - dsp_undefined, - dsp_do_2, - dsp_undefined, - - dsp_do_c, - dsp_undefined, - dsp_do_2, - dsp_undefined -}; - -static dsp_emul_t opcodes_movec[16]={ - dsp_undefined, - dsp_undefined, - dsp_undefined, - dsp_undefined, - - dsp_undefined, - dsp_undefined, - dsp_undefined, - dsp_movec_7, - - dsp_undefined, - dsp_movec_9, - dsp_undefined, - dsp_movec_b, - - dsp_undefined, - dsp_movec_d, - dsp_undefined, - dsp_movec_b -}; - -static dsp_emul_t opcodes_movep[4]={ - dsp_movep_0, - dsp_movep_1, - dsp_movep_2, - dsp_movep_2 -}; - -static dsp_emul_t opcodes_rep[16]={ - dsp_undefined, - dsp_rep_1, - dsp_undefined, - dsp_rep_3, - - dsp_undefined, - dsp_rep_5, - dsp_undefined, - dsp_rep_3, - - dsp_undefined, - dsp_undefined, - dsp_undefined, - dsp_rep_3, - - dsp_undefined, - dsp_rep_d, - dsp_undefined, - dsp_rep_3 -}; - -static dsp_emul_t opcodes_parmove[16]={ +static const dsp_emul_t opcodes_parmove[16] = { dsp_pm_0, dsp_pm_1, dsp_pm_2, @@ -597,7 +341,7 @@ static dsp_emul_t opcodes_parmove[16]={ dsp_pm_8 }; -static int registers_tcc[16][2]={ +static const int registers_tcc[16][2] = { {DSP_REG_B,DSP_REG_A}, {DSP_REG_A,DSP_REG_B}, {DSP_REG_NULL,DSP_REG_NULL}, @@ -619,7 +363,7 @@ static int registers_tcc[16][2]={ {DSP_REG_Y1,DSP_REG_B} }; -static const char *registers_lmove[8]={ +static const char *registers_lmove[8] = { "a10", "b10", "x", @@ -630,19 +374,19 @@ static const char *registers_lmove[8]={ "ba" }; -static const char *ea_names[9]={ +static const char *ea_names[9] = { "(r%d)-n%d", /* 000xxx */ "(r%d)+n%d", /* 001xxx */ "(r%d)-", /* 010xxx */ "(r%d)+", /* 011xxx */ "(r%d)", /* 100xxx */ "(r%d+n%d)", /* 101xxx */ - "0x%04x", /* 110000 */ + "$%04x", /* 110000 */ "-(r%d)", /* 111xxx */ - "0x%06x" /* 110100 */ + "$%06x" /* 110100 */ }; -static const char *cc_name[16]={ +static const char *cc_name[16] = { "cc", "ge", "ne", @@ -662,47 +406,176 @@ static const char *cc_name[16]={ "le" }; -static char parallelmove_name[64]; +void dsp56k_disasm_reg_save(void) +{ + memcpy(registers_save, dsp_core.registers , sizeof(registers_save)); +#if DSP_DISASM_REG_PC + pc_save = dsp_core.pc; +#endif +} -void dsp56k_disasm(void) +void dsp56k_disasm_reg_compare(FILE *fp) +{ + int i; + bool bRegA = false; + bool bRegB = false; + + for (i=4; i<64; i++) { + if (registers_save[i] == dsp_core.registers[i]) { + continue; + } + + switch(i) { + case DSP_REG_X0: + case DSP_REG_X1: + case DSP_REG_Y0: + case DSP_REG_Y1: + fprintf(fp, "\tReg: %s $%06x -> $%06x\n", registers_name[i], registers_save[i], dsp_core.registers[i]); + break; + case DSP_REG_R0: + case DSP_REG_R1: + case DSP_REG_R2: + case DSP_REG_R3: + case DSP_REG_R4: + case DSP_REG_R5: + case DSP_REG_R6: + case DSP_REG_R7: + case DSP_REG_M0: + case DSP_REG_M1: + case DSP_REG_M2: + case DSP_REG_M3: + case DSP_REG_M4: + case DSP_REG_M5: + case DSP_REG_M6: + case DSP_REG_M7: + case DSP_REG_N0: + case DSP_REG_N1: + case DSP_REG_N2: + case DSP_REG_N3: + case DSP_REG_N4: + case DSP_REG_N5: + case DSP_REG_N6: + case DSP_REG_N7: + case DSP_REG_SR: + case DSP_REG_LA: + case DSP_REG_LC: + fprintf(fp, "\tReg: %s $%04x -> $%04x\n", registers_name[i], registers_save[i], dsp_core.registers[i]); + break; + case DSP_REG_OMR: + case DSP_REG_SP: + case DSP_REG_SSH: + case DSP_REG_SSL: + fprintf(fp, "\tReg: %s $%02x -> $%02x\n", registers_name[i], registers_save[i], dsp_core.registers[i]); + break; + case DSP_REG_A0: + case DSP_REG_A1: + case DSP_REG_A2: + if (bRegA == false) { + fprintf(fp, "\tReg: a $%02x:%06x:%06x -> $%02x:%06x:%06x\n", + registers_save[DSP_REG_A2], registers_save[DSP_REG_A1], registers_save[DSP_REG_A0], + dsp_core.registers[DSP_REG_A2], dsp_core.registers[DSP_REG_A1], dsp_core.registers[DSP_REG_A0] + ); + bRegA = true; + } + break; + case DSP_REG_B0: + case DSP_REG_B1: + case DSP_REG_B2: + if (bRegB == false) { + fprintf(fp, "\tReg: b $%02x:%06x:%06x -> $%02x:%06x:%06x\n", + registers_save[DSP_REG_B2], registers_save[DSP_REG_B1], registers_save[DSP_REG_B0], + dsp_core.registers[DSP_REG_B2], dsp_core.registers[DSP_REG_B1], dsp_core.registers[DSP_REG_B0] + ); + bRegB = true; + } + break; + } + } + +#if DSP_DISASM_REG_PC + if (pc_save != dsp_core.pc) { + fprintf(fp, "\tReg: pc $%04x -> $%04x\n", pc_save, dsp_core.pc); + } +#endif +} + +Uint16 dsp56k_disasm(dsp_trace_disasm_t mode, FILE *fp) { Uint32 value; - cur_inst = read_memory(dsp_core->pc); + if (mode == DSP_TRACE_MODE) { + isInDisasmMode = false; + if (prev_inst_pc == dsp_core.pc) { + if (!isLooping) { + fprintf(fp, "Looping on DSP instruction at PC = $%04x\n", prev_inst_pc); + isLooping = true; + } + return 0; + } + } + else { + isInDisasmMode = true; + } + + prev_inst_pc = dsp_core.pc; + isLooping = false; + + cur_inst = read_memory(dsp_core.pc); + disasm_cur_inst_len = 1; strcpy(parallelmove_name, ""); - value = (cur_inst >> 16) & BITMASK(8); - if (value< 0x10) { + if (cur_inst < 0x100000) { + value = (cur_inst >> 11) & (BITMASK(6) << 3); + value += (cur_inst >> 5) & BITMASK(3); opcodes8h[value](); } else { dsp_pm(); - value = cur_inst & BITMASK(8); - if (value < 0x40) { - opcodes_alu003f[value](); - } else if (value < 0x80) { - value &= BITMASK(4); - opcodes_alu407f[value](); - } else { - value &= BITMASK(2); - opcodes_alu80ff[value](); - } + sprintf(str_instr, "%s %s", opcodes_alu[cur_inst & BITMASK(8)], parallelmove_name); } + return disasm_cur_inst_len; } -void dsp56k_disasm_force_reg_changed(int num_dsp_reg) +/** + * dsp56k_getInstrText : return the disasembled instructions + */ +const char* dsp56k_getInstructionText(void) { - registers_changed[num_dsp_reg]=1; -} + const int len = sizeof(str_instr); + Uint64 count, cycles; + Uint16 cycle_diff; + float percentage; + int offset; + + if (isLooping) { + *str_instr2 = 0; + } + if (disasm_cur_inst_len == 1) { + offset = sprintf(str_instr2, "p:%04x %06x (%02d cyc) %-*s\n", prev_inst_pc, cur_inst, dsp_core.instr_cycle, len, str_instr); + } else { + offset = sprintf(str_instr2, "p:%04x %06x %06x (%02d cyc) %-*s\n", prev_inst_pc, cur_inst, read_memory(prev_inst_pc + 1), dsp_core.instr_cycle, len, str_instr); + } + if (offset > 2 && Profile_DspAddressData(prev_inst_pc, &percentage, &count, &cycles, &cycle_diff)) { + offset -= 2; + sprintf(str_instr2+offset, "%5.2f%% (%"PRId64", %"PRId64", %d)\n", + percentage, count, cycles, cycle_diff); + } + return str_instr2; +} + +static void dsp_pm_class2(void) { + dsp_pm(); + sprintf(str_instr, "%s %s", opcodes_alu[cur_inst & BITMASK(8)], parallelmove_name); +} static Uint32 read_memory(Uint32 currPc) { Uint32 value; if (currPc<0x200) { - value = dsp_core->ramint[DSP_SPACE_P][currPc]; + value = dsp_core.ramint[DSP_SPACE_P][currPc]; } else { - value = dsp_core->ram[DSP_SPACE_P][currPc & (DSP_RAMSIZE-1)]; + value = dsp_core.ramext[currPc & (DSP_RAMSIZE-1)]; } return value & BITMASK(24); @@ -732,12 +605,10 @@ static int dsp_calc_ea(Uint32 ea_mode, c case 0: /* (Rx)-Nx */ sprintf(dest, ea_names[value], numreg, numreg); - registers_changed[DSP_REG_R0+numreg]=1; break; case 1: /* (Rx)+Nx */ sprintf(dest, ea_names[value], numreg, numreg); - registers_changed[DSP_REG_R0+numreg]=1; break; case 5: /* (Rx+Nx) */ @@ -746,12 +617,10 @@ static int dsp_calc_ea(Uint32 ea_mode, c case 2: /* (Rx)- */ sprintf(dest, ea_names[value], numreg); - registers_changed[DSP_REG_R0+numreg]=1; break; case 3: /* (Rx)+ */ sprintf(dest, ea_names[value], numreg); - registers_changed[DSP_REG_R0+numreg]=1; break; case 4: /* (Rx) */ @@ -760,17 +629,17 @@ static int dsp_calc_ea(Uint32 ea_mode, c case 7: /* -(Rx) */ sprintf(dest, ea_names[value], numreg); - registers_changed[DSP_REG_R0+numreg]=1; break; case 6: + disasm_cur_inst_len++; switch ((ea_mode >> 2) & 1) { case 0: /* Absolute address */ - sprintf(dest, ea_names[value], read_memory(dsp_core->pc+1)); + sprintf(dest, ea_names[value], read_memory(dsp_core.pc+1)); break; case 1: /* Immediate value */ - sprintf(dest, ea_names[8], read_memory(dsp_core->pc+1)); + sprintf(dest, ea_names[8], read_memory(dsp_core.pc+1)); retour = 1; break; } @@ -781,204 +650,239 @@ static int dsp_calc_ea(Uint32 ea_mode, c static void opcode8h_0(void) { - Uint32 value; - - if (cur_inst <= 0x00008c) { - switch(cur_inst) { - case 0x000000: - dsp_nop(); - break; - case 0x000004: - dsp_rti(); - break; - case 0x000005: - dsp_illegal(); - break; - case 0x000006: - dsp_swi(); - break; - case 0x00000c: - dsp_rts(); - break; - case 0x000084: - dsp_reset(); - break; - case 0x000086: - dsp_wait(); - break; - case 0x000087: - dsp_stop(); - break; - case 0x00008c: - dsp_enddo(); - break; - } - } else { - value = cur_inst & 0xf8; - switch (value) { - case 0x0000b8: - dsp_andi(); - break; - case 0x0000f8: - dsp_ori(); - break; - } + switch(cur_inst) { + case 0x000000: + dsp_nop(); + break; + case 0x000004: + dsp_rti(); + break; + case 0x000005: + dsp_illegal(); + break; + case 0x000006: + dsp_swi(); + break; + case 0x00000c: + dsp_rts(); + break; + case 0x000084: + dsp_reset(); + break; + case 0x000086: + dsp_wait(); + break; + case 0x000087: + dsp_stop(); + break; + case 0x00008c: + dsp_enddo(); + break; + default: + dsp_undefined(); + break; } } -static void opcode8h_1(void) +/********************************** + * Non-parallel moves instructions + **********************************/ + +static void dsp_undefined(void) { - switch(cur_inst & 0xfff8c7) { - case 0x018040: - dsp_div(); - break; - case 0x01c805: - dsp_norm(); - break; - } + /* In Disasm mode, display dc instruction_opcode */ + if (isInDisasmMode) + sprintf(str_instr, "dc $%06x", cur_inst); + /* In trace mode, display unknown instruction */ + else + sprintf(str_instr, "$%06x unknown instruction", cur_inst); } -static void opcode8h_4(void) +static void dsp_andi(void) { - switch((cur_inst>>5) & BITMASK(3)) { + switch(cur_inst & BITMASK(2)) { case 0: - dsp_lua(); + sprintf(str_instr, "andi #$%02x,mr", (cur_inst>>8) & BITMASK(8)); break; - case 5: - dsp_movec(); + case 1: + sprintf(str_instr, "andi #$%02x,ccr", (cur_inst>>8) & BITMASK(8)); + break; + case 2: + sprintf(str_instr, "andi #$%02x,omr", (cur_inst>>8) & BITMASK(8)); + break; + default: break; } } -static void opcode8h_6(void) +static void dsp_bchg_aa(void) { - if (cur_inst & (1<<5)) { - dsp_rep(); + /* bchg #n,x:aa */ + /* bchg #n,y:aa */ + char name[16]; + Uint32 memspace, value, numbit; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + if (memspace) { + sprintf(name,"y:$%04x",value); } else { - dsp_do(); + sprintf(name,"x:$%04x",value); } + + sprintf(str_instr,"bchg #%d,%s", numbit, name); } -static void opcode8h_8(void) +static void dsp_bchg_ea(void) { - Uint32 value; + /* bchg #n,x:ea */ + /* bchg #n,y:ea */ + char name[16], addr_name[16]; + Uint32 memspace, value, numbit; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); - value = (cur_inst >> 12) & BITMASK(4); - opcodes_0809[value](); + dsp_calc_ea(value, addr_name); + if (memspace) { + sprintf(name,"y:%s",addr_name); + } else { + sprintf(name,"x:%s",addr_name); + } + + sprintf(str_instr,"bchg #%d,%s", numbit, name); } -static void opcode8h_a(void) +static void dsp_bchg_pp(void) { - Uint32 value; + /* bchg #n,x:pp */ + /* bchg #n,y:pp */ + char name[16]; + Uint32 memspace, value, numbit; - value = (cur_inst >> 11) & (BITMASK(2)<<3); - value |= (cur_inst >> 5) & BITMASK(3); + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); - opcodes_0a[value](); + if (memspace) { + sprintf(name,"y:$%04x",value+0xffc0); + } else { + sprintf(name,"x:$%04x",value+0xffc0); + } + + sprintf(str_instr,"bchg #%d,%s", numbit, name); } -static void opcode8h_b(void) +static void dsp_bchg_reg(void) { - Uint32 value; + /* bchg #n,R */ + Uint32 value, numbit; - value = (cur_inst >> 11) & (BITMASK(2)<<3); - value |= (cur_inst >> 5) & BITMASK(3); + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); - opcodes_0b[value](); + sprintf(str_instr,"bchg #%d,%s", numbit, registers_name[value]); } -/********************************** - * Non-parallel moves instructions - **********************************/ +static void dsp_bclr_aa(void) +{ + /* bclr #n,x:aa */ + /* bclr #n,y:aa */ + char name[16]; + Uint32 memspace, value, numbit; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); -static void dsp_undefined(void) + if (memspace) { + sprintf(name,"y:$%04x",value); + } else { + sprintf(name,"x:$%04x",value); + } + + sprintf(str_instr,"bclr #%d,%s", numbit, name); +} + +static void dsp_bclr_ea(void) { - fprintf(stderr,"Dsp: 0x%04x: 0x%06x unknown instruction\n",dsp_core->pc, cur_inst); + /* bclr #n,x:ea */ + /* bclr #n,y:ea */ + char name[16], addr_name[16]; + Uint32 memspace, value, numbit; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + dsp_calc_ea(value, addr_name); + if (memspace) { + sprintf(name,"y:%s",addr_name); + } else { + sprintf(name,"x:%s",addr_name); + } + + sprintf(str_instr,"bclr #%d,%s", numbit, name); } -static void dsp_andi(void) +static void dsp_bclr_pp(void) { - const char *regname; + /* bclr #n,x:pp */ + /* bclr #n,y:pp */ + char name[16]; + Uint32 memspace, value, numbit; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); - switch(cur_inst & BITMASK(2)) { - case 0: - regname="mr"; - registers_changed[DSP_REG_SR]=1; - break; - case 1: - regname="ccr"; - registers_changed[DSP_REG_SR]=1; - break; - case 2: - regname="omr"; - registers_changed[DSP_REG_OMR]=1; - break; - default: - regname=""; - break; + if (memspace) { + sprintf(name,"y:$%04x",value+0xffc0); + } else { + sprintf(name,"x:$%04x",value+0xffc0); } - registers_changed[DSP_REG_SR]=1; + sprintf(str_instr,"bclr #%d,%s", numbit, name); +} - fprintf(stderr,"Dsp: 0x%04x: andi #0x%02x,%s\n", - dsp_core->pc, - (cur_inst>>8) & BITMASK(8), - regname - ); +static void dsp_bclr_reg(void) +{ + /* bclr #n,R */ + Uint32 value, numbit; + + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + sprintf(str_instr,"bclr #%d,%s", numbit, registers_name[value]); } -static void dsp_bchg(void) +static void dsp_bset_aa(void) { - char name[16], addr_name[16]; + /* bset #n,x:aa */ + /* bset #n,y:aa */ + char name[16]; Uint32 memspace, value, numbit; memspace = (cur_inst>>6) & 1; value = (cur_inst>>8) & BITMASK(6); numbit = cur_inst & BITMASK(5); - switch((cur_inst>>14) & BITMASK(2)) { - case 0: - /* bchg #n,x:aa */ - /* bchg #n,y:aa */ - if (memspace) { - sprintf(name,"y:0x%04x",value); - } else { - sprintf(name,"x:0x%04x",value); - } - break; - case 1: - /* bchg #n,x:ea */ - /* bchg #n,y:ea */ - dsp_calc_ea(value, addr_name); - if (memspace) { - sprintf(name,"y:%s",addr_name); - } else { - sprintf(name,"x:%s",addr_name); - } - break; - case 2: - /* bchg #n,x:pp */ - /* bchg #n,y:pp */ - if (memspace) { - sprintf(name,"y:0x%04x",value+0xffc0); - } else { - sprintf(name,"x:0x%04x",value+0xffc0); - } - break; - case 3: - /* bchg #n,R */ - sprintf(name,"%s",registers_name[value]); - registers_changed[value]=1; - break; + if (memspace) { + sprintf(name,"y:$%04x",value); + } else { + sprintf(name,"x:$%04x",value); } - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: bchg #%d,%s\n",dsp_core->pc, numbit, name); + sprintf(str_instr,"bset #%d,%s", numbit, name); } -static void dsp_bclr(void) +static void dsp_bset_ea(void) { + /* bset #n,x:ea */ + /* bset #n,y:ea */ char name[16], addr_name[16]; Uint32 memspace, value, numbit; @@ -986,99 +890,71 @@ static void dsp_bclr(void) value = (cur_inst>>8) & BITMASK(6); numbit = cur_inst & BITMASK(5); - switch((cur_inst>>14) & BITMASK(2)) { - case 0: - /* bclr #n,x:aa */ - /* bclr #n,y:aa */ - if (memspace) { - sprintf(name,"y:0x%04x",value); - } else { - sprintf(name,"x:0x%04x",value); - } - break; - case 1: - /* bclr #n,x:ea */ - /* bclr #n,y:ea */ - dsp_calc_ea(value, addr_name); - if (memspace) { - sprintf(name,"y:%s",addr_name); - } else { - sprintf(name,"x:%s",addr_name); - } - break; - case 2: - /* bclr #n,x:pp */ - /* bclr #n,y:pp */ - if (memspace) { - sprintf(name,"y:0x%04x",value+0xffc0); - } else { - sprintf(name,"x:0x%04x",value+0xffc0); - } - break; - case 3: - /* bclr #n,R */ - sprintf(name,"%s",registers_name[value]); - registers_changed[value]=1; - break; + dsp_calc_ea(value, addr_name); + if (memspace) { + sprintf(name,"y:%s",addr_name); + } else { + sprintf(name,"x:%s",addr_name); } - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: bclr #%d,%s\n",dsp_core->pc, numbit, name); + sprintf(str_instr,"bset #%d,%s", numbit, name); } -static void dsp_bset(void) +static void dsp_bset_pp(void) { - char name[16], addr_name[16]; + /* bset #n,x:pp */ + /* bset #n,y:pp */ + char name[16]; Uint32 memspace, value, numbit; memspace = (cur_inst>>6) & 1; value = (cur_inst>>8) & BITMASK(6); numbit = cur_inst & BITMASK(5); - switch((cur_inst>>14) & BITMASK(2)) { - case 0: - /* bset #n,x:aa */ - /* bset #n,y:aa */ - if (memspace) { - sprintf(name,"y:0x%04x",value); - } else { - sprintf(name,"x:0x%04x",value); - } - break; - case 1: - /* bset #n,x:ea */ - /* bset #n,y:ea */ - dsp_calc_ea(value, addr_name); - if (memspace) { - sprintf(name,"y:%s",addr_name); - } else { - sprintf(name,"x:%s",addr_name); - } - break; - case 2: - /* bset #n,x:pp */ - /* bset #n,y:pp */ - if (memspace) { - sprintf(name,"y:0x%04x",value+0xffc0); - } else { - sprintf(name,"x:0x%04x",value+0xffc0); - } - break; - case 3: - /* bset #n,R */ - sprintf(name,"%s",registers_name[value]); - registers_changed[value]=1; - break; + if (memspace) { + sprintf(name,"y:$%04x",value+0xffc0); + } else { + sprintf(name,"x:$%04x",value+0xffc0); } - registers_changed[DSP_REG_SR]=1; + sprintf(str_instr,"bset #%d,%s", numbit, name); +} + +static void dsp_bset_reg(void) +{ + /* bset #n,R */ + Uint32 value, numbit; + + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + sprintf(str_instr,"bset #%d,%s", numbit, registers_name[value]); +} + +static void dsp_btst_aa(void) +{ + /* btst #n,x:aa */ + /* btst #n,y:aa */ + char name[16]; + Uint32 memspace, value, numbit; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + if (memspace) { + sprintf(name,"y:$%04x",value); + } else { + sprintf(name,"x:$%04x",value); + } - fprintf(stderr,"Dsp: 0x%04x: bset #%d,%s\n",dsp_core->pc, numbit, name); + sprintf(str_instr,"btst #%d,%s", numbit, name); } -static void dsp_btst(void) +static void dsp_btst_ea(void) { + /* btst #n,x:ea */ + /* btst #n,y:ea */ char name[16], addr_name[16]; Uint32 memspace, value, numbit; @@ -1086,45 +962,45 @@ static void dsp_btst(void) value = (cur_inst>>8) & BITMASK(6); numbit = cur_inst & BITMASK(5); - switch((cur_inst>>14) & BITMASK(2)) { - case 0: - /* btst #n,x:aa */ - /* btst #n,y:aa */ - if (memspace) { - sprintf(name,"y:0x%04x",value); - } else { - sprintf(name,"x:0x%04x",value); - } - break; - case 1: - /* btst #n,x:ea */ - /* btst #n,y:ea */ - dsp_calc_ea(value, addr_name); - if (memspace) { - sprintf(name,"y:%s",addr_name); - } else { - sprintf(name,"x:%s",addr_name); - } - break; - case 2: - /* btst #n,x:pp */ - /* btst #n,y:pp */ - if (memspace) { - sprintf(name,"y:0x%04x",value+0xffc0); - } else { - sprintf(name,"x:0x%04x",value+0xffc0); - } - break; - case 3: - /* btst #n,R */ - sprintf(name,"%s",registers_name[value]); - registers_changed[value]=1; - break; + dsp_calc_ea(value, addr_name); + if (memspace) { + sprintf(name,"y:%s",addr_name); + } else { + sprintf(name,"x:%s",addr_name); + } + + sprintf(str_instr,"btst #%d,%s", numbit, name); +} + +static void dsp_btst_pp(void) +{ + /* btst #n,x:pp */ + /* btst #n,y:pp */ + char name[16]; + Uint32 memspace, value, numbit; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + if (memspace) { + sprintf(name,"y:$%04x",value+0xffc0); + } else { + sprintf(name,"x:$%04x",value+0xffc0); } - registers_changed[DSP_REG_SR]=1; + sprintf(str_instr,"btst #%d,%s", numbit, name); +} + +static void dsp_btst_reg(void) +{ + /* btst #n,R */ + Uint32 value, numbit; + + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); - fprintf(stderr,"Dsp: 0x%04x: btst #%d,%s\n",dsp_core->pc, numbit, name); + sprintf(str_instr,"btst #%d,%s", numbit, registers_name[value]); } static void dsp_div(void) @@ -1146,58 +1022,45 @@ static void dsp_div(void) break; } destreg = DSP_REG_A+((cur_inst>>3) & 1); - registers_changed[destreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: div %s,%s\n",dsp_core->pc, registers_name[srcreg],registers_name[destreg]); -} -static void dsp_do(void) -{ - Uint32 value; - - value = (cur_inst>>12) & (BITMASK(2)<<2); - value |= (cur_inst>>6) & 1<<1; - value |= (cur_inst>>5) & 1; - - opcodes_do[value](); - - registers_changed[DSP_REG_LA]=1; - registers_changed[DSP_REG_LC]=1; - registers_changed[DSP_REG_SR]=1; + sprintf(str_instr,"div %s,%s", registers_name[srcreg],registers_name[destreg]); } -static void dsp_do_0(void) +static void dsp_do_aa(void) { char name[16]; + disasm_cur_inst_len++; + if (cur_inst & (1<<6)) { - sprintf(name, "y:0x%04x", (cur_inst>>8) & BITMASK(6)); + sprintf(name, "y:$%04x", (cur_inst>>8) & BITMASK(6)); } else { - sprintf(name, "x:0x%04x", (cur_inst>>8) & BITMASK(6)); + sprintf(name, "x:$%04x", (cur_inst>>8) & BITMASK(6)); } - fprintf(stderr,"Dsp: 0x%04x: do %s,p:0x%04x\n", - dsp_core->pc, + sprintf(str_instr,"do %s,p:$%04x", name, - read_memory(dsp_core->pc+1) + read_memory(dsp_core.pc+1) ); } -static void dsp_do_2(void) +static void dsp_do_imm(void) { - fprintf(stderr,"Dsp: 0x%04x: do #0x%04x,p:0x%04x\n", - dsp_core->pc, + disasm_cur_inst_len++; + + sprintf(str_instr,"do #$%04x,p:$%04x", ((cur_inst>>8) & BITMASK(8))|((cur_inst & BITMASK(4))<<8), - read_memory(dsp_core->pc+1) + read_memory(dsp_core.pc+1) ); } -static void dsp_do_4(void) +static void dsp_do_ea(void) { char addr_name[16], name[16]; Uint32 ea_mode; + disasm_cur_inst_len++; + ea_mode = (cur_inst>>8) & BITMASK(6); dsp_calc_ea(ea_mode, addr_name); @@ -1207,339 +1070,510 @@ static void dsp_do_4(void) sprintf(name, "x:%s", addr_name); } - fprintf(stderr,"Dsp: 0x%04x: do %s,p:0x%04x\n", - dsp_core->pc, + sprintf(str_instr,"do %s,p:$%04x", name, - read_memory(dsp_core->pc+1) + read_memory(dsp_core.pc+1) ); } -static void dsp_do_c(void) +static void dsp_do_reg(void) { - fprintf(stderr,"Dsp: 0x%04x: do %s,p:0x%04x\n", - dsp_core->pc, + disasm_cur_inst_len++; + + sprintf(str_instr,"do %s,p:$%04x", registers_name[(cur_inst>>8) & BITMASK(6)], - read_memory(dsp_core->pc+1) + read_memory(dsp_core.pc+1) ); } static void dsp_enddo(void) { - fprintf(stderr,"Dsp: 0x%04x: enddo\n",dsp_core->pc); + sprintf(str_instr,"enddo"); } static void dsp_illegal(void) { - fprintf(stderr,"Dsp: 0x%04x: illegal\n",dsp_core->pc); + sprintf(str_instr,"illegal"); } -static void dsp_jcc(void) +static void dsp_jcc_ea(void) { char cond_name[16], addr_name[16]; Uint32 cc_code=0; - switch((cur_inst >> 16) & BITMASK(8)) { - case 0x0a: - dsp_calc_ea((cur_inst >>8) & BITMASK(6), addr_name); - cc_code=cur_inst & BITMASK(4); - break; - case 0x0e: - sprintf(addr_name, "0x%04x", cur_inst & BITMASK(12)); - cc_code=(cur_inst>>12) & BITMASK(4); - break; - } + dsp_calc_ea((cur_inst >>8) & BITMASK(6), addr_name); + cc_code=cur_inst & BITMASK(4); dsp_calc_cc(cc_code, cond_name); - fprintf(stderr,"Dsp: 0x%04x: j%s p:%s\n",dsp_core->pc, cond_name, addr_name); + sprintf(str_instr,"j%s p:%s", cond_name, addr_name); +} + +static void dsp_jcc_imm(void) +{ + char cond_name[16], addr_name[16]; + Uint32 cc_code=0; + + sprintf(addr_name, "$%04x", cur_inst & BITMASK(12)); + cc_code=(cur_inst>>12) & BITMASK(4); + dsp_calc_cc(cc_code, cond_name); + + sprintf(str_instr,"j%s p:%s", cond_name, addr_name); +} + +static void dsp_jclr_aa(void) +{ + /* jclr #n,x:aa,p:xx */ + /* jclr #n,y:aa,p:xx */ + char srcname[16]; + Uint32 memspace, value, numbit; + + disasm_cur_inst_len++; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + if (memspace) { + sprintf(srcname, "y:$%04x", value); + } else { + sprintf(srcname, "x:$%04x", value); + } + + sprintf(str_instr,"jclr #%d,%s,p:$%04x", + numbit, + srcname, + read_memory(dsp_core.pc+1) + ); } -static void dsp_jclr(void) +static void dsp_jclr_ea(void) { + /* jclr #n,x:ea,p:xx */ + /* jclr #n,y:ea,p:xx */ char srcname[16], addr_name[16]; Uint32 memspace, value, numbit; + disasm_cur_inst_len++; + memspace = (cur_inst>>6) & 1; value = (cur_inst>>8) & BITMASK(6); numbit = cur_inst & BITMASK(5); - switch((cur_inst>>14) & BITMASK(2)) { - case 0: - /* jclr #n,x:aa,p:xx */ - /* jclr #n,y:aa,p:xx */ - if (memspace) { - sprintf(srcname, "y:0x%04x", value); - } else { - sprintf(srcname, "x:0x%04x", value); - } - break; - case 1: - /* jclr #n,x:ea,p:xx */ - /* jclr #n,y:ea,p:xx */ - dsp_calc_ea(value, addr_name); - if (memspace) { - sprintf(srcname, "y:%s", addr_name); - } else { - sprintf(srcname, "x:%s", addr_name); - } - break; - case 2: - /* jclr #n,x:pp,p:xx */ - /* jclr #n,y:pp,p:xx */ - value += 0xffc0; - if (memspace) { - sprintf(srcname, "y:0x%04x", value); - } else { - sprintf(srcname, "x:0x%04x", value); - } - break; - case 3: - /* jclr #n,R,p:xx */ - sprintf(srcname, registers_name[value]); - break; + dsp_calc_ea(value, addr_name); + if (memspace) { + sprintf(srcname, "y:%s", addr_name); + } else { + sprintf(srcname, "x:%s", addr_name); } - fprintf(stderr,"Dsp: 0x%04x: jclr #%d,%s,p:0x%04x\n", - dsp_core->pc, + sprintf(str_instr,"jclr #%d,%s,p:$%04x", numbit, srcname, - read_memory(dsp_core->pc+1) + read_memory(dsp_core.pc+1) ); } -static void dsp_jmp(void) +static void dsp_jclr_pp(void) { - char dstname[16]; + /* jclr #n,x:pp,p:xx */ + /* jclr #n,y:pp,p:xx */ + char srcname[16]; + Uint32 memspace, value, numbit; + + disasm_cur_inst_len++; - switch((cur_inst >> 16) & BITMASK(8)) { - case 0x0a: - dsp_calc_ea((cur_inst >>8) & BITMASK(6), dstname); - break; - case 0x0c: - sprintf(dstname, "0x%04x", cur_inst & BITMASK(12)); - break; + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + value += 0xffc0; + if (memspace) { + sprintf(srcname, "y:$%04x", value); + } else { + sprintf(srcname, "x:$%04x", value); } - fprintf(stderr,"Dsp: 0x%04x: jmp p:%s\n",dsp_core->pc, dstname); + sprintf(str_instr,"jclr #%d,%s,p:$%04x", + numbit, + srcname, + read_memory(dsp_core.pc+1) + ); +} + +static void dsp_jclr_reg(void) +{ + /* jclr #n,R,p:xx */ + Uint32 value, numbit; + + disasm_cur_inst_len++; + + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + sprintf(str_instr,"jclr #%d,%s,p:$%04x", + numbit, + registers_name[value], + read_memory(dsp_core.pc+1) + ); } -static void dsp_jscc(void) +static void dsp_jmp_imm(void) +{ + sprintf(str_instr,"jmp p:$%04x", cur_inst & BITMASK(12)); +} + +static void dsp_jmp_ea(void) +{ + char dstname[16]; + + dsp_calc_ea((cur_inst >>8) & BITMASK(6), dstname); + + sprintf(str_instr,"jmp p:%s", dstname); +} + +static void dsp_jscc_ea(void) { char cond_name[16], addr_name[16]; Uint32 cc_code=0; - switch((cur_inst >> 16) & BITMASK(8)) { - case 0x0b: - dsp_calc_ea((cur_inst >>8) & BITMASK(6), addr_name); - cc_code=cur_inst & BITMASK(4); - break; - case 0x0f: - sprintf(addr_name, "0x%04x", cur_inst & BITMASK(12)); - cc_code=(cur_inst>>12) & BITMASK(4); - break; - } + dsp_calc_ea((cur_inst>>8) & BITMASK(6), addr_name); + cc_code=cur_inst & BITMASK(4); + dsp_calc_cc(cc_code, cond_name); + + sprintf(str_instr,"js%s p:%s", cond_name, addr_name); +} + +static void dsp_jscc_imm(void) +{ + char cond_name[16], addr_name[16]; + Uint32 cc_code=0; + + sprintf(addr_name, "$%04x", cur_inst & BITMASK(12)); + cc_code=(cur_inst>>12) & BITMASK(4); dsp_calc_cc(cc_code, cond_name); - fprintf(stderr,"Dsp: 0x%04x: js%s p:%s\n",dsp_core->pc, cond_name, addr_name); + sprintf(str_instr,"js%s p:%s", cond_name, addr_name); } + +static void dsp_jsclr_aa(void) +{ + /* jsclr #n,x:aa,p:xx */ + /* jsclr #n,y:aa,p:xx */ + char srcname[16]; + Uint32 memspace, value, numbit; -static void dsp_jsclr(void) + disasm_cur_inst_len++; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + if (memspace) { + sprintf(srcname, "y:$%04x", value); + } else { + sprintf(srcname, "x:$%04x", value); + } + + sprintf(str_instr,"jsclr #%d,%s,p:$%04x", + numbit, + srcname, + read_memory(dsp_core.pc+1) + ); +} + +static void dsp_jsclr_ea(void) { + /* jsclr #n,x:ea,p:xx */ + /* jsclr #n,y:ea,p:xx */ char srcname[16], addr_name[16]; Uint32 memspace, value, numbit; + disasm_cur_inst_len++; + memspace = (cur_inst>>6) & 1; value = (cur_inst>>8) & BITMASK(6); numbit = cur_inst & BITMASK(5); - switch((cur_inst>>14) & BITMASK(2)) { - case 0: - /* jsclr #n,x:aa,p:xx */ - /* jsclr #n,y:aa,p:xx */ - if (memspace) { - sprintf(srcname, "y:0x%04x", value); - } else { - sprintf(srcname, "x:0x%04x", value); - } - break; - case 1: - /* jsclr #n,x:ea,p:xx */ - /* jsclr #n,y:ea,p:xx */ - dsp_calc_ea(value, addr_name); - if (memspace) { - sprintf(srcname, "y:%s", addr_name); - } else { - sprintf(srcname, "x:%s", addr_name); - } - break; - case 2: - /* jsclr #n,x:pp,p:xx */ - /* jsclr #n,y:pp,p:xx */ - value += 0xffc0; - if (memspace) { - sprintf(srcname, "y:0x%04x", value); - } else { - sprintf(srcname, "x:0x%04x", value); - } - break; - case 3: - /* jsclr #n,R,p:xx */ - sprintf(srcname, registers_name[value]); - break; + dsp_calc_ea(value, addr_name); + if (memspace) { + sprintf(srcname, "y:%s", addr_name); + } else { + sprintf(srcname, "x:%s", addr_name); + } + + sprintf(str_instr,"jsclr #%d,%s,p:$%04x", + numbit, + srcname, + read_memory(dsp_core.pc+1) + ); +} + +static void dsp_jsclr_pp(void) +{ + /* jsclr #n,x:pp,p:xx */ + /* jsclr #n,y:pp,p:xx */ + char srcname[16]; + Uint32 memspace, value, numbit; + + disasm_cur_inst_len++; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + value += 0xffc0; + if (memspace) { + sprintf(srcname, "y:$%04x", value); + } else { + sprintf(srcname, "x:$%04x", value); } - fprintf(stderr,"Dsp: 0x%04x: jsclr #%d,%s,p:0x%04x\n", - dsp_core->pc, + sprintf(str_instr,"jsclr #%d,%s,p:$%04x", numbit, srcname, - read_memory(dsp_core->pc+1) + read_memory(dsp_core.pc+1) ); } -static void dsp_jset(void) +static void dsp_jsclr_reg(void) { + /* jsclr #n,R,p:xx */ + Uint32 value, numbit; + + disasm_cur_inst_len++; + + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + sprintf(str_instr,"jsclr #%d,%s,p:$%04x", + numbit, + registers_name[value], + read_memory(dsp_core.pc+1) + ); +} + +static void dsp_jset_aa(void) +{ + /* jset #n,x:aa,p:xx */ + /* jset #n,y:aa,p:xx */ + char srcname[16]; + Uint32 memspace, value, numbit; + + disasm_cur_inst_len++; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + if (memspace) { + sprintf(srcname, "y:$%04x", value); + } else { + sprintf(srcname, "x:$%04x", value); + } + + sprintf(str_instr,"jset #%d,%s,p:$%04x", + numbit, + srcname, + read_memory(dsp_core.pc+1) + ); +} + +static void dsp_jset_ea(void) +{ + /* jset #n,x:ea,p:xx */ + /* jset #n,y:ea,p:xx */ char srcname[16], addr_name[16]; Uint32 memspace, value, numbit; + disasm_cur_inst_len++; + memspace = (cur_inst>>6) & 1; value = (cur_inst>>8) & BITMASK(6); numbit = cur_inst & BITMASK(5); - switch((cur_inst>>14) & BITMASK(2)) { - case 0: - /* jset #n,x:aa,p:xx */ - /* jset #n,y:aa,p:xx */ - if (memspace) { - sprintf(srcname, "y:0x%04x", value); - } else { - sprintf(srcname, "x:0x%04x", value); - } - break; - case 1: - /* jset #n,x:ea,p:xx */ - /* jset #n,y:ea,p:xx */ - dsp_calc_ea(value, addr_name); - if (memspace) { - sprintf(srcname, "y:%s", addr_name); - } else { - sprintf(srcname, "x:%s", addr_name); - } - break; - case 2: - /* jset #n,x:pp,p:xx */ - /* jset #n,y:pp,p:xx */ - value += 0xffc0; - if (memspace) { - sprintf(srcname, "y:0x%04x", value); - } else { - sprintf(srcname, "x:0x%04x", value); - } - break; - case 3: - /* jset #n,R,p:xx */ - sprintf(srcname, registers_name[value]); - break; + dsp_calc_ea(value, addr_name); + if (memspace) { + sprintf(srcname, "y:%s", addr_name); + } else { + sprintf(srcname, "x:%s", addr_name); + } + + sprintf(str_instr,"jset #%d,%s,p:$%04x", + numbit, + srcname, + read_memory(dsp_core.pc+1) + ); +} + +static void dsp_jset_pp(void) +{ + /* jset #n,x:pp,p:xx */ + /* jset #n,y:pp,p:xx */ + char srcname[16]; + Uint32 memspace, value, numbit; + + disasm_cur_inst_len++; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + value += 0xffc0; + if (memspace) { + sprintf(srcname, "y:$%04x", value); + } else { + sprintf(srcname, "x:$%04x", value); } - fprintf(stderr,"Dsp: 0x%04x: jset #%d,%s,p:0x%04x\n", - dsp_core->pc, + sprintf(str_instr,"jset #%d,%s,p:$%04x", numbit, srcname, - read_memory(dsp_core->pc+1) + read_memory(dsp_core.pc+1) ); } -static void dsp_jsr(void) +static void dsp_jset_reg(void) +{ + /* jset #n,R,p:xx */ + Uint32 value, numbit; + + disasm_cur_inst_len++; + + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + sprintf(str_instr,"jset #%d,%s,p:$%04x", + numbit, + registers_name[value], + read_memory(dsp_core.pc+1) + ); +} + +static void dsp_jsr_imm(void) +{ + sprintf(str_instr,"jsr p:$%04x", cur_inst & BITMASK(12)); +} + +static void dsp_jsr_ea(void) { char dstname[16]; - if (((cur_inst>>12) & BITMASK(4))==0) { - sprintf(dstname, "0x%04x", cur_inst & BITMASK(12)); + dsp_calc_ea((cur_inst>>8) & BITMASK(6),dstname); + + sprintf(str_instr,"jsr p:%s", dstname); +} + +static void dsp_jsset_aa(void) +{ + /* jsset #n,x:aa,p:xx */ + /* jsset #n,y:aa,p:xx */ + char srcname[16]; + Uint32 memspace, value, numbit; + + disasm_cur_inst_len++; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + if (memspace) { + sprintf(srcname, "y:$%04x", value); } else { - dsp_calc_ea((cur_inst>>8) & BITMASK(6),dstname); + sprintf(srcname, "x:$%04x", value); } - fprintf(stderr,"Dsp: 0x%04x: jsr p:%s\n",dsp_core->pc, dstname); + sprintf(str_instr,"jsset #%d,%s,p:$%04x", + numbit, + srcname, + read_memory(dsp_core.pc+1) + ); } -static void dsp_jsset(void) +static void dsp_jsset_ea(void) { + /* jsset #n,x:ea,p:xx */ + /* jsset #n,y:ea,p:xx */ char srcname[16], addr_name[16]; Uint32 memspace, value, numbit; + disasm_cur_inst_len++; + memspace = (cur_inst>>6) & 1; value = (cur_inst>>8) & BITMASK(6); numbit = cur_inst & BITMASK(5); - switch((cur_inst>>14) & BITMASK(2)) { - case 0: - /* jsset #n,x:aa,p:xx */ - /* jsset #n,y:aa,p:xx */ - if (memspace) { - sprintf(srcname, "y:0x%04x", value); - } else { - sprintf(srcname, "x:0x%04x", value); - } - break; - case 1: - /* jsset #n,x:ea,p:xx */ - /* jsset #n,y:ea,p:xx */ - dsp_calc_ea(value, addr_name); - if (memspace) { - sprintf(srcname, "y:%s", addr_name); - } else { - sprintf(srcname, "x:%s", addr_name); - } - break; - case 2: - /* jsset #n,x:pp,p:xx */ - /* jsset #n,y:pp,p:xx */ - value += 0xffc0; - if (memspace) { - sprintf(srcname, "y:0x%04x", value); - } else { - sprintf(srcname, "x:0x%04x", value); - } - break; - case 3: - /* jsset #n,R,p:xx */ - sprintf(srcname, registers_name[value]); - break; + dsp_calc_ea(value, addr_name); + if (memspace) { + sprintf(srcname, "y:%s", addr_name); + } else { + sprintf(srcname, "x:%s", addr_name); } - fprintf(stderr,"Dsp: 0x%04x: jsset #%d,%s,p:0x%04x\n", - dsp_core->pc, + sprintf(str_instr,"jsset #%d,%s,p:$%04x", numbit, srcname, - read_memory(dsp_core->pc+1) + read_memory(dsp_core.pc+1) ); } -static void dsp_lua(void) +static void dsp_jsset_pp(void) { - char addr_name[16], numreg; - - dsp_calc_ea((cur_inst>>8) & BITMASK(5), addr_name); - numreg = cur_inst & BITMASK(3); - registers_changed[DSP_REG_R0+numreg]=1; + /* jsset #n,x:pp,p:xx */ + /* jsset #n,y:pp,p:xx */ + char srcname[16]; + Uint32 memspace, value, numbit; - fprintf(stderr,"Dsp: 0x%04x: lua %s,r%d\n",dsp_core->pc, addr_name, numreg); + disasm_cur_inst_len++; + + memspace = (cur_inst>>6) & 1; + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + value += 0xffc0; + if (memspace) { + sprintf(srcname, "y:$%04x", value); + } else { + sprintf(srcname, "x:$%04x", value); + } + + sprintf(str_instr,"jsset #%d,%s,p:$%04x", + numbit, + srcname, + read_memory(dsp_core.pc+1) + ); } -static void dsp_movec(void) +static void dsp_jsset_reg(void) { - Uint32 value; + /* jsset #n,r,p:xx */ + Uint32 value, numbit; - value = (cur_inst>>13) & (1<<3); - value |= (cur_inst>>12) & (1<<2); - value |= (cur_inst>>6) & (1<<1); - value |= (cur_inst>>5) & 1; + disasm_cur_inst_len++; - opcodes_movec[value](); + value = (cur_inst>>8) & BITMASK(6); + numbit = cur_inst & BITMASK(5); + + sprintf(str_instr,"jsset #%d,%s,p:$%04x", + numbit, + registers_name[value], + read_memory(dsp_core.pc+1) + ); +} + +static void dsp_lua(void) +{ + char addr_name[16], numreg; - registers_changed[DSP_REG_SR]=1; + dsp_calc_ea((cur_inst>>8) & BITMASK(5), addr_name); + numreg = cur_inst & BITMASK(3); + + if (cur_inst & (1<<3)) + sprintf(str_instr,"lua %s,n%d", addr_name, numreg); + else + sprintf(str_instr,"lua %s,r%d", addr_name, numreg); } -static void dsp_movec_7(void) +static void dsp_movec_reg(void) { Uint32 numreg1, numreg2; @@ -1547,20 +1581,18 @@ static void dsp_movec_7(void) /* S2,D1 */ numreg2 = (cur_inst>>8) & BITMASK(6); - numreg1 = (cur_inst & BITMASK(5))|0x20; + numreg1 = cur_inst & BITMASK(6); if (cur_inst & (1<<15)) { /* Write D1 */ - fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_core->pc, registers_name[numreg2], registers_name[numreg1]); - registers_changed[numreg1]=1; + sprintf(str_instr,"movec %s,%s", registers_name[numreg2], registers_name[numreg1]); } else { /* Read S1 */ - fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_core->pc, registers_name[numreg1], registers_name[numreg2]); - registers_changed[numreg2]=1; + sprintf(str_instr,"movec %s,%s", registers_name[numreg1], registers_name[numreg2]); } } -static void dsp_movec_9(void) +static void dsp_movec_aa(void) { const char *spacename; char srcname[16],dstname[16]; @@ -1571,7 +1603,7 @@ static void dsp_movec_9(void) /* y:aa,D1 */ /* S1,y:aa */ - numreg = (cur_inst & BITMASK(5))|0x20; + numreg = cur_inst & BITMASK(6); addr = (cur_inst>>8) & BITMASK(6); if (cur_inst & (1<<6)) { @@ -1582,30 +1614,29 @@ static void dsp_movec_9(void) if (cur_inst & (1<<15)) { /* Write D1 */ - sprintf(srcname, "%s:0x%04x", spacename, addr); + sprintf(srcname, "%s:$%04x", spacename, addr); strcpy(dstname, registers_name[numreg]); } else { /* Read S1 */ strcpy(srcname, registers_name[numreg]); - sprintf(dstname, "%s:0x%04x", spacename, addr); + sprintf(dstname, "%s:$%04x", spacename, addr); } - fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_core->pc, srcname, dstname); + sprintf(str_instr,"movec %s,%s", srcname, dstname); } -static void dsp_movec_b(void) +static void dsp_movec_imm(void) { Uint32 numreg; /* #xx,D1 */ - numreg = (cur_inst & BITMASK(5))|0x20; + numreg = cur_inst & BITMASK(6); - registers_changed[numreg]=1; - fprintf(stderr,"Dsp: 0x%04x: movec #0x%02x,%s\n",dsp_core->pc, (cur_inst>>8) & BITMASK(8), registers_name[numreg]); + sprintf(str_instr,"movec #$%02x,%s", (cur_inst>>8) & BITMASK(8), registers_name[numreg]); } -static void dsp_movec_d(void) +static void dsp_movec_ea(void) { const char *spacename; char srcname[16], dstname[16], addr_name[16]; @@ -1618,7 +1649,7 @@ static void dsp_movec_d(void) /* S1,y:ea */ /* #xxxx,D1 */ - numreg = (cur_inst & BITMASK(5))|0x20; + numreg = cur_inst & BITMASK(6); ea_mode = (cur_inst>>8) & BITMASK(6); retour = dsp_calc_ea(ea_mode, addr_name); @@ -1635,7 +1666,6 @@ static void dsp_movec_d(void) } else { sprintf(srcname, "%s:%s", spacename, addr_name); } - registers_changed[numreg]=1; strcpy(dstname, registers_name[numreg]); } else { /* Read S1 */ @@ -1643,31 +1673,20 @@ static void dsp_movec_d(void) sprintf(dstname, "%s:%s", spacename, addr_name); } - fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_core->pc, srcname, dstname); + sprintf(str_instr,"movec %s,%s", srcname, dstname); } -static void dsp_movem(void) +static void dsp_movem_aa(void) { + /* S,p:aa */ + /* p:aa,D */ char addr_name[16], srcname[16], dstname[16]; - Uint32 ea_mode, numreg; - - if (cur_inst & (1<<14)) { - /* S,p:ea */ - /* p:ea,D */ - - ea_mode = (cur_inst>>8) & BITMASK(6); - dsp_calc_ea(ea_mode, addr_name); - } else { - /* S,p:aa */ - /* p:aa,D */ - - sprintf(addr_name, "0x%04x",(cur_inst>>8) & BITMASK(6)); - } + Uint32 numreg; + sprintf(addr_name, "$%04x",(cur_inst>>8) & BITMASK(6)); numreg = cur_inst & BITMASK(6); if (cur_inst & (1<<15)) { /* Write D */ - registers_changed[numreg]=1; sprintf(srcname, "p:%s", addr_name); strcpy(dstname, registers_name[numreg]); } else { @@ -1676,19 +1695,30 @@ static void dsp_movem(void) sprintf(dstname, "p:%s", addr_name); } - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: movem %s,%s\n",dsp_core->pc, srcname, dstname); + sprintf(str_instr,"movem %s,%s", srcname, dstname); } -static void dsp_movep(void) +static void dsp_movem_ea(void) { - Uint32 value; - - value = (cur_inst>>6) & BITMASK(2); + /* S,p:ea */ + /* p:ea,D */ + char addr_name[16], srcname[16], dstname[16]; + Uint32 ea_mode, numreg; - opcodes_movep[value](); - registers_changed[DSP_REG_SR]=1; + ea_mode = (cur_inst>>8) & BITMASK(6); + dsp_calc_ea(ea_mode, addr_name); + numreg = cur_inst & BITMASK(6); + if (cur_inst & (1<<15)) { + /* Write D */ + sprintf(srcname, "p:%s", addr_name); + strcpy(dstname, registers_name[numreg]); + } else { + /* Read S */ + strcpy(srcname, registers_name[numreg]); + sprintf(dstname, "p:%s", addr_name); + } + + sprintf(str_instr,"movem %s,%s", srcname, dstname); } static void dsp_movep_0(void) @@ -1711,24 +1741,23 @@ static void dsp_movep_0(void) strcpy(srcname, registers_name[numreg]); if (memspace) { - sprintf(dstname, "y:0x%04x", addr); + sprintf(dstname, "y:$%04x", addr); } else { - sprintf(dstname, "x:0x%04x", addr); + sprintf(dstname, "x:$%04x", addr); } } else { /* Read pp */ if (memspace) { - sprintf(srcname, "y:0x%04x", addr); + sprintf(srcname, "y:$%04x", addr); } else { - sprintf(srcname, "x:0x%04x", addr); + sprintf(srcname, "x:$%04x", addr); } - registers_changed[numreg]=1; strcpy(dstname, registers_name[numreg]); } - fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_core->pc, srcname, dstname); + sprintf(str_instr,"movep %s,%s", srcname, dstname); } static void dsp_movep_1(void) @@ -1751,26 +1780,26 @@ static void dsp_movep_1(void) sprintf(srcname, "p:%s", name); if (memspace) { - sprintf(dstname, "y:0x%04x", addr); + sprintf(dstname, "y:$%04x", addr); } else { - sprintf(dstname, "x:0x%04x", addr); + sprintf(dstname, "x:$%04x", addr); } } else { /* Read pp */ if (memspace) { - sprintf(srcname, "y:0x%04x", addr); + sprintf(srcname, "y:$%04x", addr); } else { - sprintf(srcname, "x:0x%04x", addr); + sprintf(srcname, "x:$%04x", addr); } sprintf(dstname, "p:%s", name); } - fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_core->pc, srcname, dstname); + sprintf(str_instr,"movep %s,%s", srcname, dstname); } -static void dsp_movep_2(void) +static void dsp_movep_23(void) { char srcname[16]="",dstname[16]="",name[16]=""; Uint32 addr, memspace, easpace, retour; @@ -1806,17 +1835,17 @@ static void dsp_movep_2(void) } if (memspace) { - sprintf(dstname, "y:0x%04x", addr); + sprintf(dstname, "y:$%04x", addr); } else { - sprintf(dstname, "x:0x%04x", addr); + sprintf(dstname, "x:$%04x", addr); } } else { /* Read pp */ if (memspace) { - sprintf(srcname, "y:0x%04x", addr); + sprintf(srcname, "y:$%04x", addr); } else { - sprintf(srcname, "x:0x%04x", addr); + sprintf(srcname, "x:$%04x", addr); } if (easpace) { @@ -1826,12 +1855,12 @@ static void dsp_movep_2(void) } } - fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_core->pc, srcname, dstname); + sprintf(str_instr,"movep %s,%s", srcname, dstname); } static void dsp_nop(void) { - fprintf(stderr,"Dsp: 0x%04x: nop\n",dsp_core->pc); + sprintf(str_instr,"nop"); } static void dsp_norm(void) @@ -1841,59 +1870,28 @@ static void dsp_norm(void) srcreg = DSP_REG_R0+((cur_inst>>8) & BITMASK(3)); destreg = DSP_REG_A+((cur_inst>>3) & 1); - registers_changed[srcreg]=1; - registers_changed[destreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: norm %s,%s\n",dsp_core->pc, registers_name[srcreg], registers_name[destreg]); + sprintf(str_instr,"norm %s,%s", registers_name[srcreg], registers_name[destreg]); } static void dsp_ori(void) { - const char *regname; - switch(cur_inst & BITMASK(2)) { case 0: - regname="mr"; - registers_changed[DSP_REG_SR]=1; + sprintf(str_instr,"ori #$%02x,mr", (cur_inst>>8) & BITMASK(8)); break; case 1: - regname="ccr"; - registers_changed[DSP_REG_SR]=1; + sprintf(str_instr,"ori #$%02x,ccr", (cur_inst>>8) & BITMASK(8)); break; case 2: - regname="omr"; - registers_changed[DSP_REG_OMR]=1; + sprintf(str_instr,"ori #$%02x,omr", (cur_inst>>8) & BITMASK(8)); break; default: - regname=""; break; } - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: ori #0x%02x,%s\n", - dsp_core->pc, - (cur_inst>>8) & BITMASK(8), - regname - ); -} - -static void dsp_rep(void) -{ - Uint32 value; - - value = (cur_inst>>12) & (BITMASK(2)<<2); - value |= (cur_inst>>6) & (1<<1); - value |= (cur_inst>>5) & 1; - - opcodes_rep[value](); - - registers_changed[DSP_REG_LC]=1; - registers_changed[DSP_REG_SR]=1; } -static void dsp_rep_1(void) +static void dsp_rep_aa(void) { char name[16]; @@ -1901,21 +1899,22 @@ static void dsp_rep_1(void) /* y:aa */ if (cur_inst & (1<<6)) { - sprintf(name, "y:0x%04x",(cur_inst>>8) & BITMASK(6)); + sprintf(name, "y:$%04x",(cur_inst>>8) & BITMASK(6)); } else { - sprintf(name, "x:0x%04x",(cur_inst>>8) & BITMASK(6)); + sprintf(name, "x:$%04x",(cur_inst>>8) & BITMASK(6)); } - fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_core->pc, name); + sprintf(str_instr,"rep %s", name); } -static void dsp_rep_3(void) +static void dsp_rep_imm(void) { /* #xxx */ - fprintf(stderr,"Dsp: 0x%04x: rep #0x%02x\n",dsp_core->pc, (cur_inst>>8) & BITMASK(8)); + sprintf(str_instr,"rep #$%02x", ((cur_inst>>8) & BITMASK(8)) + + ((cur_inst & BITMASK(4))<<8)); } -static void dsp_rep_5(void) +static void dsp_rep_ea(void) { char name[16],addr_name[16]; @@ -1929,41 +1928,39 @@ static void dsp_rep_5(void) sprintf(name, "x:%s",addr_name); } - fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_core->pc, name); + sprintf(str_instr,"rep %s", name); } -static void dsp_rep_d(void) +static void dsp_rep_reg(void) { /* R */ - fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_core->pc, registers_name[(cur_inst>>8) & BITMASK(6)]); + sprintf(str_instr,"rep %s", registers_name[(cur_inst>>8) & BITMASK(6)]); } static void dsp_reset(void) { - fprintf(stderr,"Dsp: 0x%04x: reset\n",dsp_core->pc); + sprintf(str_instr,"reset"); } static void dsp_rti(void) { - registers_changed[DSP_REG_SR]=1; - fprintf(stderr,"Dsp: 0x%04x: rti\n",dsp_core->pc); + sprintf(str_instr,"rti"); } static void dsp_rts(void) { - registers_changed[DSP_REG_SR]=1; - fprintf(stderr,"Dsp: 0x%04x: rts\n",dsp_core->pc); + sprintf(str_instr,"rts"); } static void dsp_stop(void) { - fprintf(stderr,"Dsp: 0x%04x: stop\n",dsp_core->pc); + sprintf(str_instr,"stop"); } static void dsp_swi(void) { - fprintf(stderr,"Dsp: 0x%04x: swi\n",dsp_core->pc); + sprintf(str_instr,"swi"); } static void dsp_tcc(void) @@ -1975,14 +1972,11 @@ static void dsp_tcc(void) src1reg = registers_tcc[(cur_inst>>3) & BITMASK(4)][0]; dst1reg = registers_tcc[(cur_inst>>3) & BITMASK(4)][1]; - registers_changed[dst1reg]=1; if (cur_inst & (1<<16)) { - src2reg = DSP_REG_R0+(cur_inst & BITMASK(3)); - dst2reg = DSP_REG_R0+((cur_inst>>8) & BITMASK(3)); + src2reg = DSP_REG_R0+((cur_inst>>8) & BITMASK(3)); + dst2reg = DSP_REG_R0+(cur_inst & BITMASK(3)); - registers_changed[dst2reg]=1; - fprintf(stderr,"Dsp: 0x%04x: t%s %s,%s %s,%s\n", - dsp_core->pc, + sprintf(str_instr,"t%s %s,%s %s,%s", ccname, registers_name[src1reg], registers_name[dst1reg], @@ -1990,8 +1984,7 @@ static void dsp_tcc(void) registers_name[dst2reg] ); } else { - fprintf(stderr,"Dsp: 0x%04x: t%s %s,%s\n", - dsp_core->pc, + sprintf(str_instr,"t%s %s,%s", ccname, registers_name[src1reg], registers_name[dst1reg] @@ -2001,7 +1994,7 @@ static void dsp_tcc(void) static void dsp_wait(void) { - fprintf(stderr,"Dsp: 0x%04x: wait\n",dsp_core->pc); + sprintf(str_instr,"wait"); } /********************************** @@ -2013,7 +2006,6 @@ static void dsp_pm(void) Uint32 value; value = (cur_inst >> 20) & BITMASK(4); - opcodes_parmove[value](); } @@ -2037,8 +2029,6 @@ static void dsp_pm_0(void) numreg2 = DSP_REG_X0; } - registers_changed[numreg1]=1; - sprintf(parallelmove_name, "%s,%s:%s %s,%s", registers_name[numreg1], @@ -2079,13 +2069,9 @@ static void dsp_pm_1(void) s1reg = DSP_REG_A+((cur_inst>>19) & 1); d1reg = DSP_REG_X0+((cur_inst>>18) & 1); - registers_changed[d1reg]=1; - if (write_flag) { /* Write D2 */ - registers_changed[d2reg]=1; - if (retour) { sprintf(parallelmove_name,"%s,%s #%s,%s", registers_name[s1reg], @@ -2123,13 +2109,9 @@ static void dsp_pm_1(void) s2reg = DSP_REG_A+((cur_inst>>17) & 1); d2reg = DSP_REG_Y0+((cur_inst>>16) & 1); - registers_changed[d2reg]=1; - if (write_flag) { /* Write D1 */ - registers_changed[d1reg]=1; - if (retour) { sprintf(parallelmove_name,"#%s,%s %s,%s", addr_name, @@ -2174,7 +2156,6 @@ static void dsp_pm_2(void) if (((cur_inst >> 8) & 0xffe0) == 0x2040) { dsp_calc_ea((cur_inst>>8) & BITMASK(5), addr_name); - registers_changed[DSP_REG_R0+((cur_inst>>8) & BITMASK(3))]=1; sprintf(parallelmove_name, "%s,r%d",addr_name, (cur_inst>>8) & BITMASK(3)); return; } @@ -2182,14 +2163,12 @@ static void dsp_pm_2(void) if (((cur_inst >> 8) & 0xfc00) == 0x2000) { numreg1 = (cur_inst>>13) & BITMASK(5); numreg2 = (cur_inst>>8) & BITMASK(5); - registers_changed[numreg2]=1; sprintf(parallelmove_name, "%s,%s", registers_name[numreg1], registers_name[numreg2]); return; } numreg1 = (cur_inst>>16) & BITMASK(5); - registers_changed[numreg1]=1; - sprintf(parallelmove_name, "#0x%02x,%s", (cur_inst >> 8) & BITMASK(8), registers_name[numreg1]); + sprintf(parallelmove_name, "#$%02x,%s", (cur_inst >> 8) & BITMASK(8), registers_name[numreg1]); } static void dsp_pm_4(void) @@ -2222,7 +2201,7 @@ static void dsp_pm_4(void) if (cur_inst & (1<<14)) { retour = dsp_calc_ea(ea_mode, addr_name); } else { - sprintf(addr_name,"0x%04x", ea_mode); + sprintf(addr_name,"$%04x", ea_mode); retour = 0; } @@ -2232,7 +2211,6 @@ static void dsp_pm_4(void) if (cur_inst & (1<<15)) { /* Write D */ - registers_changed[value]=1; if (retour) { sprintf(parallelmove_name, "#%s,%s", addr_name, registers_lmove[value]); } else { @@ -2250,7 +2228,7 @@ static void dsp_pm_4(void) if (cur_inst & (1<<14)) { retour = dsp_calc_ea(ea_mode, addr_name); } else { - sprintf(addr_name,"0x%04x", ea_mode); + sprintf(addr_name,"$%04x", ea_mode); retour = 0; } @@ -2260,7 +2238,6 @@ static void dsp_pm_4(void) if (cur_inst & (1<<15)) { /* Write D */ - registers_changed[value]=1; if (retour) { sprintf(parallelmove_name, "#%s,%s", addr_name, registers_name[value]); } else { @@ -2277,8 +2254,6 @@ static void dsp_pm_4(void) if (cur_inst & (1<<15)) { /* Write D */ - registers_changed[value]=1; - if (retour) { sprintf(parallelmove_name, "#%s,%s", addr_name, registers_name[value]); } else { @@ -2334,9 +2309,7 @@ static void dsp_pm_8(void) dsp_calc_ea(ea_mode2, addr2_name); if (cur_inst & (1<<15)) { - registers_changed[numreg1]=1; if (cur_inst & (1<<22)) { - registers_changed[numreg2]=1; sprintf(parallelmove_name, "x:%s,%s y:%s,%s", addr1_name, registers_name[numreg1], @@ -2353,7 +2326,6 @@ static void dsp_pm_8(void) } } else { if (cur_inst & (1<<22)) { - registers_changed[numreg2]=1; sprintf(parallelmove_name, "%s,x:%s y:%s,%s", registers_name[numreg1], addr1_name, @@ -2370,855 +2342,3 @@ static void dsp_pm_8(void) } } } - - -/********************************** - * Parallel moves ALU instructions - **********************************/ - -static void dsp_abs(void) -{ - Uint32 numreg; - - numreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: abs %s %s\n", - dsp_core->pc, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_adc(void) -{ - const char *srcname; - Uint32 numreg; - - if (cur_inst & (1<<4)) { - srcname="y"; - } else { - srcname="x"; - } - - numreg=DSP_REG_A+((cur_inst>>3) & 1); - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: adc %s,%s %s\n", - dsp_core->pc, - srcname, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_add(void) -{ - const char *srcname; - Uint32 srcreg, dstreg; - - srcreg = (cur_inst>>4) & BITMASK(3); - dstreg = (cur_inst>>3) & 1; - - switch(srcreg) { - case 1: - srcreg = dstreg ^ 1; - srcname = registers_name[DSP_REG_A+srcreg]; - break; - case 2: - srcname="x"; - break; - case 3: - srcname="y"; - break; - case 4: - srcname=registers_name[DSP_REG_X0]; - break; - case 5: - srcname=registers_name[DSP_REG_Y0]; - break; - case 6: - srcname=registers_name[DSP_REG_X1]; - break; - case 7: - srcname=registers_name[DSP_REG_Y1]; - break; - default: - srcname=""; - break; - } - - registers_changed[DSP_REG_A+dstreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: add %s,%s %s\n", - dsp_core->pc, - srcname, - registers_name[DSP_REG_A+dstreg], - parallelmove_name - ); -} - -static void dsp_addl(void) -{ - Uint32 numreg; - - numreg = (cur_inst>>3) & 1; - - registers_changed[DSP_REG_A+numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: addl %s,%s %s\n", - dsp_core->pc, - registers_name[DSP_REG_A+(numreg ^ 1)], - registers_name[DSP_REG_A+numreg], - parallelmove_name - ); -} - -static void dsp_addr(void) -{ - Uint32 numreg; - - numreg = (cur_inst>>3) & 1; - - registers_changed[DSP_REG_A+numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: addr %s,%s %s\n", - dsp_core->pc, - registers_name[DSP_REG_A+(numreg ^ 1)], - registers_name[DSP_REG_A+numreg], - parallelmove_name - ); -} - -static void dsp_and(void) -{ - Uint32 srcreg,dstreg; - - switch((cur_inst>>4) & BITMASK(2)) { - case 1: - srcreg=DSP_REG_Y0; - break; - case 2: - srcreg=DSP_REG_X1; - break; - case 3: - srcreg=DSP_REG_Y1; - break; - case 0: - default: - srcreg=DSP_REG_X0; - } - dstreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[dstreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: and %s,%s %s\n", - dsp_core->pc, - registers_name[srcreg], - registers_name[dstreg], - parallelmove_name - ); -} - -static void dsp_asl(void) -{ - Uint32 numreg; - - numreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: asl %s %s\n", - dsp_core->pc, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_asr(void) -{ - Uint32 numreg; - - numreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: asr %s %s\n", - dsp_core->pc, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_clr(void) -{ - Uint32 numreg; - - numreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: clr %s %s\n", - dsp_core->pc, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_cmp(void) -{ - Uint32 srcreg, dstreg; - - srcreg = (cur_inst>>4) & BITMASK(3); - dstreg = (cur_inst>>3) & 1; - - switch(srcreg) { - case 0: - srcreg = DSP_REG_A+(dstreg ^ 1); - break; - case 4: - srcreg = DSP_REG_X0; - break; - case 5: - srcreg = DSP_REG_Y0; - break; - case 6: - srcreg = DSP_REG_X1; - break; - case 7: - srcreg = DSP_REG_Y1; - break; - } - - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: cmp %s,%s %s\n", - dsp_core->pc, - registers_name[srcreg], - registers_name[DSP_REG_A+dstreg], - parallelmove_name - ); -} - -static void dsp_cmpm(void) -{ - Uint32 srcreg, dstreg; - - srcreg = (cur_inst>>4) & BITMASK(3); - dstreg = (cur_inst>>3) & 1; - - switch(srcreg) { - case 0: - srcreg = DSP_REG_A+(dstreg ^ 1); - break; - case 4: - srcreg = DSP_REG_X0; - break; - case 5: - srcreg = DSP_REG_Y0; - break; - case 6: - srcreg = DSP_REG_X1; - break; - case 7: - srcreg = DSP_REG_Y1; - break; - } - - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: cmpm %s,%s %s\n", - dsp_core->pc, - registers_name[srcreg], - registers_name[DSP_REG_A+dstreg], - parallelmove_name - ); -} - -static void dsp_eor(void) -{ - Uint32 srcreg, dstreg; - - switch((cur_inst>>4) & BITMASK(2)) { - case 1: - srcreg=DSP_REG_Y0; - break; - case 2: - srcreg=DSP_REG_X1; - break; - case 3: - srcreg=DSP_REG_Y1; - break; - case 0: - default: - srcreg=DSP_REG_X0; - } - dstreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[dstreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: eor %s,%s %s\n", - dsp_core->pc, - registers_name[srcreg], - registers_name[dstreg], - parallelmove_name - ); -} - -static void dsp_lsl(void) -{ - Uint32 numreg; - - numreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: lsl %s %s\n", - dsp_core->pc, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_lsr(void) -{ - Uint32 numreg; - - numreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: lsr %s %s\n", - dsp_core->pc, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_mac(void) -{ - const char *sign_name; - Uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg; - - if (cur_inst & (1<<2)) { - sign_name="-"; - } else { - sign_name=""; - } - - switch((cur_inst>>4) & BITMASK(3)) { - case 0: - src1reg = DSP_REG_X0; - src2reg = DSP_REG_X0; - break; - case 1: - src1reg = DSP_REG_Y0; - src2reg = DSP_REG_Y0; - break; - case 2: - src1reg = DSP_REG_X1; - src2reg = DSP_REG_X0; - break; - case 3: - src1reg = DSP_REG_Y1; - src2reg = DSP_REG_Y0; - break; - case 4: - src1reg = DSP_REG_X0; - src2reg = DSP_REG_Y1; - break; - case 5: - src1reg = DSP_REG_Y0; - src2reg = DSP_REG_X0; - break; - case 6: - src1reg = DSP_REG_X1; - src2reg = DSP_REG_Y0; - break; - case 7: - src1reg = DSP_REG_Y1; - src2reg = DSP_REG_X1; - break; - } - dstreg = (cur_inst>>3) & 1; - - registers_changed[DSP_REG_A+dstreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: mac %s%s,%s,%s %s\n", - dsp_core->pc, - sign_name, - registers_name[src1reg], - registers_name[src2reg], - registers_name[DSP_REG_A+dstreg], - parallelmove_name - ); -} - -static void dsp_macr(void) -{ - const char *sign_name; - Uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg; - - if (cur_inst & (1<<2)) { - sign_name="-"; - } else { - sign_name=""; - } - - switch((cur_inst>>4) & BITMASK(3)) { - case 0: - src1reg = DSP_REG_X0; - src2reg = DSP_REG_X0; - break; - case 1: - src1reg = DSP_REG_Y0; - src2reg = DSP_REG_Y0; - break; - case 2: - src1reg = DSP_REG_X1; - src2reg = DSP_REG_X0; - break; - case 3: - src1reg = DSP_REG_Y1; - src2reg = DSP_REG_Y0; - break; - case 4: - src1reg = DSP_REG_X0; - src2reg = DSP_REG_Y1; - break; - case 5: - src1reg = DSP_REG_Y0; - src2reg = DSP_REG_X0; - break; - case 6: - src1reg = DSP_REG_X1; - src2reg = DSP_REG_Y0; - break; - case 7: - src1reg = DSP_REG_Y1; - src2reg = DSP_REG_X1; - break; - } - dstreg = (cur_inst>>3) & 1; - - registers_changed[DSP_REG_A+dstreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: macr %s%s,%s,%s %s\n", - dsp_core->pc, - sign_name, - registers_name[src1reg], - registers_name[src2reg], - registers_name[DSP_REG_A+dstreg], - parallelmove_name - ); -} - -static void dsp_move(void) -{ - fprintf(stderr,"Dsp: 0x%04x: move %s\n",dsp_core->pc, parallelmove_name); -} - -static void dsp_move_nopm(void) -{ - dsp_pm(); - fprintf(stderr,"Dsp: 0x%04x: move %s\n",dsp_core->pc, parallelmove_name); -} - -static void dsp_mpy(void) -{ - const char *sign_name; - Uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg; - - if (cur_inst & (1<<2)) { - sign_name="-"; - } else { - sign_name=""; - } - - switch((cur_inst>>4) & BITMASK(3)) { - case 0: - src1reg = DSP_REG_X0; - src2reg = DSP_REG_X0; - break; - case 1: - src1reg = DSP_REG_Y0; - src2reg = DSP_REG_Y0; - break; - case 2: - src1reg = DSP_REG_X1; - src2reg = DSP_REG_X0; - break; - case 3: - src1reg = DSP_REG_Y1; - src2reg = DSP_REG_Y0; - break; - case 4: - src1reg = DSP_REG_X0; - src2reg = DSP_REG_Y1; - break; - case 5: - src1reg = DSP_REG_Y0; - src2reg = DSP_REG_X0; - break; - case 6: - src1reg = DSP_REG_X1; - src2reg = DSP_REG_Y0; - break; - case 7: - src1reg = DSP_REG_Y1; - src2reg = DSP_REG_X1; - break; - } - dstreg = (cur_inst>>3) & 1; - - registers_changed[DSP_REG_A+dstreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: mpy %s%s,%s,%s %s\n", - dsp_core->pc, - sign_name, - registers_name[src1reg], - registers_name[src2reg], - registers_name[DSP_REG_A+dstreg], - parallelmove_name - ); -} - -static void dsp_mpyr(void) -{ - const char *sign_name; - Uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg; - - if (cur_inst & (1<<2)) { - sign_name="-"; - } else { - sign_name=""; - } - - switch((cur_inst>>4) & BITMASK(3)) { - case 0: - src1reg = DSP_REG_X0; - src2reg = DSP_REG_X0; - break; - case 1: - src1reg = DSP_REG_Y0; - src2reg = DSP_REG_Y0; - break; - case 2: - src1reg = DSP_REG_X1; - src2reg = DSP_REG_X0; - break; - case 3: - src1reg = DSP_REG_Y1; - src2reg = DSP_REG_Y0; - break; - case 4: - src1reg = DSP_REG_X0; - src2reg = DSP_REG_Y1; - break; - case 5: - src1reg = DSP_REG_Y0; - src2reg = DSP_REG_X0; - break; - case 6: - src1reg = DSP_REG_X1; - src2reg = DSP_REG_Y0; - break; - case 7: - src1reg = DSP_REG_Y1; - src2reg = DSP_REG_X1; - break; - } - dstreg = (cur_inst>>3) & 1; - - registers_changed[DSP_REG_A+dstreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: mpyr %s%s,%s,%s %s\n", - dsp_core->pc, - sign_name, - registers_name[src1reg], - registers_name[src2reg], - registers_name[DSP_REG_A+dstreg], - parallelmove_name - ); -} - -static void dsp_neg(void) -{ - Uint32 numreg; - - numreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: neg %s %s\n", - dsp_core->pc, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_not(void) -{ - Uint32 numreg; - - numreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: not %s %s\n", - dsp_core->pc, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_or(void) -{ - Uint32 srcreg, dstreg; - - switch((cur_inst>>4) & BITMASK(2)) { - case 1: - srcreg=DSP_REG_Y0; - break; - case 2: - srcreg=DSP_REG_X1; - break; - case 3: - srcreg=DSP_REG_Y1; - break; - case 0: - default: - srcreg=DSP_REG_X0; - } - dstreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[dstreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: or %s,%s %s\n", - dsp_core->pc, - registers_name[srcreg], - registers_name[dstreg], - parallelmove_name - ); -} - -static void dsp_rnd(void) -{ - Uint32 numreg; - - numreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: rnd %s %s\n", - dsp_core->pc, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_rol(void) -{ - Uint32 numreg; - - numreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: rol %s %s\n", - dsp_core->pc, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_ror(void) -{ - Uint32 numreg; - - numreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: ror %s %s\n", - dsp_core->pc, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_sbc(void) -{ - const char *srcname; - Uint32 numreg; - - if (cur_inst & (1<<4)) { - srcname="y"; - } else { - srcname="x"; - } - - numreg = DSP_REG_A+((cur_inst>>3) & 1); - - registers_changed[numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: sbc %s,%s %s\n", - dsp_core->pc, - srcname, - registers_name[numreg], - parallelmove_name - ); -} - -static void dsp_sub(void) -{ - const char *srcname; - Uint32 srcreg, dstreg; - - srcreg = (cur_inst>>4) & BITMASK(3); - dstreg = (cur_inst>>3) & 1; - - switch(srcreg) { - case 1: - srcreg = dstreg ^ 1; - srcname = registers_name[DSP_REG_A+srcreg]; - break; - case 2: - srcname="x"; - break; - case 3: - srcname="y"; - break; - case 4: - srcname=registers_name[DSP_REG_X0]; - break; - case 5: - srcname=registers_name[DSP_REG_Y0]; - break; - case 6: - srcname=registers_name[DSP_REG_X1]; - break; - case 7: - srcname=registers_name[DSP_REG_Y1]; - break; - default: - srcname=""; - break; - } - - registers_changed[DSP_REG_A+dstreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: sub %s,%s %s\n", - dsp_core->pc, - srcname, - registers_name[DSP_REG_A+dstreg], - parallelmove_name - ); -} - -static void dsp_subl(void) -{ - Uint32 numreg; - - numreg = (cur_inst>>3) & 1; - - registers_changed[DSP_REG_A+numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: subl %s,%s %s\n", - dsp_core->pc, - registers_name[DSP_REG_A+(numreg ^ 1)], - registers_name[DSP_REG_A+numreg], - parallelmove_name - ); -} - -static void dsp_subr(void) -{ - Uint32 numreg; - - numreg = (cur_inst>>3) & 1; - - registers_changed[DSP_REG_A+numreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: subr %s,%s %s\n", - dsp_core->pc, - registers_name[DSP_REG_A+(numreg ^ 1)], - registers_name[DSP_REG_A+numreg], - parallelmove_name - ); -} - -static void dsp_tfr(void) -{ - Uint32 srcreg, dstreg; - - srcreg = (cur_inst>>4) & BITMASK(3); - dstreg = (cur_inst>>3) & 1; - - switch(srcreg) { - case 4: - srcreg = DSP_REG_X0; - break; - case 5: - srcreg = DSP_REG_Y0; - break; - case 6: - srcreg = DSP_REG_X1; - break; - case 7: - srcreg = DSP_REG_Y1; - break; - case 0: - default: - srcreg = DSP_REG_A+(dstreg ^ 1); - break; - } - - registers_changed[DSP_REG_A+dstreg]=1; - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: tfr %s,%s %s\n", - dsp_core->pc, - registers_name[srcreg], - registers_name[DSP_REG_A+dstreg], - parallelmove_name - ); -} - -static void dsp_tst(void) -{ - registers_changed[DSP_REG_SR]=1; - - fprintf(stderr,"Dsp: 0x%04x: tst %s %s\n", - dsp_core->pc, - registers_name[DSP_REG_A+((cur_inst>>3) & 1)], - parallelmove_name - ); -}