mirror of
https://github.com/holub/mame
synced 2025-05-20 12:48:53 +03:00
More disentangling of the 68000 core. Removed old unused CPS2
encryption junk. Changed encryption interfaces to pass the CPU core object. Unwound several levels of macros for accessing memory. Still more to do.
This commit is contained in:
Aaron Giles
parent
1794cfa5a1
commit
f326c2c29e
@ -58,23 +58,13 @@ typedef struct _m68k_memory_interface m68k_memory_interface;
|
||||
struct _m68k_memory_interface
|
||||
{
|
||||
offs_t opcode_xor; // Address Calculation
|
||||
UINT16 (*readimm16)(offs_t); // Immediate read 16 bit
|
||||
UINT8 (*read8)(offs_t); // Normal read 8 bit
|
||||
UINT16 (*read16)(offs_t); // Normal read 16 bit
|
||||
UINT32 (*read32)(offs_t); // Normal read 32 bit
|
||||
void (*write8)(offs_t, UINT8); // Write 8 bit
|
||||
void (*write16)(offs_t, UINT16); // Write 16 bit
|
||||
void (*write32)(offs_t, UINT32); // Write 32 bit
|
||||
void (*changepc)(offs_t); // Change PC
|
||||
|
||||
// For Encrypted Stuff
|
||||
|
||||
UINT8 (*read8pc)(offs_t); // PC Relative read 8 bit
|
||||
UINT16 (*read16pc)(offs_t); // PC Relative read 16 bit
|
||||
UINT32 (*read32pc)(offs_t); // PC Relative read 32 bit
|
||||
|
||||
UINT16 (*read16d)(offs_t); // Direct read 16 bit
|
||||
UINT32 (*read32d)(offs_t); // Direct read 32 bit
|
||||
UINT16 (*readimm16)(const address_space *, offs_t); // Immediate read 16 bit
|
||||
UINT8 (*read8)(const address_space *, offs_t); // Normal read 8 bit
|
||||
UINT16 (*read16)(const address_space *, offs_t); // Normal read 16 bit
|
||||
UINT32 (*read32)(const address_space *, offs_t); // Normal read 32 bit
|
||||
void (*write8)(const address_space *, offs_t, UINT8); // Write 8 bit
|
||||
void (*write16)(const address_space *, offs_t, UINT16); // Write 16 bit
|
||||
void (*write32)(const address_space *, offs_t, UINT32); // Write 32 bit
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -90,63 +90,6 @@ typedef enum _m68k_register_t m68k_register_t;
|
||||
|
||||
|
||||
|
||||
/* ======================================================================== */
|
||||
/* ====================== FUNCTIONS CALLED BY THE CPU ===================== */
|
||||
/* ======================================================================== */
|
||||
|
||||
/* You will have to implement these functions */
|
||||
|
||||
/* read/write functions called by the CPU to access memory.
|
||||
* while values used are 32 bits, only the appropriate number
|
||||
* of bits are relevant (i.e. in write_memory_8, only the lower 8 bits
|
||||
* of value should be written to memory).
|
||||
*
|
||||
* NOTE: I have separated the immediate and PC-relative memory fetches
|
||||
* from the other memory fetches because some systems require
|
||||
* differentiation between PROGRAM and DATA fetches (usually
|
||||
* for security setups such as encryption).
|
||||
* This separation can either be achieved by setting
|
||||
* M68K_SEPARATE_READS in m68kconf.h and defining
|
||||
* the read functions, or by setting M68K_EMULATE_FC and
|
||||
* making a function code callback function.
|
||||
* Using the callback offers better emulation coverage
|
||||
* because you can also monitor whether the CPU is in SYSTEM or
|
||||
* USER mode, but it is also slower.
|
||||
*/
|
||||
|
||||
/* Read from anywhere */
|
||||
unsigned int m68k_read_memory_8(m68ki_cpu_core *m68k, unsigned int address);
|
||||
unsigned int m68k_read_memory_16(m68ki_cpu_core *m68k, unsigned int address);
|
||||
unsigned int m68k_read_memory_32(m68ki_cpu_core *m68k, unsigned int address);
|
||||
|
||||
/* Read data immediately following the PC */
|
||||
unsigned int m68k_read_immediate_16(m68ki_cpu_core *m68k, unsigned int address);
|
||||
unsigned int m68k_read_immediate_32(m68ki_cpu_core *m68k, unsigned int address);
|
||||
|
||||
/* Read data relative to the PC */
|
||||
unsigned int m68k_read_pcrelative_8(m68ki_cpu_core *m68k, unsigned int address);
|
||||
unsigned int m68k_read_pcrelative_16(m68ki_cpu_core *m68k, unsigned int address);
|
||||
unsigned int m68k_read_pcrelative_32(m68ki_cpu_core *m68k, unsigned int address);
|
||||
|
||||
/* Memory access for the disassembler */
|
||||
unsigned int m68k_read_disassembler_8 (unsigned int address);
|
||||
unsigned int m68k_read_disassembler_16 (unsigned int address);
|
||||
unsigned int m68k_read_disassembler_32 (unsigned int address);
|
||||
|
||||
/* Write to anywhere */
|
||||
void m68k_write_memory_8(m68ki_cpu_core *m68k, unsigned int address, unsigned int value);
|
||||
void m68k_write_memory_16(m68ki_cpu_core *m68k, unsigned int address, unsigned int value);
|
||||
void m68k_write_memory_32(m68ki_cpu_core *m68k, unsigned int address, unsigned int value);
|
||||
|
||||
/* Special call to simulate undocumented 68k behavior when move.l with a
|
||||
* predecrement destination mode is executed.
|
||||
* To simulate real 68k behavior, first write the high word to
|
||||
* [address+2], and then write the low word to [address].
|
||||
*/
|
||||
void m68k_write_memory_32_pd(m68ki_cpu_core *m68k, unsigned int address, unsigned int value);
|
||||
|
||||
|
||||
|
||||
/* ======================================================================== */
|
||||
/* ============================== CALLBACKS =============================== */
|
||||
/* ======================================================================== */
|
||||
|
||||
@ -3284,8 +3284,8 @@ M68KMAKE_OP(callm, 32, ., .)
|
||||
REG_PC += 2;
|
||||
(void)ea; /* just to avoid an 'unused variable' warning */
|
||||
M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
|
||||
m68ki_cpu_get_names[m68k->cpu_type], ADDRESS_68K(m68k, REG_PC - 2), m68k->ir,
|
||||
m68k_disassemble_quick(ADDRESS_68K(m68k, REG_PC - 2))));
|
||||
m68ki_cpu_get_names[m68k->cpu_type], REG_PC - 2, m68k->ir,
|
||||
m68k_disassemble_quick(REG_PC - 2)));
|
||||
return;
|
||||
}
|
||||
m68ki_exception_illegal(m68k);
|
||||
@ -4362,8 +4362,8 @@ M68KMAKE_OP(cpbcc, 32, ., .)
|
||||
if(CPU_TYPE_IS_EC020_PLUS(m68k->cpu_type))
|
||||
{
|
||||
M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
|
||||
m68ki_cpu_get_names[m68k->cpu_type], ADDRESS_68K(m68k, REG_PC - 2), m68k->ir,
|
||||
m68k_disassemble_quick(ADDRESS_68K(m68k, REG_PC - 2))));
|
||||
m68ki_cpu_get_names[m68k->cpu_type], REG_PC - 2, m68k->ir,
|
||||
m68k_disassemble_quick(REG_PC - 2)));
|
||||
return;
|
||||
}
|
||||
m68ki_exception_1111(m68k);
|
||||
@ -4375,8 +4375,8 @@ M68KMAKE_OP(cpdbcc, 32, ., .)
|
||||
if(CPU_TYPE_IS_EC020_PLUS(m68k->cpu_type))
|
||||
{
|
||||
M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
|
||||
m68ki_cpu_get_names[m68k->cpu_type], ADDRESS_68K(m68k, REG_PC - 2), m68k->ir,
|
||||
m68k_disassemble_quick(ADDRESS_68K(m68k, REG_PC - 2))));
|
||||
m68ki_cpu_get_names[m68k->cpu_type], REG_PC - 2, m68k->ir,
|
||||
m68k_disassemble_quick(REG_PC - 2)));
|
||||
return;
|
||||
}
|
||||
m68ki_exception_1111(m68k);
|
||||
@ -4388,8 +4388,8 @@ M68KMAKE_OP(cpgen, 32, ., .)
|
||||
if(CPU_TYPE_IS_EC020_PLUS(m68k->cpu_type))
|
||||
{
|
||||
M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
|
||||
m68ki_cpu_get_names[m68k->cpu_type], ADDRESS_68K(m68k, REG_PC - 2), m68k->ir,
|
||||
m68k_disassemble_quick(ADDRESS_68K(m68k, REG_PC - 2))));
|
||||
m68ki_cpu_get_names[m68k->cpu_type], REG_PC - 2, m68k->ir,
|
||||
m68k_disassemble_quick(REG_PC - 2)));
|
||||
return;
|
||||
}
|
||||
m68ki_exception_1111(m68k);
|
||||
@ -4401,8 +4401,8 @@ M68KMAKE_OP(cpscc, 32, ., .)
|
||||
if(CPU_TYPE_IS_EC020_PLUS(m68k->cpu_type))
|
||||
{
|
||||
M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
|
||||
m68ki_cpu_get_names[m68k->cpu_type], ADDRESS_68K(m68k, REG_PC - 2), m68k->ir,
|
||||
m68k_disassemble_quick(ADDRESS_68K(m68k, REG_PC - 2))));
|
||||
m68ki_cpu_get_names[m68k->cpu_type], REG_PC - 2, m68k->ir,
|
||||
m68k_disassemble_quick(REG_PC - 2)));
|
||||
return;
|
||||
}
|
||||
m68ki_exception_1111(m68k);
|
||||
@ -4414,8 +4414,8 @@ M68KMAKE_OP(cptrapcc, 32, ., .)
|
||||
if(CPU_TYPE_IS_EC020_PLUS(m68k->cpu_type))
|
||||
{
|
||||
M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
|
||||
m68ki_cpu_get_names[m68k->cpu_type], ADDRESS_68K(m68k, REG_PC - 2), m68k->ir,
|
||||
m68k_disassemble_quick(ADDRESS_68K(m68k, REG_PC - 2))));
|
||||
m68ki_cpu_get_names[m68k->cpu_type], REG_PC - 2, m68k->ir,
|
||||
m68k_disassemble_quick(REG_PC - 2)));
|
||||
return;
|
||||
}
|
||||
m68ki_exception_1111(m68k);
|
||||
@ -9326,8 +9326,8 @@ M68KMAKE_OP(rtm, 32, ., .)
|
||||
{
|
||||
m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
|
||||
M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
|
||||
m68ki_cpu_get_names[m68k->cpu_type], ADDRESS_68K(m68k, REG_PC - 2), m68k->ir,
|
||||
m68k_disassemble_quick(ADDRESS_68K(m68k, REG_PC - 2))));
|
||||
m68ki_cpu_get_names[m68k->cpu_type], REG_PC - 2, m68k->ir,
|
||||
m68k_disassemble_quick(REG_PC - 2)));
|
||||
return;
|
||||
}
|
||||
m68ki_exception_illegal(m68k);
|
||||
|
||||
@ -469,13 +469,6 @@ static int default_tas_instr_callback(void)
|
||||
return 1; // allow writeback
|
||||
}
|
||||
|
||||
/* Called when the program counter changed by a large value */
|
||||
static unsigned int default_pc_changed_callback_data;
|
||||
static void default_pc_changed_callback(unsigned int new_pc)
|
||||
{
|
||||
default_pc_changed_callback_data = new_pc;
|
||||
}
|
||||
|
||||
/* Called every time there's bus activity (read/write to/from memory */
|
||||
static unsigned int default_set_fc_callback_data;
|
||||
static void default_set_fc_callback(unsigned int new_fc)
|
||||
@ -483,11 +476,6 @@ static void default_set_fc_callback(unsigned int new_fc)
|
||||
default_set_fc_callback_data = new_fc;
|
||||
}
|
||||
|
||||
/* Called every instruction cycle prior to execution */
|
||||
static void default_instr_hook_callback(unsigned int pc)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
/* ======================================================================== */
|
||||
/* ================================= API ================================== */
|
||||
@ -636,21 +624,11 @@ void m68k_set_tas_instr_callback(m68ki_cpu_core *m68k, int (*callback)(void))
|
||||
m68k->tas_instr_callback = callback ? callback : default_tas_instr_callback;
|
||||
}
|
||||
|
||||
void m68k_set_pc_changed_callback(m68ki_cpu_core *m68k, void (*callback)(unsigned int new_pc))
|
||||
{
|
||||
m68k->pc_changed_callback = callback ? callback : default_pc_changed_callback;
|
||||
}
|
||||
|
||||
void m68k_set_fc_callback(m68ki_cpu_core *m68k, void (*callback)(unsigned int new_fc))
|
||||
{
|
||||
m68k->set_fc_callback = callback ? callback : default_set_fc_callback;
|
||||
}
|
||||
|
||||
void m68k_set_instr_hook_callback(m68ki_cpu_core *m68k, void (*callback)(unsigned int pc))
|
||||
{
|
||||
m68k->instr_hook_callback = callback ? callback : default_instr_hook_callback;
|
||||
}
|
||||
|
||||
#include <stdio.h>
|
||||
/* Set the CPU type. */
|
||||
void m68k_set_cpu_type(m68ki_cpu_core *m68k, unsigned int cpu_type)
|
||||
@ -659,7 +637,6 @@ void m68k_set_cpu_type(m68ki_cpu_core *m68k, unsigned int cpu_type)
|
||||
{
|
||||
case M68K_CPU_TYPE_68000:
|
||||
m68k->cpu_type = CPU_TYPE_000;
|
||||
m68k->address_mask = 0x00ffffff;
|
||||
m68k->sr_mask = 0xa71f; /* T1 -- S -- -- I2 I1 I0 -- -- -- X N Z V C */
|
||||
m68k->cyc_instruction = m68ki_cycles[0];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[0];
|
||||
@ -675,7 +652,6 @@ void m68k_set_cpu_type(m68ki_cpu_core *m68k, unsigned int cpu_type)
|
||||
return;
|
||||
case M68K_CPU_TYPE_68008:
|
||||
m68k->cpu_type = CPU_TYPE_008;
|
||||
m68k->address_mask = 0x003fffff;
|
||||
m68k->sr_mask = 0xa71f; /* T1 -- S -- -- I2 I1 I0 -- -- -- X N Z V C */
|
||||
m68k->cyc_instruction = m68ki_cycles[0];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[0];
|
||||
@ -691,7 +667,6 @@ void m68k_set_cpu_type(m68ki_cpu_core *m68k, unsigned int cpu_type)
|
||||
return;
|
||||
case M68K_CPU_TYPE_68010:
|
||||
m68k->cpu_type = CPU_TYPE_010;
|
||||
m68k->address_mask = 0x00ffffff;
|
||||
m68k->sr_mask = 0xa71f; /* T1 -- S -- -- I2 I1 I0 -- -- -- X N Z V C */
|
||||
m68k->cyc_instruction = m68ki_cycles[1];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[1];
|
||||
@ -707,7 +682,6 @@ void m68k_set_cpu_type(m68ki_cpu_core *m68k, unsigned int cpu_type)
|
||||
return;
|
||||
case M68K_CPU_TYPE_68EC020:
|
||||
m68k->cpu_type = CPU_TYPE_EC020;
|
||||
m68k->address_mask = 0x00ffffff;
|
||||
m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
|
||||
m68k->cyc_instruction = m68ki_cycles[2];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[2];
|
||||
@ -723,7 +697,6 @@ void m68k_set_cpu_type(m68ki_cpu_core *m68k, unsigned int cpu_type)
|
||||
return;
|
||||
case M68K_CPU_TYPE_68020:
|
||||
m68k->cpu_type = CPU_TYPE_020;
|
||||
m68k->address_mask = 0xffffffff;
|
||||
m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
|
||||
m68k->cyc_instruction = m68ki_cycles[2];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[2];
|
||||
@ -739,7 +712,6 @@ void m68k_set_cpu_type(m68ki_cpu_core *m68k, unsigned int cpu_type)
|
||||
return;
|
||||
case M68K_CPU_TYPE_68040: // TODO: these values are not correct
|
||||
m68k->cpu_type = CPU_TYPE_040;
|
||||
m68k->address_mask = 0xffffffff;
|
||||
m68k->sr_mask = 0xf71f; /* T1 T0 S M -- I2 I1 I0 -- -- -- X N Z V C */
|
||||
m68k->cyc_instruction = m68ki_cycles[2];
|
||||
m68k->cyc_exception = m68ki_exception_cycle_table[2];
|
||||
@ -887,9 +859,7 @@ void m68k_init(m68ki_cpu_core *m68k)
|
||||
m68k_set_cmpild_instr_callback(m68k, NULL);
|
||||
m68k_set_rte_instr_callback(m68k, NULL);
|
||||
m68k_set_tas_instr_callback(m68k, NULL);
|
||||
m68k_set_pc_changed_callback(m68k, NULL);
|
||||
m68k_set_fc_callback(m68k, NULL);
|
||||
m68k_set_instr_hook_callback(m68k, NULL);
|
||||
}
|
||||
|
||||
/* Pulse the RESET line on the CPU */
|
||||
|
||||
@ -38,8 +38,6 @@ typedef struct _m68ki_cpu_core m68ki_cpu_core;
|
||||
/* ======================================================================== */
|
||||
|
||||
/* Check for > 32bit sizes */
|
||||
#define M68K_INT_GT_32_BIT 0
|
||||
|
||||
#define MAKE_INT_8(A) (INT8)(A)
|
||||
#define MAKE_INT_16(A) (INT16)(A)
|
||||
#define MAKE_INT_32(A) (INT32)(A)
|
||||
@ -159,7 +157,7 @@ typedef struct _m68ki_cpu_core m68ki_cpu_core;
|
||||
#define MASK_OUT_BELOW_16(A) ((A) & ~0xffff)
|
||||
|
||||
/* No need to mask if we are 32 bit */
|
||||
#if M68K_INT_GT_32_BIT || M68K_USE_64_BIT
|
||||
#if M68K_USE_64_BIT
|
||||
#define MASK_OUT_ABOVE_32(A) ((A) & 0xffffffff)
|
||||
#define MASK_OUT_BELOW_32(A) ((A) & ~0xffffffff)
|
||||
#else
|
||||
@ -167,26 +165,15 @@ typedef struct _m68ki_cpu_core m68ki_cpu_core;
|
||||
#define MASK_OUT_BELOW_32(A) 0
|
||||
#endif /* M68K_INT_GT_32_BIT || M68K_USE_64_BIT */
|
||||
|
||||
/* Simulate address lines of 68k family */
|
||||
#define ADDRESS_68K(M, A) ((A) & (M)->address_mask)
|
||||
|
||||
|
||||
/* Shift & Rotate Macros. */
|
||||
#define LSL(A, C) ((A) << (C))
|
||||
#define LSR(A, C) ((A) >> (C))
|
||||
|
||||
/* Some > 32-bit optimizations */
|
||||
#if M68K_INT_GT_32_BIT
|
||||
/* Shift left and right */
|
||||
#define LSR_32(A, C) ((A) >> (C))
|
||||
#define LSL_32(A, C) ((A) << (C))
|
||||
#else
|
||||
/* We have to do this because the morons at ANSI decided that shifts
|
||||
* by >= data size are undefined.
|
||||
*/
|
||||
#define LSR_32(A, C) ((C) < 32 ? (A) >> (C) : 0)
|
||||
#define LSL_32(A, C) ((C) < 32 ? (A) << (C) : 0)
|
||||
#endif /* M68K_INT_GT_32_BIT */
|
||||
/* We have to do this because the morons at ANSI decided that shifts
|
||||
* by >= data size are undefined.
|
||||
*/
|
||||
#define LSR_32(A, C) ((C) < 32 ? (A) >> (C) : 0)
|
||||
#define LSL_32(A, C) ((C) < 32 ? (A) << (C) : 0)
|
||||
|
||||
#if M68K_USE_64_BIT
|
||||
#define LSL_32_64(A, C) ((A) << (C))
|
||||
@ -283,16 +270,6 @@ typedef struct _m68ki_cpu_core m68ki_cpu_core;
|
||||
#endif
|
||||
|
||||
|
||||
#if !M68K_SEPARATE_READS
|
||||
#define m68k_read_immediate_16(M, A) m68ki_read_program_16(M, A)
|
||||
#define m68k_read_immediate_32(M, A) m68ki_read_program_32(M, A)
|
||||
|
||||
#define m68k_read_pcrelative_8(M, A) m68ki_read_program_8(M, A)
|
||||
#define m68k_read_pcrelative_16(M, A) m68ki_read_program_16(M, A)
|
||||
#define m68k_read_pcrelative_32(M, A) m68ki_read_program_32(M, A)
|
||||
#endif /* M68K_SEPARATE_READS */
|
||||
|
||||
|
||||
/* Enable or disable function code emulation */
|
||||
#if M68K_EMULATE_FC
|
||||
#if M68K_EMULATE_FC == OPT_SPECIFY_HANDLER
|
||||
@ -447,13 +424,8 @@ typedef struct _m68ki_cpu_core m68ki_cpu_core;
|
||||
#define CFLAG_8(A) (A)
|
||||
#define CFLAG_16(A) ((A)>>8)
|
||||
|
||||
#if M68K_INT_GT_32_BIT
|
||||
#define CFLAG_ADD_32(S, D, R) ((R)>>24)
|
||||
#define CFLAG_SUB_32(S, D, R) ((R)>>24)
|
||||
#else
|
||||
#define CFLAG_ADD_32(S, D, R) (((S & D) | (~R & (S | D)))>>23)
|
||||
#define CFLAG_SUB_32(S, D, R) (((S & R) | (~D & (S | R)))>>23)
|
||||
#endif /* M68K_INT_GT_32_BIT */
|
||||
#define CFLAG_ADD_32(S, D, R) (((S & D) | (~R & (S | D)))>>23)
|
||||
#define CFLAG_SUB_32(S, D, R) (((S & R) | (~D & (S | R)))>>23)
|
||||
|
||||
#define VFLAG_ADD_8(S, D, R) ((S^R) & (D^R))
|
||||
#define VFLAG_ADD_16(S, D, R) (((S^R) & (D^R))>>8)
|
||||
@ -638,7 +610,6 @@ struct _m68ki_cpu_core
|
||||
UINT32 stopped; /* Stopped state */
|
||||
UINT32 pref_addr; /* Last prefetch address */
|
||||
UINT32 pref_data; /* Data in the prefetch queue */
|
||||
UINT32 address_mask; /* Available address pins */
|
||||
UINT32 sr_mask; /* Implemented status register bits */
|
||||
UINT32 instr_mode; /* Stores whether we are in instruction mode or group 0/1 exception mode */
|
||||
UINT32 run_mode; /* Stores whether we are processing a reset, bus error, address error, or something else */
|
||||
@ -679,10 +650,13 @@ struct _m68ki_cpu_core
|
||||
void (*cmpild_instr_callback)(unsigned int, int); /* Called when a CMPI.L #v, Dn instruction is encountered */
|
||||
void (*rte_instr_callback)(void); /* Called when a RTE instruction is encountered */
|
||||
int (*tas_instr_callback)(void); /* Called when a TAS instruction is encountered, allows / disallows writeback */
|
||||
void (*pc_changed_callback)(unsigned int new_pc); /* Called when the PC changes by a large amount */
|
||||
void (*set_fc_callback)(unsigned int new_fc); /* Called when the CPU function code changes */
|
||||
void (*instr_hook_callback)(unsigned int pc); /* Called every instruction cycle prior to execution */
|
||||
|
||||
const device_config *device;
|
||||
const address_space *program;
|
||||
m68k_memory_interface memory;
|
||||
offs_t encrypted_start;
|
||||
offs_t encrypted_end;
|
||||
};
|
||||
|
||||
|
||||
@ -815,6 +789,48 @@ char* m68ki_disassemble_quick(unsigned int pc, unsigned int cpu_type);
|
||||
/* ======================================================================== */
|
||||
|
||||
|
||||
INLINE unsigned int m68k_read_immediate_32(m68ki_cpu_core *m68k, unsigned int address)
|
||||
{
|
||||
return ((*m68k->memory.readimm16)(m68k->program, address) << 16) | (*m68k->memory.readimm16)(m68k->program, address + 2);
|
||||
}
|
||||
|
||||
INLINE unsigned int m68k_read_pcrelative_8(m68ki_cpu_core *m68k, unsigned int address)
|
||||
{
|
||||
if (address >= m68k->encrypted_start && address < m68k->encrypted_end)
|
||||
return (((*m68k->memory.readimm16)(m68k->program, address&~1)>>(8*(1-(address & 1))))&0xff);
|
||||
else
|
||||
return (*m68k->memory.read8)(m68k->program, address);
|
||||
}
|
||||
|
||||
INLINE unsigned int m68k_read_pcrelative_16(m68ki_cpu_core *m68k, unsigned int address)
|
||||
{
|
||||
if (address >= m68k->encrypted_start && address < m68k->encrypted_end)
|
||||
return (*m68k->memory.readimm16)(m68k->program, address);
|
||||
else
|
||||
return (*m68k->memory.read16)(m68k->program, address);
|
||||
}
|
||||
|
||||
INLINE unsigned int m68k_read_pcrelative_32(m68ki_cpu_core *m68k, unsigned int address)
|
||||
{
|
||||
if (address >= m68k->encrypted_start && address < m68k->encrypted_end)
|
||||
return m68k_read_immediate_32(m68k, address);
|
||||
else
|
||||
return (*m68k->memory.read32)(m68k->program, address);
|
||||
}
|
||||
|
||||
|
||||
/* Special call to simulate undocumented 68k behavior when move.l with a
|
||||
* predecrement destination mode is executed.
|
||||
* A real 68k first writes the high word to [address+2], and then writes the
|
||||
* low word to [address].
|
||||
*/
|
||||
INLINE void m68kx_write_memory_32_pd(m68ki_cpu_core *m68k, unsigned int address, unsigned int value)
|
||||
{
|
||||
(m68k->memory.write16)(m68k->program, address+2, value>>16);
|
||||
(m68k->memory.write16)(m68k->program, address, value&0xffff);
|
||||
}
|
||||
|
||||
|
||||
/* ---------------------------- Read Immediate ---------------------------- */
|
||||
|
||||
/* Handles all immediate reads, does address error check, function code setting,
|
||||
@ -830,12 +846,12 @@ INLINE UINT32 m68ki_read_imm_16(m68ki_cpu_core *m68k)
|
||||
if(REG_PC != m68k->pref_addr)
|
||||
{
|
||||
m68k->pref_addr = REG_PC;
|
||||
m68k->pref_data = m68k_read_immediate_16(m68k, ADDRESS_68K(m68k, m68k->pref_addr));
|
||||
m68k->pref_data = (*m68k->memory.readimm16)(m68k->program, m68k->pref_addr);
|
||||
}
|
||||
result = MASK_OUT_ABOVE_16(m68k->pref_data);
|
||||
REG_PC += 2;
|
||||
m68k->pref_addr = REG_PC;
|
||||
m68k->pref_data = m68k_read_immediate_16(m68k, ADDRESS_68K(m68k, m68k->pref_addr));
|
||||
m68k->pref_data = (*m68k->memory.readimm16)(m68k->program, m68k->pref_addr);
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -849,17 +865,17 @@ INLINE UINT32 m68ki_read_imm_32(m68ki_cpu_core *m68k)
|
||||
if(REG_PC != m68k->pref_addr)
|
||||
{
|
||||
m68k->pref_addr = REG_PC;
|
||||
m68k->pref_data = m68k_read_immediate_16(m68k, ADDRESS_68K(m68k, m68k->pref_addr));
|
||||
m68k->pref_data = (*m68k->memory.readimm16)(m68k->program, m68k->pref_addr);
|
||||
}
|
||||
temp_val = MASK_OUT_ABOVE_16(m68k->pref_data);
|
||||
REG_PC += 2;
|
||||
m68k->pref_addr = REG_PC;
|
||||
m68k->pref_data = m68k_read_immediate_16(m68k, ADDRESS_68K(m68k, m68k->pref_addr));
|
||||
m68k->pref_data = (*m68k->memory.readimm16)(m68k->program, m68k->pref_addr);
|
||||
|
||||
temp_val = MASK_OUT_ABOVE_32((temp_val << 16) | MASK_OUT_ABOVE_16(m68k->pref_data));
|
||||
REG_PC += 2;
|
||||
m68k->pref_addr = REG_PC;
|
||||
m68k->pref_data = m68k_read_immediate_16(m68k, ADDRESS_68K(m68k, m68k->pref_addr));
|
||||
m68k->pref_data = (*m68k->memory.readimm16)(m68k->program, m68k->pref_addr);
|
||||
|
||||
return temp_val;
|
||||
}
|
||||
@ -877,7 +893,7 @@ INLINE UINT32 m68ki_read_imm_32(m68ki_cpu_core *m68k)
|
||||
INLINE UINT32 m68ki_read_8_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
|
||||
{
|
||||
m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */
|
||||
return m68k_read_memory_8(m68k, ADDRESS_68K(m68k, address));
|
||||
return (*m68k->memory.read8)(m68k->program, address);
|
||||
}
|
||||
INLINE UINT32 m68ki_read_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
|
||||
{
|
||||
@ -886,7 +902,7 @@ INLINE UINT32 m68ki_read_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
|
||||
{
|
||||
m68ki_check_address_error(m68k, address, MODE_READ, fc);
|
||||
}
|
||||
return m68k_read_memory_16(m68k, ADDRESS_68K(m68k, address));
|
||||
return (*m68k->memory.read16)(m68k->program, address);
|
||||
}
|
||||
INLINE UINT32 m68ki_read_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
|
||||
{
|
||||
@ -895,13 +911,13 @@ INLINE UINT32 m68ki_read_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc)
|
||||
{
|
||||
m68ki_check_address_error(m68k, address, MODE_READ, fc);
|
||||
}
|
||||
return m68k_read_memory_32(m68k, ADDRESS_68K(m68k, address));
|
||||
return (*m68k->memory.read32)(m68k->program, address);
|
||||
}
|
||||
|
||||
INLINE void m68ki_write_8_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value)
|
||||
{
|
||||
m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */
|
||||
m68k_write_memory_8(m68k, ADDRESS_68K(m68k, address), value);
|
||||
(*m68k->memory.write8)(m68k->program, address, value);
|
||||
}
|
||||
INLINE void m68ki_write_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value)
|
||||
{
|
||||
@ -910,7 +926,7 @@ INLINE void m68ki_write_16_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, U
|
||||
{
|
||||
m68ki_check_address_error(m68k, address, MODE_WRITE, fc);
|
||||
}
|
||||
m68k_write_memory_16(m68k, ADDRESS_68K(m68k, address), value);
|
||||
(*m68k->memory.write16)(m68k->program, address, value);
|
||||
}
|
||||
INLINE void m68ki_write_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value)
|
||||
{
|
||||
@ -919,9 +935,14 @@ INLINE void m68ki_write_32_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, U
|
||||
{
|
||||
m68ki_check_address_error(m68k, address, MODE_WRITE, fc);
|
||||
}
|
||||
m68k_write_memory_32(m68k, ADDRESS_68K(m68k, address), value);
|
||||
(*m68k->memory.write32)(m68k->program, address, value);
|
||||
}
|
||||
|
||||
/* Special call to simulate undocumented 68k behavior when move.l with a
|
||||
* predecrement destination mode is executed.
|
||||
* A real 68k first writes the high word to [address+2], and then writes the
|
||||
* low word to [address].
|
||||
*/
|
||||
INLINE void m68ki_write_32_pd_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc, UINT32 value)
|
||||
{
|
||||
m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */
|
||||
@ -929,7 +950,8 @@ INLINE void m68ki_write_32_pd_fc(m68ki_cpu_core *m68k, UINT32 address, UINT32 fc
|
||||
{
|
||||
m68ki_check_address_error(m68k, address, MODE_WRITE, fc);
|
||||
}
|
||||
m68k_write_memory_32_pd(m68k, ADDRESS_68K(m68k, address), value);
|
||||
(*m68k->memory.write16)(m68k->program, address+2, value>>16);
|
||||
(*m68k->memory.write16)(m68k->program, address, value&0xffff);
|
||||
}
|
||||
|
||||
|
||||
@ -1178,14 +1200,14 @@ INLINE void m68ki_fake_pull_32(m68ki_cpu_core *m68k)
|
||||
INLINE void m68ki_jump(m68ki_cpu_core *m68k, UINT32 new_pc)
|
||||
{
|
||||
REG_PC = new_pc;
|
||||
change_pc(ADDRESS_68K(m68k, REG_PC));
|
||||
change_pc(REG_PC);
|
||||
}
|
||||
|
||||
INLINE void m68ki_jump_vector(m68ki_cpu_core *m68k, UINT32 vector)
|
||||
{
|
||||
REG_PC = (vector<<2) + m68k->vbr;
|
||||
REG_PC = m68ki_read_data_32(m68k, REG_PC);
|
||||
change_pc(ADDRESS_68K(m68k, REG_PC));
|
||||
change_pc(REG_PC);
|
||||
}
|
||||
|
||||
|
||||
@ -1207,7 +1229,7 @@ INLINE void m68ki_branch_16(m68ki_cpu_core *m68k, UINT32 offset)
|
||||
INLINE void m68ki_branch_32(m68ki_cpu_core *m68k, UINT32 offset)
|
||||
{
|
||||
REG_PC += offset;
|
||||
change_pc(ADDRESS_68K(m68k, REG_PC));
|
||||
change_pc(REG_PC);
|
||||
}
|
||||
|
||||
|
||||
@ -1625,8 +1647,8 @@ INLINE void m68ki_exception_1010(m68ki_cpu_core *m68k)
|
||||
UINT32 sr;
|
||||
#if M68K_LOG_1010_1111 == OPT_ON
|
||||
M68K_DO_LOG_EMU((M68K_LOG_FILEHANDLE "%s at %08x: called 1010 instruction %04x (%s)\n",
|
||||
m68ki_cpu_get_names[m68k->cpu_type], ADDRESS_68K(m68k, REG_PPC), m68k->ir,
|
||||
m68ki_disassemble_quick(ADDRESS_68K(m68k, REG_PPC))));
|
||||
m68ki_cpu_get_names[m68k->cpu_type], REG_PPC, m68k->ir,
|
||||
m68ki_disassemble_quick(REG_PPC)));
|
||||
#endif
|
||||
|
||||
sr = m68ki_init_exception(m68k);
|
||||
@ -1644,8 +1666,8 @@ INLINE void m68ki_exception_1111(m68ki_cpu_core *m68k)
|
||||
|
||||
#if M68K_LOG_1010_1111 == OPT_ON
|
||||
M68K_DO_LOG_EMU((M68K_LOG_FILEHANDLE "%s at %08x: called 1111 instruction %04x (%s)\n",
|
||||
m68ki_cpu_get_names[m68k->cpu_type], ADDRESS_68K(m68k, REG_PPC), m68k->ir,
|
||||
m68ki_disassemble_quick(ADDRESS_68K(m68k, REG_PPC))));
|
||||
m68ki_cpu_get_names[m68k->cpu_type], REG_PPC, m68k->ir,
|
||||
m68ki_disassemble_quick(REG_PPC)));
|
||||
#endif
|
||||
|
||||
sr = m68ki_init_exception(m68k);
|
||||
@ -1662,8 +1684,8 @@ INLINE void m68ki_exception_illegal(m68ki_cpu_core *m68k)
|
||||
UINT32 sr;
|
||||
|
||||
M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: illegal instruction %04x (%s)\n",
|
||||
m68ki_cpu_get_names[m68k->cpu_type], ADDRESS_68K(m68k, REG_PPC), m68k->ir,
|
||||
m68ki_disassemble_quick(ADDRESS_68K(m68k, REG_PPC))));
|
||||
m68ki_cpu_get_names[m68k->cpu_type], REG_PPC, m68k->ir,
|
||||
m68ki_disassemble_quick(REG_PPC)));
|
||||
|
||||
sr = m68ki_init_exception(m68k);
|
||||
|
||||
@ -1701,7 +1723,7 @@ INLINE void m68ki_exception_address_error(m68ki_cpu_core *m68k)
|
||||
*/
|
||||
if(m68k->run_mode == RUN_MODE_BERR_AERR_RESET)
|
||||
{
|
||||
m68k_read_memory_8(m68k, 0x00ffff01);
|
||||
(*m68k->memory.read8)(m68k->program, 0x00ffff01);
|
||||
m68k->stopped = STOP_LEVEL_HALT;
|
||||
return;
|
||||
}
|
||||
@ -1749,7 +1771,7 @@ void m68ki_exception_interrupt(m68ki_cpu_core *m68k, UINT32 int_level)
|
||||
else if(vector > 255)
|
||||
{
|
||||
M68K_DO_LOG_EMU((M68K_LOG_FILEHANDLE "%s at %08x: Interrupt acknowledge returned invalid vector $%x\n",
|
||||
m68ki_cpu_get_names[m68k->cpu_type], ADDRESS_68K(m68k, REG_PC), vector));
|
||||
m68ki_cpu_get_names[m68k->cpu_type], REG_PC, vector));
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@ -192,9 +192,6 @@ static void (*g_instruction_table[0x10000])(void);
|
||||
/* Flag if disassembler initialized */
|
||||
static int g_initialized = 0;
|
||||
|
||||
/* Address mask to simulate address lines */
|
||||
static unsigned int g_address_mask = 0xffffffff;
|
||||
|
||||
static char g_dasm_str[100]; /* string to hold disassembly */
|
||||
static char g_helper_str[100]; /* string to hold helpful info */
|
||||
static UINT32 g_cpu_pc; /* program counter */
|
||||
@ -245,10 +242,7 @@ static const char *const g_cpcc[64] =
|
||||
static UINT32 dasm_read_imm_8(UINT32 advance)
|
||||
{
|
||||
UINT32 result;
|
||||
// if (g_rawop)
|
||||
result = g_rawop[g_cpu_pc + 1 - g_rawbasepc];
|
||||
// else
|
||||
// result = m68k_read_disassembler_16(g_cpu_pc & g_address_mask) & 0xff;
|
||||
result = g_rawop[g_cpu_pc + 1 - g_rawbasepc];
|
||||
g_cpu_pc += advance;
|
||||
return result;
|
||||
}
|
||||
@ -256,11 +250,8 @@ static UINT32 dasm_read_imm_8(UINT32 advance)
|
||||
static UINT32 dasm_read_imm_16(UINT32 advance)
|
||||
{
|
||||
UINT32 result;
|
||||
// if (g_rawop)
|
||||
result = (g_rawop[g_cpu_pc + 0 - g_rawbasepc] << 8) |
|
||||
g_rawop[g_cpu_pc + 1 - g_rawbasepc];
|
||||
// else
|
||||
// result = m68k_read_disassembler_16(g_cpu_pc & g_address_mask) & 0xff;
|
||||
result = (g_rawop[g_cpu_pc + 0 - g_rawbasepc] << 8) |
|
||||
g_rawop[g_cpu_pc + 1 - g_rawbasepc];
|
||||
g_cpu_pc += advance;
|
||||
return result;
|
||||
}
|
||||
@ -268,13 +259,10 @@ static UINT32 dasm_read_imm_16(UINT32 advance)
|
||||
static UINT32 dasm_read_imm_32(UINT32 advance)
|
||||
{
|
||||
UINT32 result;
|
||||
// if (g_rawop)
|
||||
result = (g_rawop[g_cpu_pc + 0 - g_rawbasepc] << 24) |
|
||||
(g_rawop[g_cpu_pc + 1 - g_rawbasepc] << 16) |
|
||||
(g_rawop[g_cpu_pc + 2 - g_rawbasepc] << 8) |
|
||||
g_rawop[g_cpu_pc + 3 - g_rawbasepc];
|
||||
// else
|
||||
// result = m68k_read_disassembler_32(g_cpu_pc & g_address_mask) & 0xff;
|
||||
result = (g_rawop[g_cpu_pc + 0 - g_rawbasepc] << 24) |
|
||||
(g_rawop[g_cpu_pc + 1 - g_rawbasepc] << 16) |
|
||||
(g_rawop[g_cpu_pc + 2 - g_rawbasepc] << 8) |
|
||||
g_rawop[g_cpu_pc + 3 - g_rawbasepc];
|
||||
g_cpu_pc += advance;
|
||||
return result;
|
||||
}
|
||||
@ -3471,31 +3459,24 @@ unsigned int m68k_disassemble(char* str_buff, unsigned int pc, unsigned int cpu_
|
||||
{
|
||||
case M68K_CPU_TYPE_68000:
|
||||
g_cpu_type = TYPE_68000;
|
||||
g_address_mask = 0x00ffffff;
|
||||
break;
|
||||
case M68K_CPU_TYPE_68008:
|
||||
g_cpu_type = TYPE_68008;
|
||||
g_address_mask = 0x003fffff;
|
||||
break;
|
||||
case M68K_CPU_TYPE_68010:
|
||||
g_cpu_type = TYPE_68010;
|
||||
g_address_mask = 0x00ffffff;
|
||||
break;
|
||||
case M68K_CPU_TYPE_68EC020:
|
||||
g_cpu_type = TYPE_68020;
|
||||
g_address_mask = 0x00ffffff;
|
||||
break;
|
||||
case M68K_CPU_TYPE_68020:
|
||||
g_cpu_type = TYPE_68020;
|
||||
g_address_mask = 0xffffffff;
|
||||
break;
|
||||
case M68K_CPU_TYPE_68030:
|
||||
g_cpu_type = TYPE_68030;
|
||||
g_address_mask = 0xffffffff;
|
||||
break;
|
||||
case M68K_CPU_TYPE_68040:
|
||||
g_cpu_type = TYPE_68040;
|
||||
g_address_mask = 0xffffffff;
|
||||
break;
|
||||
default:
|
||||
return 0;
|
||||
|
||||
@ -5,22 +5,18 @@
|
||||
|
||||
/* global access */
|
||||
|
||||
m68k_memory_interface m68k_memory_intf;
|
||||
offs_t m68k_encrypted_opcode_start[MAX_CPU];
|
||||
offs_t m68k_encrypted_opcode_end[MAX_CPU];
|
||||
|
||||
|
||||
void m68k_set_encrypted_opcode_range(int cpunum, offs_t start, offs_t end)
|
||||
void m68k_set_encrypted_opcode_range(const device_config *device, offs_t start, offs_t end)
|
||||
{
|
||||
m68k_encrypted_opcode_start[cpunum] = start;
|
||||
m68k_encrypted_opcode_end[cpunum] = end;
|
||||
m68ki_cpu_core *m68k = device->token;
|
||||
m68k->encrypted_start = start;
|
||||
m68k->encrypted_end = end;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* 8-bit data memory interface
|
||||
****************************************************************************/
|
||||
|
||||
static UINT16 m68008_read_immediate_16(offs_t address)
|
||||
static UINT16 m68008_read_immediate_16(const address_space *space, offs_t address)
|
||||
{
|
||||
offs_t addr = address;
|
||||
return (cpu_readop(addr) << 8) | (cpu_readop(addr + 1));
|
||||
@ -31,34 +27,40 @@ static const m68k_memory_interface interface_d8 =
|
||||
{
|
||||
0,
|
||||
m68008_read_immediate_16,
|
||||
program_read_byte_8be,
|
||||
program_read_word_8be,
|
||||
program_read_dword_8be,
|
||||
program_write_byte_8be,
|
||||
program_write_word_8be,
|
||||
program_write_dword_8be
|
||||
memory_read_byte_8be,
|
||||
memory_read_word_8be,
|
||||
memory_read_dword_8be,
|
||||
memory_write_byte_8be,
|
||||
memory_write_word_8be,
|
||||
memory_write_dword_8be
|
||||
};
|
||||
|
||||
/****************************************************************************
|
||||
* 16-bit data memory interface
|
||||
****************************************************************************/
|
||||
|
||||
static UINT16 read_immediate_16(offs_t address)
|
||||
static UINT16 read_immediate_16(const address_space *space, offs_t address)
|
||||
{
|
||||
return cpu_readop16((address) ^ m68k_memory_intf.opcode_xor);
|
||||
m68ki_cpu_core *m68k = space->cpu->token;
|
||||
return cpu_readop16((address) ^ m68k->memory.opcode_xor);
|
||||
}
|
||||
|
||||
static UINT16 simple_read_immediate_16(const address_space *space, offs_t address)
|
||||
{
|
||||
return cpu_readop16(address);
|
||||
}
|
||||
|
||||
/* interface for 24-bit address bus, 16-bit data bus (68000, 68010) */
|
||||
static const m68k_memory_interface interface_d16 =
|
||||
{
|
||||
0,
|
||||
cpu_readop16,
|
||||
program_read_byte_16be,
|
||||
program_read_word_16be,
|
||||
program_read_dword_16be,
|
||||
program_write_byte_16be,
|
||||
program_write_word_16be,
|
||||
program_write_dword_16be
|
||||
simple_read_immediate_16,
|
||||
memory_read_byte_16be,
|
||||
memory_read_word_16be,
|
||||
memory_read_dword_16be,
|
||||
memory_write_byte_16be,
|
||||
memory_write_word_16be,
|
||||
memory_write_dword_16be
|
||||
};
|
||||
|
||||
/****************************************************************************
|
||||
@ -66,62 +68,62 @@ static const m68k_memory_interface interface_d16 =
|
||||
****************************************************************************/
|
||||
|
||||
/* potentially misaligned 16-bit reads with a 32-bit data bus (and 24-bit address bus) */
|
||||
static UINT16 readword_d32(offs_t address)
|
||||
static UINT16 readword_d32(const address_space *space, offs_t address)
|
||||
{
|
||||
UINT16 result;
|
||||
|
||||
if (!(address & 1))
|
||||
return program_read_word_32be(address);
|
||||
result = program_read_byte_32be(address) << 8;
|
||||
return result | program_read_byte_32be(address + 1);
|
||||
return memory_read_word_32be(space, address);
|
||||
result = memory_read_byte_32be(space, address) << 8;
|
||||
return result | memory_read_byte_32be(space, address + 1);
|
||||
}
|
||||
|
||||
/* potentially misaligned 16-bit writes with a 32-bit data bus (and 24-bit address bus) */
|
||||
static void writeword_d32(offs_t address, UINT16 data)
|
||||
static void writeword_d32(const address_space *space, offs_t address, UINT16 data)
|
||||
{
|
||||
if (!(address & 1))
|
||||
{
|
||||
program_write_word_32be(address, data);
|
||||
memory_write_word_32be(space, address, data);
|
||||
return;
|
||||
}
|
||||
program_write_byte_32be(address, data >> 8);
|
||||
program_write_byte_32be(address + 1, data);
|
||||
memory_write_byte_32be(space, address, data >> 8);
|
||||
memory_write_byte_32be(space, address + 1, data);
|
||||
}
|
||||
|
||||
/* potentially misaligned 32-bit reads with a 32-bit data bus (and 24-bit address bus) */
|
||||
static UINT32 readlong_d32(offs_t address)
|
||||
static UINT32 readlong_d32(const address_space *space, offs_t address)
|
||||
{
|
||||
UINT32 result;
|
||||
|
||||
if (!(address & 3))
|
||||
return program_read_dword_32be(address);
|
||||
return memory_read_dword_32be(space, address);
|
||||
else if (!(address & 1))
|
||||
{
|
||||
result = program_read_word_32be(address) << 16;
|
||||
return result | program_read_word_32be(address + 2);
|
||||
result = memory_read_word_32be(space, address) << 16;
|
||||
return result | memory_read_word_32be(space, address + 2);
|
||||
}
|
||||
result = program_read_byte_32be(address) << 24;
|
||||
result |= program_read_word_32be(address + 1) << 8;
|
||||
return result | program_read_byte_32be(address + 3);
|
||||
result = memory_read_byte_32be(space, address) << 24;
|
||||
result |= memory_read_word_32be(space, address + 1) << 8;
|
||||
return result | memory_read_byte_32be(space, address + 3);
|
||||
}
|
||||
|
||||
/* potentially misaligned 32-bit writes with a 32-bit data bus (and 24-bit address bus) */
|
||||
static void writelong_d32(offs_t address, UINT32 data)
|
||||
static void writelong_d32(const address_space *space, offs_t address, UINT32 data)
|
||||
{
|
||||
if (!(address & 3))
|
||||
{
|
||||
program_write_dword_32be(address, data);
|
||||
memory_write_dword_32be(space, address, data);
|
||||
return;
|
||||
}
|
||||
else if (!(address & 1))
|
||||
{
|
||||
program_write_word_32be(address, data >> 16);
|
||||
program_write_word_32be(address + 2, data);
|
||||
memory_write_word_32be(space, address, data >> 16);
|
||||
memory_write_word_32be(space, address + 2, data);
|
||||
return;
|
||||
}
|
||||
program_write_byte_32be(address, data >> 24);
|
||||
program_write_word_32be(address + 1, data >> 8);
|
||||
program_write_byte_32be(address + 3, data);
|
||||
memory_write_byte_32be(space, address, data >> 24);
|
||||
memory_write_word_32be(space, address + 1, data >> 8);
|
||||
memory_write_byte_32be(space, address + 3, data);
|
||||
}
|
||||
|
||||
/* interface for 32-bit data bus (68EC020, 68020) */
|
||||
@ -129,10 +131,10 @@ static const m68k_memory_interface interface_d32 =
|
||||
{
|
||||
WORD_XOR_BE(0),
|
||||
read_immediate_16,
|
||||
program_read_byte_32be,
|
||||
memory_read_byte_32be,
|
||||
readword_d32,
|
||||
readlong_d32,
|
||||
program_write_byte_32be,
|
||||
memory_write_byte_32be,
|
||||
writeword_d32,
|
||||
writelong_d32
|
||||
};
|
||||
@ -154,9 +156,11 @@ static void set_irq_line(m68ki_cpu_core *m68k, int irqline, int state)
|
||||
static CPU_INIT( m68000 )
|
||||
{
|
||||
m68ki_cpu_core *m68k = device->token;
|
||||
m68k->device = device;
|
||||
m68k->program = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
|
||||
m68k->memory = interface_d16;
|
||||
m68k_init(m68k);
|
||||
m68k_set_cpu_type(m68k, M68K_CPU_TYPE_68000);
|
||||
m68k_memory_intf = interface_d16;
|
||||
m68k_state_register(m68k, "m68000", index);
|
||||
m68k_set_int_ack_callback(m68k, (void *)device, (int (*)(void *param, int int_level)) irqcallback);
|
||||
}
|
||||
@ -182,8 +186,6 @@ static CPU_GET_CONTEXT( m68000 )
|
||||
|
||||
static CPU_SET_CONTEXT( m68000 )
|
||||
{
|
||||
if (m68k_memory_intf.read8 != program_read_byte_16be)
|
||||
m68k_memory_intf = interface_d16;
|
||||
}
|
||||
|
||||
static CPU_DISASSEMBLE( m68000 )
|
||||
@ -199,9 +201,11 @@ static CPU_DISASSEMBLE( m68000 )
|
||||
static CPU_INIT( m68008 )
|
||||
{
|
||||
m68ki_cpu_core *m68k = device->token;
|
||||
m68k->device = device;
|
||||
m68k->program = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
|
||||
m68k->memory = interface_d8;
|
||||
m68k_init(m68k);
|
||||
m68k_set_cpu_type(m68k, M68K_CPU_TYPE_68008);
|
||||
m68k_memory_intf = interface_d8;
|
||||
m68k_state_register(m68k, "m68008", index);
|
||||
m68k_set_int_ack_callback(m68k, (void *)device, irqcallback);
|
||||
}
|
||||
@ -227,8 +231,6 @@ static CPU_GET_CONTEXT( m68008 )
|
||||
|
||||
static CPU_SET_CONTEXT( m68008 )
|
||||
{
|
||||
if (m68k_memory_intf.read8 != program_read_byte_8be)
|
||||
m68k_memory_intf = interface_d8;
|
||||
}
|
||||
|
||||
static CPU_DISASSEMBLE( m68008 )
|
||||
@ -246,9 +248,11 @@ static CPU_DISASSEMBLE( m68008 )
|
||||
static CPU_INIT( m68010 )
|
||||
{
|
||||
m68ki_cpu_core *m68k = device->token;
|
||||
m68k->device = device;
|
||||
m68k->program = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
|
||||
m68k->memory = interface_d16;
|
||||
m68k_init(m68k);
|
||||
m68k_set_cpu_type(m68k, M68K_CPU_TYPE_68010);
|
||||
m68k_memory_intf = interface_d16;
|
||||
m68k_state_register(m68k, "m68010", index);
|
||||
m68k_set_int_ack_callback(m68k, (void *)device, (int (*)(void *param, int int_level)) irqcallback);
|
||||
}
|
||||
@ -267,9 +271,11 @@ static CPU_DISASSEMBLE( m68010 )
|
||||
static CPU_INIT( m68020 )
|
||||
{
|
||||
m68ki_cpu_core *m68k = device->token;
|
||||
m68k->device = device;
|
||||
m68k->program = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
|
||||
m68k->memory = interface_d32;
|
||||
m68k_init(m68k);
|
||||
m68k_set_cpu_type(m68k, M68K_CPU_TYPE_68020);
|
||||
m68k_memory_intf = interface_d32;
|
||||
m68k_state_register(m68k, "m68020", index);
|
||||
m68k_set_int_ack_callback(m68k, (void *)device, (int (*)(void *param, int int_level)) irqcallback);
|
||||
}
|
||||
@ -295,8 +301,6 @@ static CPU_GET_CONTEXT( m68020 )
|
||||
|
||||
static CPU_SET_CONTEXT( m68020 )
|
||||
{
|
||||
if (m68k_memory_intf.read8 != program_read_byte_32be)
|
||||
m68k_memory_intf = interface_d32;
|
||||
}
|
||||
|
||||
static CPU_DISASSEMBLE( m68020 )
|
||||
@ -313,9 +317,11 @@ static CPU_DISASSEMBLE( m68020 )
|
||||
static CPU_INIT( m68ec020 )
|
||||
{
|
||||
m68ki_cpu_core *m68k = device->token;
|
||||
m68k->device = device;
|
||||
m68k->program = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
|
||||
m68k->memory = interface_d32;
|
||||
m68k_init(m68k);
|
||||
m68k_set_cpu_type(m68k, M68K_CPU_TYPE_68EC020);
|
||||
m68k_memory_intf = interface_d32;
|
||||
m68k_state_register(m68k, "m68ec020", index);
|
||||
m68k_set_int_ack_callback(m68k, (void *)device, (int (*)(void *param, int int_level)) irqcallback);
|
||||
}
|
||||
@ -335,9 +341,11 @@ static CPU_DISASSEMBLE( m68ec020 )
|
||||
static CPU_INIT( m68040 )
|
||||
{
|
||||
m68ki_cpu_core *m68k = device->token;
|
||||
m68k->device = device;
|
||||
m68k->program = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
|
||||
m68k->memory = interface_d32;
|
||||
m68k_init(m68k);
|
||||
m68k_set_cpu_type(m68k, M68K_CPU_TYPE_68040);
|
||||
m68k_memory_intf = interface_d32;
|
||||
m68k_state_register(m68k, "m68040", index);
|
||||
m68k_set_int_ack_callback(m68k, (void *)device, (int (*)(void *param, int int_level)) irqcallback);
|
||||
}
|
||||
@ -363,8 +371,6 @@ static CPU_GET_CONTEXT( m68040 )
|
||||
|
||||
static CPU_SET_CONTEXT( m68040 )
|
||||
{
|
||||
if (m68k_memory_intf.read8 != program_read_byte_32be)
|
||||
m68k_memory_intf = interface_d32;
|
||||
}
|
||||
|
||||
static CPU_DISASSEMBLE( m68040 )
|
||||
|
||||
@ -11,16 +11,10 @@
|
||||
#include "deprecat.h"
|
||||
#include "m68000.h"
|
||||
|
||||
#ifndef __M68KCPU_H__
|
||||
#define m68ki_cpu_core void
|
||||
#endif
|
||||
|
||||
#define OPT_ON 1
|
||||
#define OPT_OFF 0
|
||||
|
||||
/* Configuration switches (see m68kconf.h for explanation) */
|
||||
#define M68K_SEPARATE_READS OPT_ON
|
||||
|
||||
#define M68K_EMULATE_TRACE OPT_OFF
|
||||
|
||||
#define M68K_EMULATE_FC OPT_OFF
|
||||
@ -33,82 +27,7 @@
|
||||
#define M68K_USE_64_BIT OPT_OFF
|
||||
|
||||
|
||||
extern m68k_memory_interface m68k_memory_intf;
|
||||
extern offs_t m68k_encrypted_opcode_start[MAX_CPU];
|
||||
extern offs_t m68k_encrypted_opcode_end[MAX_CPU];
|
||||
|
||||
#define m68k_read_memory_8(M, A) (*m68k_memory_intf.read8)(A)
|
||||
#define m68k_read_memory_16(M, A) (*m68k_memory_intf.read16)(A)
|
||||
#define m68k_read_memory_32(M, A) (*m68k_memory_intf.read32)(A)
|
||||
|
||||
#define m68k_read_immediate_16(M, A) (*m68k_memory_intf.readimm16)(A)
|
||||
#define m68k_read_immediate_32(M, A) m68kx_read_immediate_32(M, A)
|
||||
#define m68k_read_pcrelative_8(M, A) m68kx_read_pcrelative_8(M, A)
|
||||
#define m68k_read_pcrelative_16(M, A) m68kx_read_pcrelative_16(M, A)
|
||||
#define m68k_read_pcrelative_32(M, A) m68kx_read_pcrelative_32(M, A)
|
||||
|
||||
#define m68k_read_disassembler_16(M, A) m68k_read_immediate_16(M, A)
|
||||
#define m68k_read_disassembler_32(M, A) m68kx_read_immediate_32(M, A)
|
||||
|
||||
#define m68k_write_memory_8(M, A, V) (*m68k_memory_intf.write8)(A, V)
|
||||
#define m68k_write_memory_16(M, A, V) (*m68k_memory_intf.write16)(A, V)
|
||||
#define m68k_write_memory_32(M, A, V) (*m68k_memory_intf.write32)(A, V)
|
||||
#define m68k_write_memory_32_pd(M, A, V) m68kx_write_memory_32_pd(M, A, V)
|
||||
|
||||
|
||||
INLINE unsigned int m68k_read_immediate_32(m68ki_cpu_core *m68k, unsigned int address);
|
||||
INLINE unsigned int m68k_read_pcrelative_8(m68ki_cpu_core *m68k, unsigned int address);
|
||||
INLINE unsigned int m68k_read_pcrelative_16(m68ki_cpu_core *m68k, unsigned int address);
|
||||
INLINE unsigned int m68k_read_pcrelative_32(m68ki_cpu_core *m68k, unsigned int address);
|
||||
INLINE void m68k_write_memory_32_pd(m68ki_cpu_core *m68k, unsigned int address, unsigned int value);
|
||||
|
||||
|
||||
INLINE unsigned int m68kx_read_immediate_32(m68ki_cpu_core *m68k, unsigned int address)
|
||||
{
|
||||
return ((m68k_read_immediate_16(m68k, address) << 16) | m68k_read_immediate_16(m68k, (address)+2));
|
||||
}
|
||||
|
||||
INLINE unsigned int m68kx_read_pcrelative_8(m68ki_cpu_core *m68k, unsigned int address)
|
||||
{
|
||||
if (address >= m68k_encrypted_opcode_start[cpunum_get_active()] &&
|
||||
address < m68k_encrypted_opcode_end[cpunum_get_active()])
|
||||
return ((m68k_read_immediate_16(m68k, address&~1)>>(8*(1-(address & 1))))&0xff);
|
||||
else
|
||||
return m68k_read_memory_8(m68k, address);
|
||||
}
|
||||
|
||||
INLINE unsigned int m68kx_read_pcrelative_16(m68ki_cpu_core *m68k, unsigned int address)
|
||||
{
|
||||
if (address >= m68k_encrypted_opcode_start[cpunum_get_active()] &&
|
||||
address < m68k_encrypted_opcode_end[cpunum_get_active()])
|
||||
return m68k_read_immediate_16(m68k, address);
|
||||
else
|
||||
return m68k_read_memory_16(m68k, address);
|
||||
}
|
||||
|
||||
INLINE unsigned int m68kx_read_pcrelative_32(m68ki_cpu_core *m68k, unsigned int address)
|
||||
{
|
||||
if (address >= m68k_encrypted_opcode_start[cpunum_get_active()] &&
|
||||
address < m68k_encrypted_opcode_end[cpunum_get_active()])
|
||||
return m68k_read_immediate_32(m68k, address);
|
||||
else
|
||||
return m68k_read_memory_32(m68k, address);
|
||||
}
|
||||
|
||||
|
||||
/* Special call to simulate undocumented 68k behavior when move.l with a
|
||||
* predecrement destination mode is executed.
|
||||
* A real 68k first writes the high word to [address+2], and then writes the
|
||||
* low word to [address].
|
||||
*/
|
||||
INLINE void m68kx_write_memory_32_pd(m68ki_cpu_core *m68k, unsigned int address, unsigned int value)
|
||||
{
|
||||
(*m68k_memory_intf.write16)(address+2, value>>16);
|
||||
(*m68k_memory_intf.write16)(address, value&0xffff);
|
||||
}
|
||||
|
||||
|
||||
void m68k_set_encrypted_opcode_range(int cpunum, offs_t start, offs_t end);
|
||||
void m68k_set_encrypted_opcode_range(const device_config *device, offs_t start, offs_t end);
|
||||
|
||||
|
||||
/* ======================================================================== */
|
||||
|
||||
@ -808,28 +808,6 @@ static READ16_HANDLER( cps2_qsound_volume_r )
|
||||
}
|
||||
|
||||
|
||||
/*************************************
|
||||
*
|
||||
* ???
|
||||
*
|
||||
*************************************/
|
||||
|
||||
static UINT8 cps2_read8(offs_t address)
|
||||
{
|
||||
return m68k_read_pcrelative_8(NULL, address);
|
||||
}
|
||||
|
||||
static UINT16 cps2_read16(offs_t address)
|
||||
{
|
||||
return m68k_read_pcrelative_16(NULL, address);
|
||||
}
|
||||
|
||||
static UINT32 cps2_read32(offs_t address)
|
||||
{
|
||||
return m68k_read_pcrelative_32(NULL, address);
|
||||
}
|
||||
|
||||
|
||||
/*************************************
|
||||
*
|
||||
* Read handlers
|
||||
@ -1234,19 +1212,6 @@ static GFXDECODE_START( cps2 )
|
||||
GFXDECODE_END
|
||||
|
||||
|
||||
/*************************************
|
||||
*
|
||||
* M68K encryption interface
|
||||
*
|
||||
*************************************/
|
||||
|
||||
static const m68k_encryption_interface cps2_encryption =
|
||||
{
|
||||
cps2_read8, cps2_read16, cps2_read32,
|
||||
cps2_read16, cps2_read32
|
||||
};
|
||||
|
||||
|
||||
/*************************************
|
||||
*
|
||||
* Machine driver
|
||||
@ -1257,7 +1222,6 @@ static MACHINE_DRIVER_START( cps2 )
|
||||
|
||||
/* basic machine hardware */
|
||||
MDRV_CPU_ADD("main", M68000, XTAL_16MHz)
|
||||
MDRV_CPU_CONFIG(cps2_encryption)
|
||||
MDRV_CPU_PROGRAM_MAP(cps2_readmem,cps2_writemem)
|
||||
MDRV_CPU_VBLANK_INT_HACK(cps2_interrupt,259) // 262 /* ??? interrupts per frame */
|
||||
|
||||
|
||||
@ -720,7 +720,7 @@ static void cps2_decrypt(running_machine *machine, const UINT32 *master_key, UIN
|
||||
}
|
||||
|
||||
memory_set_decrypted_region(0, 0x000000, length - 1, dec);
|
||||
m68k_set_encrypted_opcode_range(0,0,length);
|
||||
m68k_set_encrypted_opcode_range(machine->cpu[0],0,length);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -58,7 +58,7 @@ void deco102_decrypt_cpu(running_machine *machine, const char *region, int addre
|
||||
memcpy(buf,rom,size);
|
||||
|
||||
memory_set_decrypted_region(0, 0, size - 1, opcodes);
|
||||
m68k_set_encrypted_opcode_range(0,0,size);
|
||||
m68k_set_encrypted_opcode_range(machine->cpu[0],0,size);
|
||||
|
||||
for (i = 0;i < size/2;i++)
|
||||
{
|
||||
|
||||
@ -78,7 +78,7 @@ static void fd1094_setstate_and_decrypt(int state)
|
||||
/* copy cached state */
|
||||
fd1094_userregion=fd1094_cacheregion[i];
|
||||
set_decrypted_region();
|
||||
m68k_set_encrypted_opcode_range(0,0,fd1094_cpuregionsize);
|
||||
m68k_set_encrypted_opcode_range(Machine->cpu[0],0,fd1094_cpuregionsize);
|
||||
|
||||
return;
|
||||
}
|
||||
@ -97,7 +97,7 @@ static void fd1094_setstate_and_decrypt(int state)
|
||||
/* copy newly decrypted data to user region */
|
||||
fd1094_userregion=fd1094_cacheregion[fd1094_current_cacheposition];
|
||||
set_decrypted_region();
|
||||
m68k_set_encrypted_opcode_range(0,0,fd1094_cpuregionsize);
|
||||
m68k_set_encrypted_opcode_range(Machine->cpu[0],0,fd1094_cpuregionsize);
|
||||
|
||||
fd1094_current_cacheposition++;
|
||||
|
||||
|
||||
@ -58,7 +58,7 @@ static void s24_fd1094_setstate_and_decrypt(int state)
|
||||
/* copy cached state */
|
||||
s24_fd1094_userregion=s24_fd1094_cacheregion[i];
|
||||
memory_set_decrypted_region(1, 0, s24_fd1094_cpuregionsize - 1, s24_fd1094_userregion);
|
||||
m68k_set_encrypted_opcode_range(1,0,s24_fd1094_cpuregionsize);
|
||||
m68k_set_encrypted_opcode_range(Machine->cpu[1],0,s24_fd1094_cpuregionsize);
|
||||
|
||||
return;
|
||||
}
|
||||
@ -79,7 +79,7 @@ static void s24_fd1094_setstate_and_decrypt(int state)
|
||||
/* copy newly decrypted data to user region */
|
||||
s24_fd1094_userregion=s24_fd1094_cacheregion[fd1094_current_cacheposition];
|
||||
memory_set_decrypted_region(1, 0, s24_fd1094_cpuregionsize - 1, s24_fd1094_userregion);
|
||||
m68k_set_encrypted_opcode_range(1,0,s24_fd1094_cpuregionsize);
|
||||
m68k_set_encrypted_opcode_range(Machine->cpu[1],0,s24_fd1094_cpuregionsize);
|
||||
|
||||
fd1094_current_cacheposition++;
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user