void activecpu_set_info_ptr(UINT32 state, void *data)
{
cpuinfo info;
VERIFY_ACTIVECPU(activecpu_set_info_ptr);
info.p = data;
(*cpu[activecpu].intf.set_info)(state, &info);
}
void activecpu_set_info_int(UINT32 state, INT64 data)
{
cpuinfo info;
VERIFY_ACTIVECPU(activecpu_set_info_int);
info.i = data;
(*cpu[activecpu].intf.set_info)(state, &info);
}
void activecpu_set_info_fct(UINT32 state, genf *data)
{
cpuinfo info;
VERIFY_ACTIVECPU(activecpu_set_info_fct);
info.f = data;
(*cpu[activecpu].intf.set_info)(state, &info);
}
unsigned activecpu_dasm_new(char *buffer, offs_t pc, UINT8 *oprom, UINT8 *opram, int bytes)
{
unsigned result;
VERIFY_ACTIVECPU(activecpu_dasm_new);
if (cpu[activecpu].intf.disassemble_new)
{
result = (*cpu[activecpu].intf.disassemble_new)(buffer, pc, oprom, opram, bytes);
}
else
{
/* if no disassembler present, dump vanilla bytes */
switch(activecpu_min_instruction_bytes())
{
case 1:
default:
sprintf(buffer, "$%02X", (unsigned) *((UINT8 *) oprom));
result = 1;
break;
case 2:
sprintf(buffer, "$%04X", (unsigned) *((UINT16 *) oprom));
result = 2;
break;
case 4:
sprintf(buffer, "$%08X", (unsigned) *((UINT32 *) oprom));
result = 4;
break;
}
}
return result;
}
const char *activecpu_get_info_string(UINT32 state)
{
union cpuinfo info;
VERIFY_ACTIVECPU(activecpu_get_info_string);
info.s = NULL;
(*cpu[activecpu].intf.get_info)(state, &info);
return info.s;
}
genf *activecpu_get_info_fct(UINT32 state)
{
cpuinfo info;
VERIFY_ACTIVECPU(activecpu_get_info_fct);
info.f = NULL;
(*cpu[activecpu].intf.get_info)(state, &info);
return info.f;
}
const char *activecpu_get_info_string(UINT32 state)
{
cpuinfo info;
VERIFY_ACTIVECPU(activecpu_get_info_string);
info.s = cpuintrf_temp_str();
(*cpu[activecpu].intf.get_info)(state, &info);
return info.s;
}
INT64 activecpu_get_info_int(UINT32 state)
{
cpuinfo info;
VERIFY_ACTIVECPU(activecpu_get_info_int);
info.i = 0;
(*cpu[activecpu].intf.get_info)(state, &info);
return info.i;
}
void *activecpu_get_info_ptr(UINT32 state)
{
cpuinfo info;
VERIFY_ACTIVECPU(activecpu_get_info_ptr);
info.p = NULL;
(*cpu[activecpu].intf.get_info)(state, &info);
return info.p;
}
void activecpu_set_input_line(int irqline, int state)
{
VERIFY_ACTIVECPU(activecpu_set_input_line);
if (state != INTERNAL_CLEAR_LINE && state != INTERNAL_ASSERT_LINE)
{
logerror("activecpu_set_input_line called when cpu_set_input_line should have been used!\n");
return;
}
activecpu_set_info_int(CPUINFO_INT_INPUT_STATE + irqline, state - INTERNAL_CLEAR_LINE);
}
offs_t activecpu_dasm(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram)
{
unsigned result;
VERIFY_ACTIVECPU(activecpu_dasm);
/* check for disassembler override */
if (cpu_dasm_override[activecpu])
{
result = (*cpu_dasm_override[activecpu])(buffer, pc, oprom, opram);
if (result != 0)
return result;
}
if (cpu[activecpu].intf.disassemble != NULL)
{
result = (*cpu[activecpu].intf.disassemble)(buffer, pc, oprom, opram);
}
else
{
/* if no disassembler present, dump vanilla bytes */
switch (activecpu_min_instruction_bytes())
{
case 1:
default:
sprintf(buffer, "$%02X", (unsigned) *((UINT8 *) oprom));
result = 1;
break;
case 2:
sprintf(buffer, "$%04X", (unsigned) *((UINT16 *) oprom));
result = 2;
break;
case 4:
sprintf(buffer, "$%08X", (unsigned) *((UINT32 *) oprom));
result = 4;
break;
}
}
/* make sure we get good results */
assert((result & DASMFLAG_LENGTHMASK) != 0);
#ifdef MAME_DEBUG
{
int shift = activecpu_addrbus_shift(ADDRESS_SPACE_PROGRAM);
int bytes = (shift < 0) ? ((result & DASMFLAG_LENGTHMASK) << -shift) : ((result & DASMFLAG_LENGTHMASK) >> shift);
assert(bytes >= activecpu_min_instruction_bytes());
assert(bytes <= activecpu_max_instruction_bytes());
(void) bytes; /* appease compiler */
}
#endif
return result;
}
offs_t activecpu_get_pc_byte(void)
{
offs_t base, pc;
int shift;
VERIFY_ACTIVECPU(0, activecpu_get_pc_byte);
shift = cpu[activecpu].intf.address_shift;
base = cpu[activecpu].intf.pgm_memory_base;
pc = (*cpu[activecpu].intf.get_reg)(REG_PC);
return base + ((shift < 0) ? (pc << -shift) : (pc >> shift));
}
offs_t activecpu_get_physical_pc_byte(void)
{
offs_t pc;
int shift;
VERIFY_ACTIVECPU(activecpu_get_physical_pc_byte);
shift = cpu[activecpu].intf.address_shift;
pc = activecpu_get_reg(REG_PC);
if (shift < 0)
pc <<= -shift;
else
pc >>= shift;
if (cpu[activecpu].intf.translate)
(*cpu[activecpu].intf.translate)(ADDRESS_SPACE_PROGRAM, &pc);
return pc;
}
const char *activecpu_dump_state(void)
{
static char buffer[1024+1];
unsigned addr_width = (activecpu_address_bits() + 3) / 4;
char *dst = buffer;
const char *src;
const INT8 *regs;
int width;
VERIFY_ACTIVECPU("", activecpu_dump_state);
dst += sprintf(dst, "CPU #%d [%s]\n", activecpu, activecpu_name());
width = 0;
regs = (INT8 *)activecpu_reg_layout();
while (*regs)
{
if (*regs == -1)
{
dst += sprintf(dst, "\n");
width = 0;
}
else
{
src = activecpu_dump_reg(*regs);
if (*src)
{
if (width + strlen(src) + 1 >= 80)
{
dst += sprintf(dst, "\n");
width = 0;
}
dst += sprintf(dst, "%s ", src);
width += strlen(src) + 1;
}
}
regs++;
}
dst += sprintf(dst, "\n%0*X: ", addr_width, activecpu_get_pc());
activecpu_dasm(dst, activecpu_get_pc());
strcat(dst, "\n\n");
return buffer;
}
int cpu_getiloops(void)
{
VERIFY_ACTIVECPU(0, cpu_getiloops);
return cpu[activecpu].iloops;
}
void activecpu_set_opbase(unsigned val)
{
VERIFY_ACTIVECPU(activecpu_set_opbase);
memory_set_opbase(val);
}
offs_t activecpu_dasm(char *buffer, offs_t pc)
{
VERIFY_ACTIVECPU(activecpu_dasm);
/* allow overrides */
if (cpu_dasm_override)
{
offs_t result = cpu_dasm_override(activecpu, buffer, pc);
if (result)
return result;
}
/* if there's no old-style assembler, do some work to make this call work with the new one */
if (!cpu[activecpu].intf.disassemble)
{
int dbwidth = activecpu_databus_width(ADDRESS_SPACE_PROGRAM);
int maxbytes = activecpu_max_instruction_bytes();
int endianness = activecpu_endianness();
UINT8 opbuf[64], argbuf[64];
int xorval = 0;
int numbytes;
/* determine the XOR to get the bytes in order */
switch (dbwidth)
{
case 8: xorval = 0; break;
case 16: xorval = (endianness == CPU_IS_LE) ? BYTE_XOR_LE(0) : BYTE_XOR_BE(0); break;
case 32: xorval = (endianness == CPU_IS_LE) ? BYTE4_XOR_LE(0) : BYTE4_XOR_BE(0); break;
case 64: xorval = (endianness == CPU_IS_LE) ? BYTE8_XOR_LE(0) : BYTE8_XOR_BE(0); break;
}
/* fetch the bytes up to the maximum */
memset(opbuf, 0xff, sizeof(opbuf));
memset(argbuf, 0xff, sizeof(argbuf));
for (numbytes = 0; numbytes < maxbytes; numbytes++)
{
offs_t physpc = pc + numbytes;
const UINT8 *ptr;
/* translate the address, set the opcode base, and apply the byte xor */
if (!cpu[activecpu].intf.translate || (*cpu[activecpu].intf.translate)(ADDRESS_SPACE_PROGRAM, &physpc))
{
memory_set_opbase(physpc);
physpc ^= xorval;
/* get pointer to data */
ptr = memory_get_op_ptr(cpu_getactivecpu(), physpc, 0);
if (ptr)
{
opbuf[numbytes] = *ptr;
ptr = memory_get_op_ptr(cpu_getactivecpu(), physpc, 1);
if (ptr)
argbuf[numbytes] = *ptr;
else
argbuf[numbytes] = opbuf[numbytes];
}
}
}
return activecpu_dasm_new(buffer, pc, opbuf, argbuf, maxbytes);
}
return (*cpu[activecpu].intf.disassemble)(buffer, pc);
}
void activecpu_reset_banking(void)
{
VERIFY_ACTIVECPU(activecpu_reset_banking);
memory_set_opbase(activecpu_get_physical_pc_byte());
}
int activecpu_get_icount(void)
{
VERIFY_ACTIVECPU(activecpu_get_icount);
return *cpu[activecpu].intf.icount;
}
void activecpu_adjust_icount(int delta)
{
VERIFY_ACTIVECPU(activecpu_adjust_icount);
*cpu[activecpu].intf.icount += delta;
}
unsigned activecpu_dasm(char *buffer, unsigned pc)
{
VERIFY_ACTIVECPU(1, activecpu_dasm);
return (*cpu[activecpu].intf.cpu_dasm)(buffer, pc);
}
const char *activecpu_dump_reg(int regnum)
{
VERIFY_ACTIVECPU("", activecpu_dump_reg);
return (*cpu[activecpu].intf.cpu_info)(NULL, CPU_INFO_REG + regnum);
}
const void *activecpu_get_cycle_table(int which)
{
VERIFY_ACTIVECPU(NULL, activecpu_get_cycle_table);
return (*cpu[activecpu].intf.get_cycle_table)(which);
}
unsigned activecpu_get_reg(int regnum)
{
VERIFY_ACTIVECPU(0, activecpu_get_reg);
return (*cpu[activecpu].intf.get_reg)(regnum);
}
unsigned activecpu_dasm(char *buffer, unsigned pc)
{
VERIFY_ACTIVECPU(1, activecpu_dasm);
return internal_dasm(activecpu, buffer, pc);
}
const char *activecpu_flags(void)
{
VERIFY_ACTIVECPU("", activecpu_flags);
return (*cpu[activecpu].intf.cpu_info)(NULL, CPU_INFO_FLAGS);
}
