From ce701022af571e2bf292a66de04bd2f3c64534e3 Mon Sep 17 00:00:00 2001 From: AJR Date: Tue, 15 Nov 2016 23:00:17 -0500 Subject: [PATCH] Changed the sh2 and sh4 disassemblers to use 'std::ostream &' internally --- src/devices/cpu/sh2/sh2dasm.cpp | 388 ++++++++--------- src/devices/cpu/sh2/sh2drc.cpp | 18 +- src/devices/cpu/sh4/sh4dasm.cpp | 737 ++++++++++++++++++-------------- 3 files changed, 618 insertions(+), 525 deletions(-) diff --git a/src/devices/cpu/sh2/sh2dasm.cpp b/src/devices/cpu/sh2/sh2dasm.cpp index 30cb8fdb98d..a484c2a9cb4 100644 --- a/src/devices/cpu/sh2/sh2dasm.cpp +++ b/src/devices/cpu/sh2/sh2dasm.cpp @@ -15,596 +15,600 @@ static const char *const regname[16] = { "R8", "R9", "R10","R11","R12","R13","R14","SP" }; -static uint32_t op0000(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0000(std::ostream &stream, uint32_t pc, uint16_t opcode) { uint32_t flags = 0; switch(opcode & 0x3f) { case 0x02: - sprintf(buffer,"STC SR,%s", regname[Rn]); + util::stream_format(stream, "STC SR,%s", regname[Rn]); break; case 0x03: - sprintf(buffer,"BSRF %s", regname[Rn]); + util::stream_format(stream, "BSRF %s", regname[Rn]); break; case 0x08: - sprintf(buffer,"CLRT"); + stream << "CLRT"; break; case 0x09: - sprintf(buffer,"NOP"); + stream << "NOP"; break; case 0x0A: - sprintf(buffer,"STS MACH,%s", regname[Rn]); + util::stream_format(stream, "STS MACH,%s", regname[Rn]); break; case 0x0B: - sprintf(buffer,"RTS"); + stream << "RTS"; flags = DASMFLAG_STEP_OUT; break; case 0x12: - sprintf(buffer,"STS GBR,%s", regname[Rn]); + util::stream_format(stream, "STS GBR,%s", regname[Rn]); break; case 0x18: - sprintf(buffer,"SETT"); + stream << "SETT"; break; case 0x19: - sprintf(buffer,"DIV0U"); + stream << "DIV0U"; break; case 0x1A: - sprintf(buffer,"STS MACL,%s", regname[Rn]); + util::stream_format(stream, "STS MACL,%s", regname[Rn]); break; case 0x1B: - sprintf(buffer,"SLEEP"); + stream << "SLEEP"; break; case 0x22: - sprintf(buffer,"STC VBR,%s", regname[Rn]); + util::stream_format(stream, "STC VBR,%s", regname[Rn]); break; case 0x23: - sprintf(buffer,"BRAF %s", regname[Rn]); + util::stream_format(stream, "BRAF %s", regname[Rn]); break; case 0x28: - sprintf(buffer,"CLRMAC"); + stream << "CLRMAC"; break; case 0x29: - sprintf(buffer,"MOVT %s", regname[Rn]); + util::stream_format(stream, "MOVT %s", regname[Rn]); break; case 0x2A: - sprintf(buffer,"STS PR,%s", regname[Rn]); + util::stream_format(stream, "STS PR,%s", regname[Rn]); break; case 0x2B: - sprintf(buffer,"RTE"); + stream << "RTE"; flags = DASMFLAG_STEP_OUT; break; default: switch(opcode & 15) { case 0: - sprintf(buffer, "?????? $%04X", opcode); + util::stream_format(stream, "?????? $%04X", opcode); break; case 1: - sprintf(buffer, "?????? $%04X", opcode); + util::stream_format(stream, "?????? $%04X", opcode); break; case 2: - sprintf(buffer, "?????? $%04X", opcode); + util::stream_format(stream, "?????? $%04X", opcode); break; case 3: - sprintf(buffer, "?????? $%04X", opcode); + util::stream_format(stream, "?????? $%04X", opcode); break; case 4: - sprintf(buffer, "MOV.B %s,@(R0,%s)", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.B %s,@(R0,%s)", regname[Rm], regname[Rn]); break; case 5: - sprintf(buffer, "MOV.W %s,@(R0,%s)", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.W %s,@(R0,%s)", regname[Rm], regname[Rn]); break; case 6: - sprintf(buffer, "MOV.L %s,@(R0,%s)", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.L %s,@(R0,%s)", regname[Rm], regname[Rn]); break; case 7: - sprintf(buffer, "MUL.L %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MUL.L %s,%s", regname[Rm], regname[Rn]); break; case 8: - sprintf(buffer, "?????? $%04X", opcode); + util::stream_format(stream, "?????? $%04X", opcode); break; case 9: - sprintf(buffer, "?????? $%04X", opcode); + util::stream_format(stream, "?????? $%04X", opcode); break; case 10: - sprintf(buffer, "?????? $%04X", opcode); + util::stream_format(stream, "?????? $%04X", opcode); break; case 11: - sprintf(buffer, "?????? $%04X", opcode); + util::stream_format(stream, "?????? $%04X", opcode); break; case 12: - sprintf(buffer, "MOV.B @(R0,%s),%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.B @(R0,%s),%s", regname[Rm], regname[Rn]); break; case 13: - sprintf(buffer, "MOV.W @(R0,%s),%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.W @(R0,%s),%s", regname[Rm], regname[Rn]); break; case 14: - sprintf(buffer, "MOV.L @(R0,%s),%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.L @(R0,%s),%s", regname[Rm], regname[Rn]); break; case 15: - sprintf(buffer, "MAC.L @%s+,@%s+", regname[Rn], regname[Rm]); + util::stream_format(stream, "MAC.L @%s+,@%s+", regname[Rn], regname[Rm]); break; } } return flags; } -static uint32_t op0001(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0001(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "MOV.L %s,@($%02X,%s)", regname[Rm], (opcode & 15) * 4, regname[Rn]); + util::stream_format(stream, "MOV.L %s,@($%02X,%s)", regname[Rm], (opcode & 15) * 4, regname[Rn]); return 0; } -static uint32_t op0010(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0010(std::ostream &stream, uint32_t pc, uint16_t opcode) { switch (opcode & 15) { case 0: - sprintf(buffer, "MOV.B %s,@%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.B %s,@%s", regname[Rm], regname[Rn]); break; case 1: - sprintf(buffer, "MOV.W %s,@%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.W %s,@%s", regname[Rm], regname[Rn]); break; case 2: - sprintf(buffer, "MOV.L %s,@%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.L %s,@%s", regname[Rm], regname[Rn]); break; case 3: - sprintf(buffer, "?????? $%04X", opcode); + util::stream_format(stream, "?????? $%04X", opcode); break; case 4: - sprintf(buffer, "MOV.B %s,@-%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.B %s,@-%s", regname[Rm], regname[Rn]); break; case 5: - sprintf(buffer, "MOV.W %s,@-%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.W %s,@-%s", regname[Rm], regname[Rn]); break; case 6: - sprintf(buffer, "MOV.L %s,@-%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.L %s,@-%s", regname[Rm], regname[Rn]); break; case 7: - sprintf(buffer, "DIV0S %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "DIV0S %s,%s", regname[Rm], regname[Rn]); break; case 8: - sprintf(buffer, "TST %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "TST %s,%s", regname[Rm], regname[Rn]); break; case 9: - sprintf(buffer, "AND %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "AND %s,%s", regname[Rm], regname[Rn]); break; case 10: - sprintf(buffer, "XOR %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "XOR %s,%s", regname[Rm], regname[Rn]); break; case 11: - sprintf(buffer, "OR %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "OR %s,%s", regname[Rm], regname[Rn]); break; case 12: - sprintf(buffer, "CMP/STR %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "CMP/STR %s,%s", regname[Rm], regname[Rn]); break; case 13: - sprintf(buffer, "XTRCT %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "XTRCT %s,%s", regname[Rm], regname[Rn]); break; case 14: - sprintf(buffer, "MULU.W %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MULU.W %s,%s", regname[Rm], regname[Rn]); break; case 15: - sprintf(buffer, "MULS.W %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MULS.W %s,%s", regname[Rm], regname[Rn]); break; } return 0; } -static uint32_t op0011(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0011(std::ostream &stream, uint32_t pc, uint16_t opcode) { switch (opcode & 15) { case 0: - sprintf(buffer, "CMP/EQ %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "CMP/EQ %s,%s", regname[Rm], regname[Rn]); break; case 1: - sprintf(buffer, "?????? %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "?????? %s,%s", regname[Rm], regname[Rn]); break; case 2: - sprintf(buffer, "CMP/HS %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "CMP/HS %s,%s", regname[Rm], regname[Rn]); break; case 3: - sprintf(buffer, "CMP/GE %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "CMP/GE %s,%s", regname[Rm], regname[Rn]); break; case 4: - sprintf(buffer, "DIV1 %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "DIV1 %s,%s", regname[Rm], regname[Rn]); break; case 5: - sprintf(buffer, "DMULU.L %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "DMULU.L %s,%s", regname[Rm], regname[Rn]); break; case 6: - sprintf(buffer, "CMP/HI %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "CMP/HI %s,%s", regname[Rm], regname[Rn]); break; case 7: - sprintf(buffer, "CMP/GT %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "CMP/GT %s,%s", regname[Rm], regname[Rn]); break; case 8: - sprintf(buffer, "SUB %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "SUB %s,%s", regname[Rm], regname[Rn]); break; case 9: - sprintf(buffer, "?????? %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "?????? %s,%s", regname[Rm], regname[Rn]); break; case 10: - sprintf(buffer, "SUBC %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "SUBC %s,%s", regname[Rm], regname[Rn]); break; case 11: - sprintf(buffer, "SUBV %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "SUBV %s,%s", regname[Rm], regname[Rn]); break; case 12: - sprintf(buffer, "ADD %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "ADD %s,%s", regname[Rm], regname[Rn]); break; case 13: - sprintf(buffer, "DMULS.L %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "DMULS.L %s,%s", regname[Rm], regname[Rn]); break; case 14: - sprintf(buffer, "ADDC %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "ADDC %s,%s", regname[Rm], regname[Rn]); break; case 15: - sprintf(buffer, "ADDV %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "ADDV %s,%s", regname[Rm], regname[Rn]); break; } return 0; } -static uint32_t op0100(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0100(std::ostream &stream, uint32_t pc, uint16_t opcode) { uint32_t flags = 0; switch(opcode & 0x3F) { case 0x00: - sprintf(buffer, "SHLL %s", regname[Rn]); + util::stream_format(stream, "SHLL %s", regname[Rn]); break; case 0x01: - sprintf(buffer, "SHLR %s", regname[Rn]); + util::stream_format(stream, "SHLR %s", regname[Rn]); break; case 0x02: - sprintf(buffer, "STS.L MACH,@-%s", regname[Rn]); + util::stream_format(stream, "STS.L MACH,@-%s", regname[Rn]); break; case 0x03: - sprintf(buffer, "STC.L SR,@-%s", regname[Rn]); + util::stream_format(stream, "STC.L SR,@-%s", regname[Rn]); break; case 0x04: - sprintf(buffer, "ROTL %s", regname[Rn]); + util::stream_format(stream, "ROTL %s", regname[Rn]); break; case 0x05: - sprintf(buffer, "ROTR %s", regname[Rn]); + util::stream_format(stream, "ROTR %s", regname[Rn]); break; case 0x06: - sprintf(buffer, "LDS.L @%s+,MACH", regname[Rn]); + util::stream_format(stream, "LDS.L @%s+,MACH", regname[Rn]); break; case 0x07: - sprintf(buffer, "LDC.L @%s+,SR", regname[Rn]); + util::stream_format(stream, "LDC.L @%s+,SR", regname[Rn]); break; case 0x08: - sprintf(buffer, "SHLL2 %s", regname[Rn]); + util::stream_format(stream, "SHLL2 %s", regname[Rn]); break; case 0x09: - sprintf(buffer, "SHLR2 %s", regname[Rn]); + util::stream_format(stream, "SHLR2 %s", regname[Rn]); break; case 0x0a: - sprintf(buffer, "LDS %s,MACH", regname[Rn]); + util::stream_format(stream, "LDS %s,MACH", regname[Rn]); break; case 0x0b: - sprintf(buffer, "JSR %s", regname[Rn]); + util::stream_format(stream, "JSR %s", regname[Rn]); flags = DASMFLAG_STEP_OVER | DASMFLAG_STEP_OVER_EXTRA(1); break; case 0x0e: - sprintf(buffer, "LDC %s,SR", regname[Rn]); + util::stream_format(stream, "LDC %s,SR", regname[Rn]); break; case 0x10: - sprintf(buffer, "DT %s", regname[Rn]); + util::stream_format(stream, "DT %s", regname[Rn]); break; case 0x11: - sprintf(buffer, "CMP/PZ %s", regname[Rn]); + util::stream_format(stream, "CMP/PZ %s", regname[Rn]); break; case 0x12: - sprintf(buffer, "STS.L MACL,@-%s", regname[Rn]); + util::stream_format(stream, "STS.L MACL,@-%s", regname[Rn]); break; case 0x13: - sprintf(buffer, "STC.L GBR,@-%s", regname[Rn]); + util::stream_format(stream, "STC.L GBR,@-%s", regname[Rn]); break; case 0x15: - sprintf(buffer, "CMP/PL %s", regname[Rn]); + util::stream_format(stream, "CMP/PL %s", regname[Rn]); break; case 0x16: - sprintf(buffer, "LDS.L @%s+,MACL", regname[Rn]); + util::stream_format(stream, "LDS.L @%s+,MACL", regname[Rn]); break; case 0x17: - sprintf(buffer, "LDC.L @%s+,GBR", regname[Rn]); + util::stream_format(stream, "LDC.L @%s+,GBR", regname[Rn]); break; case 0x18: - sprintf(buffer, "SHLL8 %s", regname[Rn]); + util::stream_format(stream, "SHLL8 %s", regname[Rn]); break; case 0x19: - sprintf(buffer, "SHLR8 %s", regname[Rn]); + util::stream_format(stream, "SHLR8 %s", regname[Rn]); break; case 0x1a: - sprintf(buffer, "LDS %s,MACL", regname[Rn]); + util::stream_format(stream, "LDS %s,MACL", regname[Rn]); break; case 0x1b: - sprintf(buffer, "TAS %s", regname[Rn]); + util::stream_format(stream, "TAS %s", regname[Rn]); break; case 0x1e: - sprintf(buffer, "LDC %s,GBR", regname[Rn]); + util::stream_format(stream, "LDC %s,GBR", regname[Rn]); break; case 0x20: - sprintf(buffer, "SHAL %s", regname[Rn]); + util::stream_format(stream, "SHAL %s", regname[Rn]); break; case 0x21: - sprintf(buffer, "SHAR %s", regname[Rn]); + util::stream_format(stream, "SHAR %s", regname[Rn]); break; case 0x22: - sprintf(buffer, "STS.L PR,@-%s", regname[Rn]); + util::stream_format(stream, "STS.L PR,@-%s", regname[Rn]); break; case 0x23: - sprintf(buffer, "STC.L VBR,@-%s", regname[Rn]); + util::stream_format(stream, "STC.L VBR,@-%s", regname[Rn]); break; case 0x24: - sprintf(buffer, "ROTCL %s", regname[Rn]); + util::stream_format(stream, "ROTCL %s", regname[Rn]); break; case 0x25: - sprintf(buffer, "ROTCR %s", regname[Rn]); + util::stream_format(stream, "ROTCR %s", regname[Rn]); break; case 0x26: - sprintf(buffer, "LDS.L @%s+,PR", regname[Rn]); + util::stream_format(stream, "LDS.L @%s+,PR", regname[Rn]); break; case 0x27: - sprintf(buffer, "LDC.L @%s+,VBR", regname[Rn]); + util::stream_format(stream, "LDC.L @%s+,VBR", regname[Rn]); break; case 0x28: - sprintf(buffer, "SHLL16 %s", regname[Rn]); + util::stream_format(stream, "SHLL16 %s", regname[Rn]); break; case 0x29: - sprintf(buffer, "SHLR16 %s", regname[Rn]); + util::stream_format(stream, "SHLR16 %s", regname[Rn]); break; case 0x2a: - sprintf(buffer, "LDS %s,PR", regname[Rn]); + util::stream_format(stream, "LDS %s,PR", regname[Rn]); break; case 0x2b: - sprintf(buffer, "JMP %s", regname[Rn]); + util::stream_format(stream, "JMP %s", regname[Rn]); break; case 0x2e: - sprintf(buffer, "LDC %s,VBR", regname[Rn]); + util::stream_format(stream, "LDC %s,VBR", regname[Rn]); break; default: if ((opcode & 15) == 15) - sprintf(buffer, "MAC.W @%s+,@%s+", regname[Rm], regname[Rn]); + util::stream_format(stream, "MAC.W @%s+,@%s+", regname[Rm], regname[Rn]); else - sprintf(buffer, "?????? $%04X", opcode); + util::stream_format(stream, "?????? $%04X", opcode); } return flags; } -static uint32_t op0101(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0101(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "MOV.L @($%02X,%s),%s", (opcode & 15) * 4, regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.L @($%02X,%s),%s", (opcode & 15) * 4, regname[Rm], regname[Rn]); return 0; } -static uint32_t op0110(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0110(std::ostream &stream, uint32_t pc, uint16_t opcode) { switch(opcode & 0xF) { case 0x00: - sprintf(buffer, "MOV.B @%s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.B @%s,%s", regname[Rm], regname[Rn]); break; case 0x01: - sprintf(buffer, "MOV.W @%s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.W @%s,%s", regname[Rm], regname[Rn]); break; case 0x02: - sprintf(buffer, "MOV.L @%s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.L @%s,%s", regname[Rm], regname[Rn]); break; case 0x03: - sprintf(buffer, "MOV %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV %s,%s", regname[Rm], regname[Rn]); break; case 0x04: - sprintf(buffer, "MOV.B @%s+,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.B @%s+,%s", regname[Rm], regname[Rn]); break; case 0x05: - sprintf(buffer, "MOV.W @%s+,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.W @%s+,%s", regname[Rm], regname[Rn]); break; case 0x06: - sprintf(buffer, "MOV.L @%s+,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.L @%s+,%s", regname[Rm], regname[Rn]); break; case 0x07: - sprintf(buffer, "NOT %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "NOT %s,%s", regname[Rm], regname[Rn]); break; case 0x08: - sprintf(buffer, "SWAP.B %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "SWAP.B %s,%s", regname[Rm], regname[Rn]); break; case 0x09: - sprintf(buffer, "SWAP.W %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "SWAP.W %s,%s", regname[Rm], regname[Rn]); break; case 0x0a: - sprintf(buffer, "NEGC %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "NEGC %s,%s", regname[Rm], regname[Rn]); break; case 0x0b: - sprintf(buffer, "NEG %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "NEG %s,%s", regname[Rm], regname[Rn]); break; case 0x0c: - sprintf(buffer, "EXTU.B %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "EXTU.B %s,%s", regname[Rm], regname[Rn]); break; case 0x0d: - sprintf(buffer, "EXTU.W %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "EXTU.W %s,%s", regname[Rm], regname[Rn]); break; case 0x0e: - sprintf(buffer, "EXTS.B %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "EXTS.B %s,%s", regname[Rm], regname[Rn]); break; case 0x0f: - sprintf(buffer, "EXTS.W %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "EXTS.W %s,%s", regname[Rm], regname[Rn]); break; } return 0; } -static uint32_t op0111(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0111(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "ADD #$%02X,%s", opcode & 0xff, regname[Rn]); + util::stream_format(stream, "ADD #$%02X,%s", opcode & 0xff, regname[Rn]); return 0; } -static uint32_t op1000(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1000(std::ostream &stream, uint32_t pc, uint16_t opcode) { switch((opcode >> 8) & 15) { case 0: - sprintf(buffer, "MOV.B R0,@($%02X,%s)", (opcode & 15), regname[Rm]); + util::stream_format(stream, "MOV.B R0,@($%02X,%s)", (opcode & 15), regname[Rm]); break; case 1: - sprintf(buffer, "MOV.W R0,@($%02X,%s)", (opcode & 15) * 2, regname[Rm]); + util::stream_format(stream, "MOV.W R0,@($%02X,%s)", (opcode & 15) * 2, regname[Rm]); break; case 4: - sprintf(buffer, "MOV.B @($%02X,%s),R0", (opcode & 15), regname[Rm]); + util::stream_format(stream, "MOV.B @($%02X,%s),R0", (opcode & 15), regname[Rm]); break; case 5: - sprintf(buffer, "MOV.W @($%02X,%s),R0", (opcode & 15), regname[Rm]); + util::stream_format(stream, "MOV.W @($%02X,%s),R0", (opcode & 15), regname[Rm]); break; case 8: - sprintf(buffer, "CMP/EQ #$%02X,R0", (opcode & 0xff)); + util::stream_format(stream, "CMP/EQ #$%02X,R0", (opcode & 0xff)); break; case 9: - sprintf(buffer, "BT $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); + util::stream_format(stream, "BT $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); break; case 11: - sprintf(buffer, "BF $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); + util::stream_format(stream, "BF $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); break; case 13: - sprintf(buffer, "BTS $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); + util::stream_format(stream, "BTS $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); break; case 15: - sprintf(buffer, "BFS $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); + util::stream_format(stream, "BFS $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); break; default : - sprintf(buffer, "invalid $%04X", opcode); + util::stream_format(stream, "invalid $%04X", opcode); } return 0; } -static uint32_t op1001(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1001(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "MOV.W @($%04X,PC),%s [%08X]", (opcode & 0xff) * 2, regname[Rn], pc+((opcode & 0xff) * 2)+2); + util::stream_format(stream, "MOV.W @($%04X,PC),%s [%08X]", (opcode & 0xff) * 2, regname[Rn], pc+((opcode & 0xff) * 2)+2); return 0; } -static uint32_t op1010(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1010(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "BRA $%08X", SIGNX12(opcode & 0xfff) * 2 + pc + 2); + util::stream_format(stream, "BRA $%08X", SIGNX12(opcode & 0xfff) * 2 + pc + 2); return 0; } -static uint32_t op1011(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1011(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "BSR $%08X", SIGNX12(opcode & 0xfff) * 2 + pc + 2); + util::stream_format(stream, "BSR $%08X", SIGNX12(opcode & 0xfff) * 2 + pc + 2); return DASMFLAG_STEP_OVER | DASMFLAG_STEP_OVER_EXTRA(1); } -static uint32_t op1100(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1100(std::ostream &stream, uint32_t pc, uint16_t opcode) { uint32_t flags = 0; switch((opcode >> 8) & 15) { case 0: - sprintf(buffer, "MOV.B R0,@($%02X,GBR)", opcode & 0xff); + util::stream_format(stream, "MOV.B R0,@($%02X,GBR)", opcode & 0xff); break; case 1: - sprintf(buffer, "MOV.W R0,@($%04X,GBR)", (opcode & 0xff) * 2); + util::stream_format(stream, "MOV.W R0,@($%04X,GBR)", (opcode & 0xff) * 2); break; case 2: - sprintf(buffer, "MOV.L R0,@($%04X,GBR)", (opcode & 0xff) * 4); + util::stream_format(stream, "MOV.L R0,@($%04X,GBR)", (opcode & 0xff) * 4); break; case 3: - sprintf(buffer, "TRAPA #$%02X", opcode & 0xff); + util::stream_format(stream, "TRAPA #$%02X", opcode & 0xff); flags = DASMFLAG_STEP_OVER; break; case 4: - sprintf(buffer, "MOV.B @($%02X,GBR),R0", opcode & 0xff); + util::stream_format(stream, "MOV.B @($%02X,GBR),R0", opcode & 0xff); break; case 5: - sprintf(buffer, "MOV.W @($%04X,GBR),R0", (opcode & 0xff) * 2); + util::stream_format(stream, "MOV.W @($%04X,GBR),R0", (opcode & 0xff) * 2); break; case 6: - sprintf(buffer, "MOV.L @($%04X,GBR),R0", (opcode & 0xff) * 4); + util::stream_format(stream, "MOV.L @($%04X,GBR),R0", (opcode & 0xff) * 4); break; case 7: - sprintf(buffer, "MOVA @($%04X,PC),R0 [%08X]", (opcode & 0xff) * 4, ((pc + 2) & ~3) + (opcode & 0xff) * 4); + util::stream_format(stream, "MOVA @($%04X,PC),R0 [%08X]", (opcode & 0xff) * 4, ((pc + 2) & ~3) + (opcode & 0xff) * 4); break; case 8: - sprintf(buffer, "TST #$%02X,R0", opcode & 0xff); + util::stream_format(stream, "TST #$%02X,R0", opcode & 0xff); break; case 9: - sprintf(buffer, "AND #$%02X,R0", opcode & 0xff); + util::stream_format(stream, "AND #$%02X,R0", opcode & 0xff); break; case 10: - sprintf(buffer, "XOR #$%02X,R0", opcode & 0xff); + util::stream_format(stream, "XOR #$%02X,R0", opcode & 0xff); break; case 11: - sprintf(buffer, "OR #$%02X,R0", opcode & 0xff); + util::stream_format(stream, "OR #$%02X,R0", opcode & 0xff); break; case 12: - sprintf(buffer, "TST.B #$%02X,@(R0,GBR)", opcode & 0xff); + util::stream_format(stream, "TST.B #$%02X,@(R0,GBR)", opcode & 0xff); break; case 13: - sprintf(buffer, "AND.B #$%02X,@(R0,GBR)", opcode & 0xff); + util::stream_format(stream, "AND.B #$%02X,@(R0,GBR)", opcode & 0xff); break; case 14: - sprintf(buffer, "XOR.B #$%02X,@(R0,GBR)", opcode & 0xff); + util::stream_format(stream, "XOR.B #$%02X,@(R0,GBR)", opcode & 0xff); break; case 15: - sprintf(buffer, "OR.B #$%02X,@(R0,GBR)", opcode & 0xff); + util::stream_format(stream, "OR.B #$%02X,@(R0,GBR)", opcode & 0xff); break; } return flags; } -static uint32_t op1101(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1101(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "MOV.L @($%02X,PC),%s [%08X]", (opcode * 4) & 0xff, regname[Rn], ((pc + 2) & ~3) + (opcode & 0xff) * 4); + util::stream_format(stream, "MOV.L @($%02X,PC),%s [%08X]", (opcode * 4) & 0xff, regname[Rn], ((pc + 2) & ~3) + (opcode & 0xff) * 4); return 0; } -static uint32_t op1110(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1110(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "MOV #$%02X,%s", (opcode & 0xff), regname[Rn]); + util::stream_format(stream, "MOV #$%02X,%s", (opcode & 0xff), regname[Rn]); return 0; } -static uint32_t op1111(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1111(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "unknown $%04X", opcode); + util::stream_format(stream, "unknown $%04X", opcode); return 0; } -unsigned DasmSH2(char *buffer, unsigned pc, uint16_t opcode) +unsigned DasmSH2(std::ostream &stream, unsigned pc, uint16_t opcode) { uint32_t flags; pc += 2; - switch((opcode >> 12) & 15) + switch ((opcode >> 12) & 15) { - case 0: flags = op0000(buffer,pc,opcode); break; - case 1: flags = op0001(buffer,pc,opcode); break; - case 2: flags = op0010(buffer,pc,opcode); break; - case 3: flags = op0011(buffer,pc,opcode); break; - case 4: flags = op0100(buffer,pc,opcode); break; - case 5: flags = op0101(buffer,pc,opcode); break; - case 6: flags = op0110(buffer,pc,opcode); break; - case 7: flags = op0111(buffer,pc,opcode); break; - case 8: flags = op1000(buffer,pc,opcode); break; - case 9: flags = op1001(buffer,pc,opcode); break; - case 10: flags = op1010(buffer,pc,opcode); break; - case 11: flags = op1011(buffer,pc,opcode); break; - case 12: flags = op1100(buffer,pc,opcode); break; - case 13: flags = op1101(buffer,pc,opcode); break; - case 14: flags = op1110(buffer,pc,opcode); break; - default: flags = op1111(buffer,pc,opcode); break; + case 0: flags = op0000(stream, pc, opcode); break; + case 1: flags = op0001(stream, pc, opcode); break; + case 2: flags = op0010(stream, pc, opcode); break; + case 3: flags = op0011(stream, pc, opcode); break; + case 4: flags = op0100(stream, pc, opcode); break; + case 5: flags = op0101(stream, pc, opcode); break; + case 6: flags = op0110(stream, pc, opcode); break; + case 7: flags = op0111(stream, pc, opcode); break; + case 8: flags = op1000(stream, pc, opcode); break; + case 9: flags = op1001(stream, pc, opcode); break; + case 10: flags = op1010(stream, pc, opcode); break; + case 11: flags = op1011(stream, pc, opcode); break; + case 12: flags = op1100(stream, pc, opcode); break; + case 13: flags = op1101(stream, pc, opcode); break; + case 14: flags = op1110(stream, pc, opcode); break; + default: flags = op1111(stream, pc, opcode); break; } return 2 | flags | DASMFLAG_SUPPORTED; } -CPU_DISASSEMBLE( sh2 ) +CPU_DISASSEMBLE(sh2) { - return DasmSH2( buffer, pc, (oprom[0] << 8) | oprom[1] ); + std::ostringstream stream; + offs_t result = DasmSH2(stream, pc, (oprom[0] << 8) | oprom[1]); + std::string stream_str = stream.str(); + strcpy(buffer, stream_str.c_str()); + return result; } diff --git a/src/devices/cpu/sh2/sh2drc.cpp b/src/devices/cpu/sh2/sh2drc.cpp index 964e7cebb41..1003463b97a 100644 --- a/src/devices/cpu/sh2/sh2drc.cpp +++ b/src/devices/cpu/sh2/sh2drc.cpp @@ -12,7 +12,7 @@ #include "sh2.h" #include "sh2comn.h" -extern unsigned DasmSH2(char *buffer, unsigned pc, uint16_t opcode); +extern unsigned DasmSH2(std::ostream &stream, unsigned pc, uint16_t opcode); using namespace uml; @@ -1171,19 +1171,19 @@ void sh2_device::log_opcode_desc(drcuml_state *drcuml, const opcode_desc *descli /* output each descriptor */ for ( ; desclist != nullptr; desclist = desclist->next()) { - char buffer[100]; + std::ostringstream stream; /* disassemle the current instruction and output it to the log */ if (drcuml->logging() || drcuml->logging_native()) { if (desclist->flags & OPFLAG_VIRTUAL_NOOP) - strcpy(buffer, ""); + stream << ""; else - DasmSH2(buffer, desclist->pc, desclist->opptr.w[0]); + DasmSH2(stream, desclist->pc, desclist->opptr.w[0]); } else - strcpy(buffer, "???"); - drcuml->log_printf("%08X [%08X] t:%08X f:%s: %-30s", desclist->pc, desclist->physpc, desclist->targetpc, log_desc_flags_to_string(desclist->flags), buffer); + stream << "???"; + drcuml->log_printf("%08X [%08X] t:%08X f:%s: %-30s", desclist->pc, desclist->physpc, desclist->targetpc, log_desc_flags_to_string(desclist->flags), stream.str().c_str()); /* output register states */ log_register_list(drcuml, "use", desclist->regin, nullptr); @@ -1209,9 +1209,9 @@ void sh2_device::log_add_disasm_comment(drcuml_block *block, uint32_t pc, uint32 { if (m_drcuml->logging()) { - char buffer[100]; - DasmSH2(buffer, pc, op); - block->append_comment("%08X: %s", pc, buffer); // comment + std::ostringstream stream; + DasmSH2(stream, pc, op); + block->append_comment("%08X: %s", pc, stream.str().c_str()); } } diff --git a/src/devices/cpu/sh4/sh4dasm.cpp b/src/devices/cpu/sh4/sh4dasm.cpp index 93a0a91ab1e..2815dc720be 100644 --- a/src/devices/cpu/sh4/sh4dasm.cpp +++ b/src/devices/cpu/sh4/sh4dasm.cpp @@ -15,253 +15,279 @@ static const char *const regname[16] = { "R8", "R9", "R10","R11","R12","R13","R14","R15" }; -static uint32_t op0000(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0000(std::ostream &stream, uint32_t pc, uint16_t opcode) { uint32_t flags = 0; switch (opcode & 0xF) { case 0x0: case 0x1: - sprintf(buffer, "?????? $%04X", opcode); break; + util::stream_format(stream, "?????? $%04X", opcode); + break; case 0x2: if (opcode & 0x80) { - sprintf(buffer,"STC %s_BANK,%s", regname[(Rm) & 7],regname[Rn]); + util::stream_format(stream, "STC %s_BANK,%s", regname[(Rm) & 7], regname[Rn]); return flags; } switch (opcode & 0x70) { case 0x00: - sprintf(buffer,"STC SR,%s", regname[Rn]); break; + util::stream_format(stream, "STC SR,%s", regname[Rn]); + break; case 0x10: - sprintf(buffer,"STC GBR,%s", regname[Rn]); break; + util::stream_format(stream, "STC GBR,%s", regname[Rn]); + break; case 0x20: - sprintf(buffer,"STC VBR,%s", regname[Rn]); break; + util::stream_format(stream, "STC VBR,%s", regname[Rn]); + break; case 0x30: - sprintf(buffer,"STC SSR,%s", regname[Rn]); break; + util::stream_format(stream, "STC SSR,%s", regname[Rn]); + break; case 0x40: - sprintf(buffer,"STC SPC,%s", regname[Rn]); break; + util::stream_format(stream, "STC SPC,%s", regname[Rn]); + break; } break; case 0x3: switch (opcode & 0xF0) { case 0x00: - sprintf(buffer,"BSRF %s", regname[Rn]); break; + util::stream_format(stream, "BSRF %s", regname[Rn]); + break; case 0x20: - sprintf(buffer,"BRAF %s", regname[Rn]); break; + util::stream_format(stream, "BRAF %s", regname[Rn]); + break; case 0x80: - sprintf(buffer,"PREF @%s", regname[Rn]); break; + util::stream_format(stream, "PREF @%s", regname[Rn]); + break; case 0x90: - sprintf(buffer,"OCBI @%s", regname[Rn]); break; + util::stream_format(stream, "OCBI @%s", regname[Rn]); + break; case 0xA0: - sprintf(buffer,"OCBP @%s", regname[Rn]); break; + util::stream_format(stream, "OCBP @%s", regname[Rn]); + break; case 0xB0: - sprintf(buffer,"OCBWB @%s", regname[Rn]); break; + util::stream_format(stream, "OCBWB @%s", regname[Rn]); + break; case 0xC0: - sprintf(buffer,"MOVCA.L R0,@%s", regname[Rn]); break; + util::stream_format(stream, "MOVCA.L R0,@%s", regname[Rn]); + break; } break; case 0x4: - sprintf(buffer, "MOV.B %s,@(R0,%s)", regname[Rm], regname[Rn]); break; + util::stream_format(stream, "MOV.B %s,@(R0,%s)", regname[Rm], regname[Rn]); + break; case 0x5: - sprintf(buffer, "MOV.W %s,@(R0,%s)", regname[Rm], regname[Rn]); break; + util::stream_format(stream, "MOV.W %s,@(R0,%s)", regname[Rm], regname[Rn]); + break; case 0x6: - sprintf(buffer, "MOV.L %s,@(R0,%s)", regname[Rm], regname[Rn]); break; + util::stream_format(stream, "MOV.L %s,@(R0,%s)", regname[Rm], regname[Rn]); + break; case 0x7: - sprintf(buffer, "MUL.L %s,%s", regname[Rm], regname[Rn]); break; + util::stream_format(stream, "MUL.L %s,%s", regname[Rm], regname[Rn]); + break; case 0x8: switch (opcode & 0x70) { - case 0x00: - sprintf(buffer,"CLRT"); break; - case 0x10: - sprintf(buffer,"SETT"); break; - case 0x20: - sprintf(buffer,"CLRMAC"); break; - case 0x30: - sprintf(buffer,"LDTLB"); break; - case 0x40: - sprintf(buffer,"CLRS"); break; - case 0x50: - sprintf(buffer,"SETS"); break; + case 0x00: stream << "CLRT"; break; + case 0x10: stream << "SETT"; break; + case 0x20: stream << "CLRMAC"; break; + case 0x30: stream << "LDTLB"; break; + case 0x40: stream << "CLRS"; break; + case 0x50: stream << "SETS"; break; } break; case 0x9: switch (opcode & 0x30) { case 0x00: - sprintf(buffer,"NOP"); break; + stream << "NOP"; + break; case 0x10: - sprintf(buffer,"DIV0U"); break; + stream << "DIV0U"; + break; case 0x20: - sprintf(buffer,"MOVT %s", regname[Rn]); break; + util::stream_format(stream, "MOVT %s", regname[Rn]); + break; } break; case 0xA: switch (opcode & 0x70) { case 0x00: - sprintf(buffer,"STS MACH,%s", regname[Rn]); break; + util::stream_format(stream, "STS MACH,%s", regname[Rn]); + break; case 0x10: - sprintf(buffer,"STS MACL,%s", regname[Rn]); break; + util::stream_format(stream, "STS MACL,%s", regname[Rn]); + break; case 0x20: - sprintf(buffer,"STS PR,%s", regname[Rn]); break; + util::stream_format(stream, "STS PR,%s", regname[Rn]); + break; case 0x30: - sprintf(buffer,"STC SGR,%s", regname[Rn]); break; + util::stream_format(stream, "STC SGR,%s", regname[Rn]); + break; case 0x50: - sprintf(buffer,"STS FPUL,%s", regname[Rn]); break; + util::stream_format(stream, "STS FPUL,%s", regname[Rn]); + break; case 0x60: - sprintf(buffer,"STS FPSCR,%s", regname[Rn]); break; + util::stream_format(stream, "STS FPSCR,%s", regname[Rn]); + break; case 0x70: - sprintf(buffer,"STC DBR,%s", regname[Rn]); break; + util::stream_format(stream, "STC DBR,%s", regname[Rn]); + break; } break; case 0xB: switch (opcode & 0x30) { case 0x00: - sprintf(buffer,"RTS"); + stream << "RTS"; flags = DASMFLAG_STEP_OUT; break; case 0x10: - sprintf(buffer,"SLEEP"); break; + stream << "SLEEP"; + break; case 0x20: - sprintf(buffer,"RTE"); + stream << "RTE"; flags = DASMFLAG_STEP_OUT; break; } break; case 0xC: - sprintf(buffer, "MOV.B @(R0,%s),%s", regname[Rm], regname[Rn]); break; + util::stream_format(stream, "MOV.B @(R0,%s),%s", regname[Rm], regname[Rn]); + break; case 0xD: - sprintf(buffer, "MOV.W @(R0,%s),%s", regname[Rm], regname[Rn]); break; + util::stream_format(stream, "MOV.W @(R0,%s),%s", regname[Rm], regname[Rn]); + break; case 0xE: - sprintf(buffer, "MOV.L @(R0,%s),%s", regname[Rm], regname[Rn]); break; + util::stream_format(stream, "MOV.L @(R0,%s),%s", regname[Rm], regname[Rn]); + break; case 0xF: - sprintf(buffer, "MAC.L @%s+,@%s+", regname[Rn], regname[Rm]); break; + util::stream_format(stream, "MAC.L @%s+,@%s+", regname[Rn], regname[Rm]); + break; } return flags; } -static uint32_t op0001(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0001(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "MOV.L %s,@($%02X,%s)", regname[Rm], (opcode & 15) * 4, regname[Rn]); + util::stream_format(stream, "MOV.L %s,@($%02X,%s)", regname[Rm], (opcode & 15) * 4, regname[Rn]); return 0; } -static uint32_t op0010(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0010(std::ostream &stream, uint32_t pc, uint16_t opcode) { switch (opcode & 15) { case 0: - sprintf(buffer, "MOV.B %s,@%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.B %s,@%s", regname[Rm], regname[Rn]); break; case 1: - sprintf(buffer, "MOV.W %s,@%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.W %s,@%s", regname[Rm], regname[Rn]); break; case 2: - sprintf(buffer, "MOV.L %s,@%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.L %s,@%s", regname[Rm], regname[Rn]); break; case 3: - sprintf(buffer, "?????? $%04X", opcode); + util::stream_format(stream, "?????? $%04X", opcode); break; case 4: - sprintf(buffer, "MOV.B %s,@-%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.B %s,@-%s", regname[Rm], regname[Rn]); break; case 5: - sprintf(buffer, "MOV.W %s,@-%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.W %s,@-%s", regname[Rm], regname[Rn]); break; case 6: - sprintf(buffer, "MOV.L %s,@-%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.L %s,@-%s", regname[Rm], regname[Rn]); break; case 7: - sprintf(buffer, "DIV0S %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "DIV0S %s,%s", regname[Rm], regname[Rn]); break; case 8: - sprintf(buffer, "TST %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "TST %s,%s", regname[Rm], regname[Rn]); break; case 9: - sprintf(buffer, "AND %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "AND %s,%s", regname[Rm], regname[Rn]); break; case 10: - sprintf(buffer, "XOR %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "XOR %s,%s", regname[Rm], regname[Rn]); break; case 11: - sprintf(buffer, "OR %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "OR %s,%s", regname[Rm], regname[Rn]); break; case 12: - sprintf(buffer, "CMP/STR %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "CMP/STR %s,%s", regname[Rm], regname[Rn]); break; case 13: - sprintf(buffer, "XTRCT %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "XTRCT %s,%s", regname[Rm], regname[Rn]); break; case 14: - sprintf(buffer, "MULU.W %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MULU.W %s,%s", regname[Rm], regname[Rn]); break; case 15: - sprintf(buffer, "MULS.W %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MULS.W %s,%s", regname[Rm], regname[Rn]); break; } return 0; } -static uint32_t op0011(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0011(std::ostream &stream, uint32_t pc, uint16_t opcode) { switch (opcode & 15) { case 0: - sprintf(buffer, "CMP/EQ %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "CMP/EQ %s,%s", regname[Rm], regname[Rn]); break; case 1: - sprintf(buffer, "?????? %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "?????? %s,%s", regname[Rm], regname[Rn]); break; case 2: - sprintf(buffer, "CMP/HS %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "CMP/HS %s,%s", regname[Rm], regname[Rn]); break; case 3: - sprintf(buffer, "CMP/GE %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "CMP/GE %s,%s", regname[Rm], regname[Rn]); break; case 4: - sprintf(buffer, "DIV1 %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "DIV1 %s,%s", regname[Rm], regname[Rn]); break; case 5: - sprintf(buffer, "DMULU.L %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "DMULU.L %s,%s", regname[Rm], regname[Rn]); break; case 6: - sprintf(buffer, "CMP/HI %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "CMP/HI %s,%s", regname[Rm], regname[Rn]); break; case 7: - sprintf(buffer, "CMP/GT %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "CMP/GT %s,%s", regname[Rm], regname[Rn]); break; case 8: - sprintf(buffer, "SUB %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "SUB %s,%s", regname[Rm], regname[Rn]); break; case 9: - sprintf(buffer, "?????? %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "?????? %s,%s", regname[Rm], regname[Rn]); break; case 10: - sprintf(buffer, "SUBC %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "SUBC %s,%s", regname[Rm], regname[Rn]); break; case 11: - sprintf(buffer, "SUBV %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "SUBV %s,%s", regname[Rm], regname[Rn]); break; case 12: - sprintf(buffer, "ADD %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "ADD %s,%s", regname[Rm], regname[Rn]); break; case 13: - sprintf(buffer, "DMULS.L %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "DMULS.L %s,%s", regname[Rm], regname[Rn]); break; case 14: - sprintf(buffer, "ADDC %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "ADDC %s,%s", regname[Rm], regname[Rn]); break; case 15: - sprintf(buffer, "ADDV %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "ADDV %s,%s", regname[Rm], regname[Rn]); break; } return 0; } -static uint32_t op0100(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0100(std::ostream &stream, uint32_t pc, uint16_t opcode) { uint32_t flags = 0; switch (opcode & 0xF) @@ -270,555 +296,618 @@ static uint32_t op0100(char *buffer, uint32_t pc, uint16_t opcode) switch (opcode & 0x30) { case 0x00: - sprintf(buffer, "SHLL %s", regname[Rn]); break; + util::stream_format(stream, "SHLL %s", regname[Rn]); + break; case 0x10: - sprintf(buffer, "DT %s", regname[Rn]); break; + util::stream_format(stream, "DT %s", regname[Rn]); + break; case 0x20: - sprintf(buffer, "SHAL %s", regname[Rn]); break; + util::stream_format(stream, "SHAL %s", regname[Rn]); + break; } break; case 0x1: switch (opcode & 0x30) { case 0x00: - sprintf(buffer, "SHLR %s", regname[Rn]); break; + util::stream_format(stream, "SHLR %s", regname[Rn]); + break; case 0x10: - sprintf(buffer, "CMP/PZ %s", regname[Rn]); break; + util::stream_format(stream, "CMP/PZ %s", regname[Rn]); + break; case 0x20: - sprintf(buffer, "SHAR %s", regname[Rn]); break; + util::stream_format(stream, "SHAR %s", regname[Rn]); + break; } break; case 0x2: switch (opcode & 0xF0) { case 0x00: - sprintf(buffer, "STS.L MACH,@-%s", regname[Rn]); break; + util::stream_format(stream, "STS.L MACH,@-%s", regname[Rn]); + break; case 0x10: - sprintf(buffer, "STS.L MACL,@-%s", regname[Rn]); break; + util::stream_format(stream, "STS.L MACL,@-%s", regname[Rn]); + break; case 0x20: - sprintf(buffer, "STS.L PR,@-%s", regname[Rn]); break; + util::stream_format(stream, "STS.L PR,@-%s", regname[Rn]); + break; case 0x30: - sprintf(buffer, "STC.L SGR,@-%s", regname[Rn]); break; + util::stream_format(stream, "STC.L SGR,@-%s", regname[Rn]); + break; case 0x50: - sprintf(buffer, "STS.L FPUL,@-%s", regname[Rn]); break; + util::stream_format(stream, "STS.L FPUL,@-%s", regname[Rn]); + break; case 0x60: - sprintf(buffer, "STS.L FPSCR,@-%s", regname[Rn]); break; + util::stream_format(stream, "STS.L FPSCR,@-%s", regname[Rn]); + break; case 0xF0: - sprintf(buffer, "STC.L DBR,@-%s", regname[Rn]); break; + util::stream_format(stream, "STC.L DBR,@-%s", regname[Rn]); + break; } break; case 0x3: if (opcode & 0x80) { - sprintf(buffer, "STC.L %s_BANK,@-%s", regname[(Rm) & 7],regname[Rn]); + util::stream_format(stream, "STC.L %s_BANK,@-%s", regname[(Rm) & 7],regname[Rn]); return flags; } switch (opcode & 0x70) { case 0x00: - sprintf(buffer, "STC.L SR,@-%s", regname[Rn]); break; + util::stream_format(stream, "STC.L SR,@-%s", regname[Rn]); + break; case 0x10: - sprintf(buffer, "STC.L GBR,@-%s", regname[Rn]); break; + util::stream_format(stream, "STC.L GBR,@-%s", regname[Rn]); + break; case 0x20: - sprintf(buffer, "STC.L VBR,@-%s", regname[Rn]); break; + util::stream_format(stream, "STC.L VBR,@-%s", regname[Rn]); + break; case 0x30: - sprintf(buffer, "STC.L SSR,@-%s", regname[Rn]); break; + util::stream_format(stream, "STC.L SSR,@-%s", regname[Rn]); + break; case 0x40: - sprintf(buffer, "STC.L SPC,@-%s", regname[Rn]); break; + util::stream_format(stream, "STC.L SPC,@-%s", regname[Rn]); + break; } break; case 0x4: switch (opcode & 0x30) { case 0x00: - sprintf(buffer, "ROTL %s", regname[Rn]); break; + util::stream_format(stream, "ROTL %s", regname[Rn]); + break; case 0x20: - sprintf(buffer, "ROTCL %s", regname[Rn]); break; + util::stream_format(stream, "ROTCL %s", regname[Rn]); + break; } break; case 0x5: switch (opcode & 0x30) { case 0x00: - sprintf(buffer, "ROTR %s", regname[Rn]); break; + util::stream_format(stream, "ROTR %s", regname[Rn]); + break; case 0x10: - sprintf(buffer, "CMP/PL %s", regname[Rn]); break; + util::stream_format(stream, "CMP/PL %s", regname[Rn]); + break; case 0x20: - sprintf(buffer, "ROTCR %s", regname[Rn]); break; + util::stream_format(stream, "ROTCR %s", regname[Rn]); + break; } break; case 0x6: switch (opcode & 0xF0) { case 0x00: - sprintf(buffer, "LDS.L @%s+,MACH", regname[Rn]); break; + util::stream_format(stream, "LDS.L @%s+,MACH", regname[Rn]); + break; case 0x10: - sprintf(buffer, "LDS.L @%s+,MACL", regname[Rn]); break; + util::stream_format(stream, "LDS.L @%s+,MACL", regname[Rn]); + break; case 0x20: - sprintf(buffer, "LDS.L @%s+,PR", regname[Rn]); break; + util::stream_format(stream, "LDS.L @%s+,PR", regname[Rn]); + break; case 0x50: - sprintf(buffer, "LDS.L @%s+,FPUL", regname[Rn]); break; + util::stream_format(stream, "LDS.L @%s+,FPUL", regname[Rn]); + break; case 0x60: - sprintf(buffer, "LDS.L @%s+,FPSCR", regname[Rn]); break; + util::stream_format(stream, "LDS.L @%s+,FPSCR", regname[Rn]); + break; case 0xF0: - sprintf(buffer, "LDC.L @%s+,DBR", regname[Rn]); break; + util::stream_format(stream, "LDC.L @%s+,DBR", regname[Rn]); + break; } break; case 0x7: if (opcode & 0x80) { - sprintf(buffer, "LDC.L @%s+,%s_BANK", regname[Rn],regname[(Rm) & 7]); + util::stream_format(stream, "LDC.L @%s+,%s_BANK", regname[Rn],regname[(Rm) & 7]); return flags; } switch (opcode & 0x70) { case 0x00: - sprintf(buffer, "LDC.L @%s+,SR", regname[Rn]); break; + util::stream_format(stream, "LDC.L @%s+,SR", regname[Rn]); + break; case 0x10: - sprintf(buffer, "LDC.L @%s+,GBR", regname[Rn]); break; + util::stream_format(stream, "LDC.L @%s+,GBR", regname[Rn]); + break; case 0x20: - sprintf(buffer, "LDC.L @%s+,VBR", regname[Rn]); break; + util::stream_format(stream, "LDC.L @%s+,VBR", regname[Rn]); + break; case 0x30: - sprintf(buffer, "LDC.L @%s+,SSR", regname[Rn]); break; + util::stream_format(stream, "LDC.L @%s+,SSR", regname[Rn]); + break; case 0x40: - sprintf(buffer, "LDC.L @%s+,SPC", regname[Rn]); break; + util::stream_format(stream, "LDC.L @%s+,SPC", regname[Rn]); + break; } break; case 0x8: switch (opcode & 0x30) { case 0x00: - sprintf(buffer, "SHLL2 %s", regname[Rn]); break; + util::stream_format(stream, "SHLL2 %s", regname[Rn]); + break; case 0x10: - sprintf(buffer, "SHLL8 %s", regname[Rn]); break; + util::stream_format(stream, "SHLL8 %s", regname[Rn]); + break; case 0x20: - sprintf(buffer, "SHLL16 %s", regname[Rn]); break; + util::stream_format(stream, "SHLL16 %s", regname[Rn]); + break; } break; case 0x9: switch (opcode & 0x30) { case 0x00: - sprintf(buffer, "SHLR2 %s", regname[Rn]); break; + util::stream_format(stream, "SHLR2 %s", regname[Rn]); + break; case 0x10: - sprintf(buffer, "SHLR8 %s", regname[Rn]); break; + util::stream_format(stream, "SHLR8 %s", regname[Rn]); + break; case 0x20: - sprintf(buffer, "SHLR16 %s", regname[Rn]); break; + util::stream_format(stream, "SHLR16 %s", regname[Rn]); + break; } break; case 0xA: switch (opcode & 0xF0) { case 0x00: - sprintf(buffer, "LDS %s,MACH", regname[Rn]); break; + util::stream_format(stream, "LDS %s,MACH", regname[Rn]); + break; case 0x10: - sprintf(buffer, "LDS %s,MACL", regname[Rn]); break; + util::stream_format(stream, "LDS %s,MACL", regname[Rn]); + break; case 0x20: - sprintf(buffer, "LDS %s,PR", regname[Rn]); break; + util::stream_format(stream, "LDS %s,PR", regname[Rn]); + break; case 0x50: - sprintf(buffer, "LDS %s,FPUL", regname[Rn]); break; + util::stream_format(stream, "LDS %s,FPUL", regname[Rn]); + break; case 0x60: - sprintf(buffer, "LDS %s,FPSCR", regname[Rn]); break; + util::stream_format(stream, "LDS %s,FPSCR", regname[Rn]); + break; case 0xF0: - sprintf(buffer, "LDC %s,DBR", regname[Rn]); break; + util::stream_format(stream, "LDC %s,DBR", regname[Rn]); + break; } break; case 0xB: switch (opcode & 0x30) { case 0x00: - sprintf(buffer, "JSR %s", regname[Rn]); + util::stream_format(stream, "JSR %s", regname[Rn]); flags = DASMFLAG_STEP_OVER | DASMFLAG_STEP_OVER_EXTRA(1); break; case 0x10: - sprintf(buffer, "TAS %s", regname[Rn]); break; + util::stream_format(stream, "TAS %s", regname[Rn]); + break; case 0x20: - sprintf(buffer, "JMP %s", regname[Rn]); break; + util::stream_format(stream, "JMP %s", regname[Rn]); + break; } break; case 0xC: - sprintf(buffer, "SHAD %s,%s", regname[Rm], regname[Rn]); break; + util::stream_format(stream, "SHAD %s,%s", regname[Rm], regname[Rn]); + break; case 0xD: - sprintf(buffer, "SHLD %s,%s", regname[Rm], regname[Rn]); break; + util::stream_format(stream, "SHLD %s,%s", regname[Rm], regname[Rn]); + break; case 0xE: if (opcode & 0x80) { - sprintf(buffer, "LDC %s,%s_BANK", regname[Rn],regname[(Rm) & 7]); + util::stream_format(stream, "LDC %s,%s_BANK", regname[Rn],regname[(Rm) & 7]); return flags; } switch (opcode & 0x70) { case 0x00: - sprintf(buffer, "LDC %s,SR", regname[Rn]); break; + util::stream_format(stream, "LDC %s,SR", regname[Rn]); + break; case 0x10: - sprintf(buffer, "LDC %s,GBR", regname[Rn]); break; + util::stream_format(stream, "LDC %s,GBR", regname[Rn]); + break; case 0x20: - sprintf(buffer, "LDC %s,VBR", regname[Rn]); break; + util::stream_format(stream, "LDC %s,VBR", regname[Rn]); + break; case 0x30: - sprintf(buffer, "LDC %s,SSR", regname[Rn]); break; + util::stream_format(stream, "LDC %s,SSR", regname[Rn]); + break; case 0x40: - sprintf(buffer, "LDC %s,SPC", regname[Rn]); break; + util::stream_format(stream, "LDC %s,SPC", regname[Rn]); + break; } break; case 0xF: - sprintf(buffer, "MAC.W @%s+,@%s+", regname[Rm], regname[Rn]); break; + util::stream_format(stream, "MAC.W @%s+,@%s+", regname[Rm], regname[Rn]); + break; } return flags; } -static uint32_t op0101(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0101(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "MOV.L @($%02X,%s),%s", (opcode & 15) * 4, regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.L @($%02X,%s),%s", (opcode & 15) * 4, regname[Rm], regname[Rn]); return 0; } -static uint32_t op0110(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0110(std::ostream &stream, uint32_t pc, uint16_t opcode) { switch(opcode & 0xF) { case 0x00: - sprintf(buffer, "MOV.B @%s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.B @%s,%s", regname[Rm], regname[Rn]); break; case 0x01: - sprintf(buffer, "MOV.W @%s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.W @%s,%s", regname[Rm], regname[Rn]); break; case 0x02: - sprintf(buffer, "MOV.L @%s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.L @%s,%s", regname[Rm], regname[Rn]); break; case 0x03: - sprintf(buffer, "MOV %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV %s,%s", regname[Rm], regname[Rn]); break; case 0x04: - sprintf(buffer, "MOV.B @%s+,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.B @%s+,%s", regname[Rm], regname[Rn]); break; case 0x05: - sprintf(buffer, "MOV.W @%s+,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.W @%s+,%s", regname[Rm], regname[Rn]); break; case 0x06: - sprintf(buffer, "MOV.L @%s+,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "MOV.L @%s+,%s", regname[Rm], regname[Rn]); break; case 0x07: - sprintf(buffer, "NOT %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "NOT %s,%s", regname[Rm], regname[Rn]); break; case 0x08: - sprintf(buffer, "SWAP.B %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "SWAP.B %s,%s", regname[Rm], regname[Rn]); break; case 0x09: - sprintf(buffer, "SWAP.W %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "SWAP.W %s,%s", regname[Rm], regname[Rn]); break; case 0x0a: - sprintf(buffer, "NEGC %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "NEGC %s,%s", regname[Rm], regname[Rn]); break; case 0x0b: - sprintf(buffer, "NEG %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "NEG %s,%s", regname[Rm], regname[Rn]); break; case 0x0c: - sprintf(buffer, "EXTU.B %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "EXTU.B %s,%s", regname[Rm], regname[Rn]); break; case 0x0d: - sprintf(buffer, "EXTU.W %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "EXTU.W %s,%s", regname[Rm], regname[Rn]); break; case 0x0e: - sprintf(buffer, "EXTS.B %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "EXTS.B %s,%s", regname[Rm], regname[Rn]); break; case 0x0f: - sprintf(buffer, "EXTS.W %s,%s", regname[Rm], regname[Rn]); + util::stream_format(stream, "EXTS.W %s,%s", regname[Rm], regname[Rn]); break; } return 0; } -static uint32_t op0111(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op0111(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "ADD #$%02X,%s", opcode & 0xff, regname[Rn]); + util::stream_format(stream, "ADD #$%02X,%s", opcode & 0xff, regname[Rn]); return 0; } -static uint32_t op1000(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1000(std::ostream &stream, uint32_t pc, uint16_t opcode) { switch((opcode >> 8) & 15) { case 0: - sprintf(buffer, "MOV.B R0,@($%02X,%s)", (opcode & 15), regname[Rm]); + util::stream_format(stream, "MOV.B R0,@($%02X,%s)", (opcode & 15), regname[Rm]); break; case 1: - sprintf(buffer, "MOV.W R0,@($%02X,%s)", (opcode & 15) * 2, regname[Rm]); + util::stream_format(stream, "MOV.W R0,@($%02X,%s)", (opcode & 15) * 2, regname[Rm]); break; case 4: - sprintf(buffer, "MOV.B @($%02X,%s),R0", (opcode & 15), regname[Rm]); + util::stream_format(stream, "MOV.B @($%02X,%s),R0", (opcode & 15), regname[Rm]); break; case 5: - sprintf(buffer, "MOV.W @($%02X,%s),R0", (opcode & 15) * 2, regname[Rm]); + util::stream_format(stream, "MOV.W @($%02X,%s),R0", (opcode & 15) * 2, regname[Rm]); break; case 8: - sprintf(buffer, "CMP/EQ #$%02X,R0", (opcode & 0xff)); + util::stream_format(stream, "CMP/EQ #$%02X,R0", (opcode & 0xff)); break; case 9: - sprintf(buffer, "BT $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); + util::stream_format(stream, "BT $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); break; case 11: - sprintf(buffer, "BF $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); + util::stream_format(stream, "BF $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); break; case 13: - sprintf(buffer, "BTS $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); + util::stream_format(stream, "BTS $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); break; case 15: - sprintf(buffer, "BFS $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); + util::stream_format(stream, "BFS $%08X", pc + SIGNX8(opcode & 0xff) * 2 + 2); break; default : - sprintf(buffer, "invalid $%04X", opcode); + util::stream_format(stream, "invalid $%04X", opcode); } return 0; } -static uint32_t op1001(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1001(std::ostream &stream, uint32_t pc, uint16_t opcode) { uint32_t ea=(pc+((opcode & 0xff) * 2)+2); - sprintf(buffer, "MOV.W @($%04X,PC),%s [%08X]", (opcode & 0xff) * 2, regname[Rn], ea); + util::stream_format(stream, "MOV.W @($%04X,PC),%s [%08X]", (opcode & 0xff) * 2, regname[Rn], ea); return 0; } -static uint32_t op1010(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1010(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "BRA $%08X", SIGNX12(opcode & 0xfff) * 2 + pc + 2); + util::stream_format(stream, "BRA $%08X", SIGNX12(opcode & 0xfff) * 2 + pc + 2); return 0; } -static uint32_t op1011(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1011(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "BSR $%08X", SIGNX12(opcode & 0xfff) * 2 + pc + 2); + util::stream_format(stream, "BSR $%08X", SIGNX12(opcode & 0xfff) * 2 + pc + 2); return DASMFLAG_STEP_OVER | DASMFLAG_STEP_OVER_EXTRA(1); } -static uint32_t op1100(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1100(std::ostream &stream, uint32_t pc, uint16_t opcode) { uint32_t flags = 0; switch((opcode >> 8) & 15) { case 0: - sprintf(buffer, "MOV.B R0,@($%02X,GBR)", opcode & 0xff); + util::stream_format(stream, "MOV.B R0,@($%02X,GBR)", opcode & 0xff); break; case 1: - sprintf(buffer, "MOV.W R0,@($%04X,GBR)", (opcode & 0xff) * 2); + util::stream_format(stream, "MOV.W R0,@($%04X,GBR)", (opcode & 0xff) * 2); break; case 2: - sprintf(buffer, "MOV.L R0,@($%04X,GBR)", (opcode & 0xff) * 4); + util::stream_format(stream, "MOV.L R0,@($%04X,GBR)", (opcode & 0xff) * 4); break; case 3: - sprintf(buffer, "TRAPA #$%02X", opcode & 0xff); + util::stream_format(stream, "TRAPA #$%02X", opcode & 0xff); flags = DASMFLAG_STEP_OVER; break; case 4: - sprintf(buffer, "MOV.B @($%02X,GBR),R0", opcode & 0xff); + util::stream_format(stream, "MOV.B @($%02X,GBR),R0", opcode & 0xff); break; case 5: - sprintf(buffer, "MOV.W @($%04X,GBR),R0", (opcode & 0xff) * 2); + util::stream_format(stream, "MOV.W @($%04X,GBR),R0", (opcode & 0xff) * 2); break; case 6: - sprintf(buffer, "MOV.L @($%04X,GBR),R0", (opcode & 0xff) * 4); + util::stream_format(stream, "MOV.L @($%04X,GBR),R0", (opcode & 0xff) * 4); break; case 7: - sprintf(buffer, "MOVA @($%04X,PC),R0 [%08X]", (opcode & 0xff) * 4, ((pc + 2) & ~3) + (opcode & 0xff) * 4); + util::stream_format(stream, "MOVA @($%04X,PC),R0 [%08X]", (opcode & 0xff) * 4, ((pc + 2) & ~3) + (opcode & 0xff) * 4); break; case 8: - sprintf(buffer, "TST #$%02X,R0", opcode & 0xff); + util::stream_format(stream, "TST #$%02X,R0", opcode & 0xff); break; case 9: - sprintf(buffer, "AND #$%02X,R0", opcode & 0xff); + util::stream_format(stream, "AND #$%02X,R0", opcode & 0xff); break; case 10: - sprintf(buffer, "XOR #$%02X,R0", opcode & 0xff); + util::stream_format(stream, "XOR #$%02X,R0", opcode & 0xff); break; case 11: - sprintf(buffer, "OR #$%02X,R0", opcode & 0xff); + util::stream_format(stream, "OR #$%02X,R0", opcode & 0xff); break; case 12: - sprintf(buffer, "TST.B #$%02X,@(R0,GBR)", opcode & 0xff); + util::stream_format(stream, "TST.B #$%02X,@(R0,GBR)", opcode & 0xff); break; case 13: - sprintf(buffer, "AND.B #$%02X,@(R0,GBR)", opcode & 0xff); + util::stream_format(stream, "AND.B #$%02X,@(R0,GBR)", opcode & 0xff); break; case 14: - sprintf(buffer, "XOR.B #$%02X,@(R0,GBR)", opcode & 0xff); + util::stream_format(stream, "XOR.B #$%02X,@(R0,GBR)", opcode & 0xff); break; case 15: - sprintf(buffer, "OR.B #$%02X,@(R0,GBR)", opcode & 0xff); + util::stream_format(stream, "OR.B #$%02X,@(R0,GBR)", opcode & 0xff); break; } return flags; } -static uint32_t op1101(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1101(std::ostream &stream, uint32_t pc, uint16_t opcode) { uint32_t ea=((pc + 2) & ~3) + (opcode & 0xff) * 4; - sprintf(buffer, "MOV.L @($%04X,PC),%s [%08X]", (opcode & 0xff) * 4, regname[Rn], ea); + util::stream_format(stream, "MOV.L @($%04X,PC),%s [%08X]", (opcode & 0xff) * 4, regname[Rn], ea); return 0; } -static uint32_t op1110(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1110(std::ostream &stream, uint32_t pc, uint16_t opcode) { - sprintf(buffer, "MOV #$%02X,%s", (opcode & 0xff), regname[Rn]); + util::stream_format(stream, "MOV #$%02X,%s", (opcode & 0xff), regname[Rn]); return 0; } -static uint32_t op1111(char *buffer, uint32_t pc, uint16_t opcode) +static uint32_t op1111(std::ostream &stream, uint32_t pc, uint16_t opcode) { switch (opcode & 0xf) { - case 0: - sprintf(buffer, "FADD F%s, F%s", regname[Rm], regname[Rn]); + case 0: + util::stream_format(stream, "FADD F%s, F%s", regname[Rm], regname[Rn]); + break; + case 1: + util::stream_format(stream, "FSUB F%s, F%s", regname[Rm], regname[Rn]); + break; + case 2: + util::stream_format(stream, "FMUL F%s, F%s", regname[Rm], regname[Rn]); + break; + case 3: + util::stream_format(stream, "FDIV F%s, F%s", regname[Rm], regname[Rn]); + break; + case 4: + util::stream_format(stream, "FCMP/EQ F%s, F%s", regname[Rm], regname[Rn]); + break; + case 5: + util::stream_format(stream, "FCMP/GT F%s, F%s", regname[Rm], regname[Rn]); + break; + case 6: + util::stream_format(stream, "FMOV.S @(R0,%s),F%s", regname[Rm], regname[Rn]); + break; + case 7: + util::stream_format(stream, "FMOV.S F%s, @(R0,%s)", regname[Rm], regname[Rn]); + break; + case 8: + util::stream_format(stream, "FMOV.S @%s, F%s", regname[Rm], regname[Rn]); + break; + case 9: + util::stream_format(stream, "FMOV.S @%s+, F%s", regname[Rm], regname[Rn]); + break; + case 10: + util::stream_format(stream, "FMOV.S F%s, @%s", regname[Rm], regname[Rn]); + break; + case 11: + util::stream_format(stream, "FMOV.S F%s, @-%s", regname[Rm], regname[Rn]); + break; + case 12: + util::stream_format(stream, "FMOV.S F%s, F%s", regname[Rm], regname[Rn]); + break; + case 13: + switch (opcode & 0xF0) + { + case 0x00: + util::stream_format(stream, "FSTS FPUL, F%s", regname[Rn]); break; - case 1: - sprintf(buffer, "FSUB F%s, F%s", regname[Rm], regname[Rn]); + case 0x10: + util::stream_format(stream, "FLDS F%s, FPUL", regname[Rn]); break; - case 2: - sprintf(buffer, "FMUL F%s, F%s", regname[Rm], regname[Rn]); + case 0x20: + util::stream_format(stream, "FLOAT FPUL, F%s", regname[Rn]); break; - case 3: - sprintf(buffer, "FDIV F%s, F%s", regname[Rm], regname[Rn]); + case 0x30: + util::stream_format(stream, "FTRC F%s, FPUL", regname[Rn]); break; - case 4: - sprintf(buffer, "FCMP/EQ F%s, F%s", regname[Rm], regname[Rn]); + case 0x40: + util::stream_format(stream, "FNEG F%s", regname[Rn]); break; - case 5: - sprintf(buffer, "FCMP/GT F%s, F%s", regname[Rm], regname[Rn]); + case 0x50: + util::stream_format(stream, "FABS F%s", regname[Rn]); break; - case 6: - sprintf(buffer, "FMOV.S @(R0,%s),F%s", regname[Rm], regname[Rn]); + case 0x60: + util::stream_format(stream, "FSQRT F%s", regname[Rn]); break; - case 7: - sprintf(buffer, "FMOV.S F%s, @(R0,%s)", regname[Rm], regname[Rn]); + case 0x70: + util::stream_format(stream, "FSRRA F%s", regname[Rn]); break; - case 8: - sprintf(buffer, "FMOV.S @%s, F%s", regname[Rm], regname[Rn]); + case 0x80: + util::stream_format(stream, "FLDI0 F%s", regname[Rn]); break; - case 9: - sprintf(buffer, "FMOV.S @%s+, F%s", regname[Rm], regname[Rn]); + case 0x90: + util::stream_format(stream, "FLDI1 F%s", regname[Rn]); break; - case 10: - sprintf(buffer, "FMOV.S F%s, @%s", regname[Rm], regname[Rn]); + case 0xA0: + util::stream_format(stream, "FCNVSD FPUL, D%s", regname[Rn]); break; - case 11: - sprintf(buffer, "FMOV.S F%s, @-%s", regname[Rm], regname[Rn]); + case 0xB0: + util::stream_format(stream, "FCNVDS D%s, FPUL", regname[Rn]); break; - case 12: - sprintf(buffer, "FMOV.S F%s, F%s", regname[Rm], regname[Rn]); + case 0xE0: + util::stream_format(stream, "FIPR FV%d, FV%d", (Rn & 3) << 2, Rn & 12); break; - case 13: - switch (opcode & 0xF0) - { - case 0x00: - sprintf(buffer, "FSTS FPUL, F%s", regname[Rn]); - break; - case 0x10: - sprintf(buffer, "FLDS F%s, FPUL", regname[Rn]); - break; - case 0x20: - sprintf(buffer, "FLOAT FPUL, F%s", regname[Rn]); - break; - case 0x30: - sprintf(buffer, "FTRC F%s, FPUL", regname[Rn]); - break; - case 0x40: - sprintf(buffer, "FNEG F%s", regname[Rn]); - break; - case 0x50: - sprintf(buffer, "FABS F%s", regname[Rn]); - break; - case 0x60: - sprintf(buffer, "FSQRT F%s", regname[Rn]); - break; - case 0x70: - sprintf(buffer, "FSRRA F%s", regname[Rn]); - break; - case 0x80: - sprintf(buffer, "FLDI0 F%s", regname[Rn]); - break; - case 0x90: - sprintf(buffer, "FLDI1 F%s", regname[Rn]); - break; - case 0xA0: - sprintf(buffer, "FCNVSD FPUL, D%s", regname[Rn]); - break; - case 0xB0: - sprintf(buffer, "FCNVDS D%s, FPUL", regname[Rn]); - break; - case 0xE0: - sprintf(buffer, "FIPR FV%d, FV%d", (Rn & 3) << 2, Rn & 12); - break; - case 0xF0: - if (opcode & 0x100) { - if (opcode & 0x200) { - switch (opcode & 0xC00) - { - case 0x000: - sprintf(buffer, "FSCHG"); - break; - case 0x800: - sprintf(buffer, "FRCHG"); - break; - default: - sprintf(buffer, "Funknown $%04X", opcode); - break; - } - } else { - sprintf(buffer, "FTRV XMTRX, FV%d", Rn & 12); - } - } else { - sprintf(buffer, "FSCA FPUL, F%s", regname[Rn & 14]); + case 0xF0: + if (opcode & 0x100) { + if (opcode & 0x200) { + switch (opcode & 0xC00) + { + case 0x000: + stream << "FSCHG"; + break; + case 0x800: + stream << "FRCHG"; + break; + default: + util::stream_format(stream, "Funknown $%04X", opcode); + break; } - break; - default: - sprintf(buffer, "Funknown $%04X", opcode); - break; + } else { + util::stream_format(stream, "FTRV XMTRX, FV%d", Rn & 12); + } + } else { + util::stream_format(stream, "FSCA FPUL, F%s", regname[Rn & 14]); } break; - case 14: - sprintf(buffer, "FMAC FR0, F%s,F%s", regname[Rm], regname[Rn]); - break; default: - sprintf(buffer, "Funknown $%04X", opcode); + util::stream_format(stream, "Funknown $%04X", opcode); break; - + } + break; + case 14: + util::stream_format(stream, "FMAC FR0, F%s,F%s", regname[Rm], regname[Rn]); + break; + default: + util::stream_format(stream, "Funknown $%04X", opcode); + break; } return 0; } -unsigned DasmSH4(char *buffer, unsigned pc, uint16_t opcode) +unsigned DasmSH4(std::ostream &stream, unsigned pc, uint16_t opcode) { uint32_t flags; pc += 2; - switch((opcode >> 12) & 15) + switch ((opcode >> 12) & 15) { - case 0: flags = op0000(buffer,pc,opcode); break; - case 1: flags = op0001(buffer,pc,opcode); break; - case 2: flags = op0010(buffer,pc,opcode); break; - case 3: flags = op0011(buffer,pc,opcode); break; - case 4: flags = op0100(buffer,pc,opcode); break; - case 5: flags = op0101(buffer,pc,opcode); break; - case 6: flags = op0110(buffer,pc,opcode); break; - case 7: flags = op0111(buffer,pc,opcode); break; - case 8: flags = op1000(buffer,pc,opcode); break; - case 9: flags = op1001(buffer,pc,opcode); break; - case 10: flags = op1010(buffer,pc,opcode); break; - case 11: flags = op1011(buffer,pc,opcode); break; - case 12: flags = op1100(buffer,pc,opcode); break; - case 13: flags = op1101(buffer,pc,opcode); break; - case 14: flags = op1110(buffer,pc,opcode); break; - default: flags = op1111(buffer,pc,opcode); break; + case 0: flags = op0000(stream, pc, opcode); break; + case 1: flags = op0001(stream, pc, opcode); break; + case 2: flags = op0010(stream, pc, opcode); break; + case 3: flags = op0011(stream, pc, opcode); break; + case 4: flags = op0100(stream, pc, opcode); break; + case 5: flags = op0101(stream, pc, opcode); break; + case 6: flags = op0110(stream, pc, opcode); break; + case 7: flags = op0111(stream, pc, opcode); break; + case 8: flags = op1000(stream, pc, opcode); break; + case 9: flags = op1001(stream, pc, opcode); break; + case 10: flags = op1010(stream, pc, opcode); break; + case 11: flags = op1011(stream, pc, opcode); break; + case 12: flags = op1100(stream, pc, opcode); break; + case 13: flags = op1101(stream, pc, opcode); break; + case 14: flags = op1110(stream, pc, opcode); break; + default: flags = op1111(stream, pc, opcode); break; } return 2 | flags | DASMFLAG_SUPPORTED; } -CPU_DISASSEMBLE( sh4 ) +CPU_DISASSEMBLE(sh4) { - return DasmSH4( buffer, pc, (oprom[1] << 8) | oprom[0] ); + std::ostringstream stream; + offs_t result = DasmSH4(stream, pc, (oprom[1] << 8) | oprom[0]); + std::string stream_str = stream.str(); + strcpy(buffer, stream_str.c_str()); + return result; } -CPU_DISASSEMBLE( sh4be ) +CPU_DISASSEMBLE(sh4be) { - return DasmSH4( buffer, pc, (oprom[0] << 8) | oprom[1] ); + std::ostringstream stream; + offs_t result = DasmSH4(stream, pc, (oprom[0] << 8) | oprom[1]); + std::string stream_str = stream.str(); + strcpy(buffer, stream_str.c_str()); + return result; }