diff options
author | 2010-07-04 10:51:28 +0200 | |
---|---|---|
committer | 2010-07-04 10:51:28 +0200 | |
commit | e6013001a3e730497e4606add4aff3ac743aedc4 (patch) | |
tree | 0b347abed118addaf7631f78cbc1649b0b9d0596 /plugins/ao/eng_ssf/m68kcpu.h | |
parent | efd7ae55acdca5eef47432eefed35d90d594d572 (diff) |
ao plugin: eng_ssf reentrant
Diffstat (limited to 'plugins/ao/eng_ssf/m68kcpu.h')
-rw-r--r-- | plugins/ao/eng_ssf/m68kcpu.h | 1014 |
1 files changed, 515 insertions, 499 deletions
diff --git a/plugins/ao/eng_ssf/m68kcpu.h b/plugins/ao/eng_ssf/m68kcpu.h index 80d4e19a..77e4191b 100644 --- a/plugins/ao/eng_ssf/m68kcpu.h +++ b/plugins/ao/eng_ssf/m68kcpu.h @@ -2,6 +2,7 @@ #ifdef _MSC_VER #include "ao.h" #else +#undef INLINE #define INLINE static inline #endif /* ======================================================================== */ @@ -67,12 +68,12 @@ #define uint8 unsigned char #define uint16 unsigned short #define uint32 unsigned long - /* signed and unsigned int must be at least 32 bits wide */ #define sint signed int #define uint unsigned int +#if 0 #if M68K_USE_64_BIT #define sint64 signed long long #define uint64 unsigned long long @@ -80,7 +81,7 @@ #define sint64 sint32 #define uint64 uint32 #endif /* M68K_USE_64_BIT */ - +#endif /* Allow for architectures that don't have 8-bit sizes */ @@ -127,7 +128,99 @@ } #endif /* ULONG_MAX == 0xffffffff */ +/* ======================================================================== */ +/* =============================== PROTOTYPES ============================= */ +/* ======================================================================== */ + + +typedef struct m68ki_cpu_core_s +{ + uint cpu_type; /* CPU Type: 68000, 68010, 68EC020, or 68020 */ + uint dar[16]; /* Data and Address Registers */ + uint ppc; /* Previous program counter */ + uint pc; /* Program Counter */ + uint sp[7]; /* User, Interrupt, and Master Stack Pointers */ + uint vbr; /* Vector Base Register (m68010+) */ + uint sfc; /* Source Function Code Register (m68010+) */ + uint dfc; /* Destination Function Code Register (m68010+) */ + uint cacr; /* Cache Control Register (m68020, unemulated) */ + uint caar; /* Cache Address Register (m68020, unemulated) */ + uint ir; /* Instruction Register */ + uint t1_flag; /* Trace 1 */ + uint t0_flag; /* Trace 0 */ + uint s_flag; /* Supervisor */ + uint m_flag; /* Master/Interrupt state */ + uint x_flag; /* Extend */ + uint n_flag; /* Negative */ + uint not_z_flag; /* Zero, inverted for speedups */ + uint v_flag; /* Overflow */ + uint c_flag; /* Carry */ + uint int_mask; /* I0-I2 */ + uint int_level; /* State of interrupt pins IPL0-IPL2 -- ASG: changed from ints_pending */ + uint int_cycles; /* ASG: extra cycles from generated interrupts */ + uint stopped; /* Stopped state */ + uint pref_addr; /* Last prefetch address */ + uint pref_data; /* Data in the prefetch queue */ + uint address_mask; /* Available address pins */ + uint sr_mask; /* Implemented status register bits */ + uint instr_mode; /* Stores whether we are in instruction mode or group 0/1 exception mode */ + uint run_mode; /* Stores whether we are processing a reset, bus error, address error, or something else */ + + /* Clocks required for instructions / exceptions */ + uint cyc_bcc_notake_b; + uint cyc_bcc_notake_w; + uint cyc_dbcc_f_noexp; + uint cyc_dbcc_f_exp; + uint cyc_scc_r_false; + uint cyc_movem_w; + uint cyc_movem_l; + uint cyc_shift; + uint cyc_reset; + uint8* cyc_instruction; + uint8* cyc_exception; + + /* Callbacks to host */ + int (*int_ack_callback)(struct m68ki_cpu_core_s *cpu, int int_line); /* Interrupt Acknowledge */ + void (*bkpt_ack_callback)(struct m68ki_cpu_core_s *cpu, unsigned int data); /* Breakpoint Acknowledge */ + void (*reset_instr_callback)(struct m68ki_cpu_core_s *cpu); /* Called when a RESET instruction is encountered */ + void (*pc_changed_callback)(struct m68ki_cpu_core_s *cpu, unsigned int new_pc); /* Called when the PC changes by a large amount */ + void (*set_fc_callback)(struct m68ki_cpu_core_s *cpu, unsigned int new_fc); /* Called when the CPU function code changes */ + void (*instr_hook_callback)(struct m68ki_cpu_core_s *cpu); /* Called every instruction cycle prior to execution */ + +#if M68K_EMULATE_ADDRESS_ERROR + jmp_buf m68ki_aerr_trap; +#endif /* M68K_EMULATE_ADDRESS_ERROR */ + + uint m68ki_aerr_address; + uint m68ki_aerr_write_mode; + uint m68ki_aerr_fc; + + int default_int_ack_callback_data; + unsigned int default_bkpt_ack_callback_data; + unsigned int default_pc_changed_callback_data; + unsigned int default_set_fc_callback_data; + int m68k_trap0; + int m68ki_initial_cycles; + int m68ki_remaining_cycles; /* Number of clocks remaining */ + uint m68ki_tracing; + uint m68ki_address_space; + + uint8 sat_ram[512*1024]; + + void *SCSP; +} m68ki_cpu_core; + + +extern uint8 m68ki_shift_8_table[]; +extern uint16 m68ki_shift_16_table[]; +extern uint m68ki_shift_32_table[]; +extern uint8 m68ki_exception_cycle_table[][256]; +extern uint8 m68ki_ea_idx_cycle_table[]; +m68ki_cpu_core *m68k_init(void); +/* Execute some instructions until we use up num_cycles clock cycles */ +/* ASG: removed per-instruction interrupt checks */ +int m68k_execute(m68ki_cpu_core *cpu, int num_cycles); /* ======================================================================== */ @@ -300,65 +393,65 @@ /* ------------------------------ CPU Access ------------------------------ */ /* Access the CPU registers */ -#define CPU_TYPE m68ki_cpu.cpu_type - -#define REG_DA m68ki_cpu.dar /* easy access to data and address regs */ -#define REG_D m68ki_cpu.dar -#define REG_A (m68ki_cpu.dar+8) -#define REG_PPC m68ki_cpu.ppc -#define REG_PC m68ki_cpu.pc -#define REG_SP_BASE m68ki_cpu.sp -#define REG_USP m68ki_cpu.sp[0] -#define REG_ISP m68ki_cpu.sp[4] -#define REG_MSP m68ki_cpu.sp[6] -#define REG_SP m68ki_cpu.dar[15] -#define REG_VBR m68ki_cpu.vbr -#define REG_SFC m68ki_cpu.sfc -#define REG_DFC m68ki_cpu.dfc -#define REG_CACR m68ki_cpu.cacr -#define REG_CAAR m68ki_cpu.caar -#define REG_IR m68ki_cpu.ir - -#define FLAG_T1 m68ki_cpu.t1_flag -#define FLAG_T0 m68ki_cpu.t0_flag -#define FLAG_S m68ki_cpu.s_flag -#define FLAG_M m68ki_cpu.m_flag -#define FLAG_X m68ki_cpu.x_flag -#define FLAG_N m68ki_cpu.n_flag -#define FLAG_Z m68ki_cpu.not_z_flag -#define FLAG_V m68ki_cpu.v_flag -#define FLAG_C m68ki_cpu.c_flag -#define FLAG_INT_MASK m68ki_cpu.int_mask - -#define CPU_INT_LEVEL m68ki_cpu.int_level /* ASG: changed from CPU_INTS_PENDING */ -#define CPU_INT_CYCLES m68ki_cpu.int_cycles /* ASG */ -#define CPU_STOPPED m68ki_cpu.stopped -#define CPU_PREF_ADDR m68ki_cpu.pref_addr -#define CPU_PREF_DATA m68ki_cpu.pref_data -#define CPU_ADDRESS_MASK m68ki_cpu.address_mask -#define CPU_SR_MASK m68ki_cpu.sr_mask -#define CPU_INSTR_MODE m68ki_cpu.instr_mode -#define CPU_RUN_MODE m68ki_cpu.run_mode - -#define CYC_INSTRUCTION m68ki_cpu.cyc_instruction -#define CYC_EXCEPTION m68ki_cpu.cyc_exception -#define CYC_BCC_NOTAKE_B m68ki_cpu.cyc_bcc_notake_b -#define CYC_BCC_NOTAKE_W m68ki_cpu.cyc_bcc_notake_w -#define CYC_DBCC_F_NOEXP m68ki_cpu.cyc_dbcc_f_noexp -#define CYC_DBCC_F_EXP m68ki_cpu.cyc_dbcc_f_exp -#define CYC_SCC_R_FALSE m68ki_cpu.cyc_scc_r_false -#define CYC_MOVEM_W m68ki_cpu.cyc_movem_w -#define CYC_MOVEM_L m68ki_cpu.cyc_movem_l -#define CYC_SHIFT m68ki_cpu.cyc_shift -#define CYC_RESET m68ki_cpu.cyc_reset - - -#define CALLBACK_INT_ACK m68ki_cpu.int_ack_callback -#define CALLBACK_BKPT_ACK m68ki_cpu.bkpt_ack_callback -#define CALLBACK_RESET_INSTR m68ki_cpu.reset_instr_callback -#define CALLBACK_PC_CHANGED m68ki_cpu.pc_changed_callback -#define CALLBACK_SET_FC m68ki_cpu.set_fc_callback -#define CALLBACK_INSTR_HOOK m68ki_cpu.instr_hook_callback +#define CPU_TYPE cpu->cpu_type + +#define REG_DA cpu->dar /* easy access to data and address regs */ +#define REG_D cpu->dar +#define REG_A (cpu->dar+8) +#define REG_PPC cpu->ppc +#define REG_PC cpu->pc +#define REG_SP_BASE cpu->sp +#define REG_USP cpu->sp[0] +#define REG_ISP cpu->sp[4] +#define REG_MSP cpu->sp[6] +#define REG_SP cpu->dar[15] +#define REG_VBR cpu->vbr +#define REG_SFC cpu->sfc +#define REG_DFC cpu->dfc +#define REG_CACR cpu->cacr +#define REG_CAAR cpu->caar +#define REG_IR cpu->ir + +#define FLAG_T1 cpu->t1_flag +#define FLAG_T0 cpu->t0_flag +#define FLAG_S cpu->s_flag +#define FLAG_M cpu->m_flag +#define FLAG_X cpu->x_flag +#define FLAG_N cpu->n_flag +#define FLAG_Z cpu->not_z_flag +#define FLAG_V cpu->v_flag +#define FLAG_C cpu->c_flag +#define FLAG_INT_MASK cpu->int_mask + +#define CPU_INT_LEVEL cpu->int_level /* ASG: changed from CPU_INTS_PENDING */ +#define CPU_INT_CYCLES cpu->int_cycles /* ASG */ +#define CPU_STOPPED cpu->stopped +#define CPU_PREF_ADDR cpu->pref_addr +#define CPU_PREF_DATA cpu->pref_data +#define CPU_ADDRESS_MASK cpu->address_mask +#define CPU_SR_MASK cpu->sr_mask +#define CPU_INSTR_MODE cpu->instr_mode +#define CPU_RUN_MODE cpu->run_mode + +#define CYC_INSTRUCTION cpu->cyc_instruction +#define CYC_EXCEPTION cpu->cyc_exception +#define CYC_BCC_NOTAKE_B cpu->cyc_bcc_notake_b +#define CYC_BCC_NOTAKE_W cpu->cyc_bcc_notake_w +#define CYC_DBCC_F_NOEXP cpu->cyc_dbcc_f_noexp +#define CYC_DBCC_F_EXP cpu->cyc_dbcc_f_exp +#define CYC_SCC_R_FALSE cpu->cyc_scc_r_false +#define CYC_MOVEM_W cpu->cyc_movem_w +#define CYC_MOVEM_L cpu->cyc_movem_l +#define CYC_SHIFT cpu->cyc_shift +#define CYC_RESET cpu->cyc_reset + + +#define CALLBACK_INT_ACK cpu->int_ack_callback +#define CALLBACK_BKPT_ACK cpu->bkpt_ack_callback +#define CALLBACK_RESET_INSTR cpu->reset_instr_callback +#define CALLBACK_PC_CHANGED cpu->pc_changed_callback +#define CALLBACK_SET_FC cpu->set_fc_callback +#define CALLBACK_INSTR_HOOK cpu->instr_hook_callback @@ -419,13 +512,13 @@ /* Enable or disable callback functions */ #if M68K_EMULATE_INT_ACK #if M68K_EMULATE_INT_ACK == OPT_SPECIFY_HANDLER - #define m68ki_int_ack(A) M68K_INT_ACK_CALLBACK(A) + #define m68ki_int_ack(cpu, A) M68K_INT_ACK_CALLBACK(cpu, A) #else - #define m68ki_int_ack(A) CALLBACK_INT_ACK(A) + #define m68ki_int_ack(cpu, A) CALLBACK_INT_ACK(cpu, A) #endif #else /* Default action is to used autovector mode, which is most common */ - #define m68ki_int_ack(A) M68K_INT_ACK_AUTOVECTOR + #define m68ki_int_ack(cpu, A) M68K_INT_ACK_AUTOVECTOR #endif /* M68K_EMULATE_INT_ACK */ #if M68K_EMULATE_BKPT_ACK @@ -580,10 +673,10 @@ #define EA_AY_PD_8() (--AY) /* predecrement (size = byte) */ #define EA_AY_PD_16() (AY-=2) /* predecrement (size = word) */ #define EA_AY_PD_32() (AY-=4) /* predecrement (size = long) */ -#define EA_AY_DI_8() (AY+MAKE_INT_16(m68ki_read_imm_16())) /* displacement */ +#define EA_AY_DI_8() (AY+MAKE_INT_16(m68ki_read_imm_16(cpu))) /* displacement */ #define EA_AY_DI_16() EA_AY_DI_8() #define EA_AY_DI_32() EA_AY_DI_8() -#define EA_AY_IX_8() m68ki_get_ea_ix(AY) /* indirect + index */ +#define EA_AY_IX_8() m68ki_get_ea_ix(cpu, AY) /* indirect + index */ #define EA_AY_IX_16() EA_AY_IX_8() #define EA_AY_IX_32() EA_AY_IX_8() @@ -596,33 +689,33 @@ #define EA_AX_PD_8() (--AX) #define EA_AX_PD_16() (AX-=2) #define EA_AX_PD_32() (AX-=4) -#define EA_AX_DI_8() (AX+MAKE_INT_16(m68ki_read_imm_16())) +#define EA_AX_DI_8() (AX+MAKE_INT_16(m68ki_read_imm_16(cpu))) #define EA_AX_DI_16() EA_AX_DI_8() #define EA_AX_DI_32() EA_AX_DI_8() -#define EA_AX_IX_8() m68ki_get_ea_ix(AX) +#define EA_AX_IX_8() m68ki_get_ea_ix(cpu, AX) #define EA_AX_IX_16() EA_AX_IX_8() #define EA_AX_IX_32() EA_AX_IX_8() #define EA_A7_PI_8() ((REG_A[7]+=2)-2) #define EA_A7_PD_8() (REG_A[7]-=2) -#define EA_AW_8() MAKE_INT_16(m68ki_read_imm_16()) /* absolute word */ +#define EA_AW_8() MAKE_INT_16(m68ki_read_imm_16(cpu)) /* absolute word */ #define EA_AW_16() EA_AW_8() #define EA_AW_32() EA_AW_8() -#define EA_AL_8() m68ki_read_imm_32() /* absolute long */ +#define EA_AL_8() m68ki_read_imm_32(cpu) /* absolute long */ #define EA_AL_16() EA_AL_8() #define EA_AL_32() EA_AL_8() -#define EA_PCDI_8() m68ki_get_ea_pcdi() /* pc indirect + displacement */ +#define EA_PCDI_8() m68ki_get_ea_pcdi(cpu) /* pc indirect + displacement */ #define EA_PCDI_16() EA_PCDI_8() #define EA_PCDI_32() EA_PCDI_8() -#define EA_PCIX_8() m68ki_get_ea_pcix() /* pc indirect + index */ +#define EA_PCIX_8() m68ki_get_ea_pcix(cpu) /* pc indirect + index */ #define EA_PCIX_16() EA_PCIX_8() #define EA_PCIX_32() EA_PCIX_8() #define OPER_I_8() m68ki_read_imm_8() -#define OPER_I_16() m68ki_read_imm_16() -#define OPER_I_32() m68ki_read_imm_32() +#define OPER_I_16() m68ki_read_imm_16(cpu) +#define OPER_I_32() m68ki_read_imm_32(cpu) @@ -739,34 +832,34 @@ /* ---------------------------- Cycle Counting ---------------------------- */ -#define ADD_CYCLES(A) m68ki_remaining_cycles += (A) -#define USE_CYCLES(A) m68ki_remaining_cycles -= (A) -#define SET_CYCLES(A) m68ki_remaining_cycles = A -#define GET_CYCLES() m68ki_remaining_cycles -#define USE_ALL_CYCLES() m68ki_remaining_cycles = 0 +#define ADD_CYCLES(A) cpu->m68ki_remaining_cycles += (A) +#define USE_CYCLES(A) cpu->m68ki_remaining_cycles -= (A) +#define SET_CYCLES(A) cpu->m68ki_remaining_cycles = A +#define GET_CYCLES() cpu->m68ki_remaining_cycles +#define USE_ALL_CYCLES() cpu->m68ki_remaining_cycles = 0 /* ----------------------------- Read / Write ----------------------------- */ /* Read from the current address space */ -#define m68ki_read_8(A) m68ki_read_8_fc (A, FLAG_S | m68ki_get_address_space()) -#define m68ki_read_16(A) m68ki_read_16_fc(A, FLAG_S | m68ki_get_address_space()) -#define m68ki_read_32(A) m68ki_read_32_fc(A, FLAG_S | m68ki_get_address_space()) +#define m68ki_read_8(A) m68ki_read_8_fc (cpu, A, FLAG_S | m68ki_get_address_space()) +#define m68ki_read_16(A) m68ki_read_16_fc(cpu, A, FLAG_S | m68ki_get_address_space()) +#define m68ki_read_32(A) m68ki_read_32_fc(cpu, A, FLAG_S | m68ki_get_address_space()) /* Write to the current data space */ -#define m68ki_write_8(A, V) m68ki_write_8_fc (A, FLAG_S | FUNCTION_CODE_USER_DATA, V) -#define m68ki_write_16(A, V) m68ki_write_16_fc(A, FLAG_S | FUNCTION_CODE_USER_DATA, V) -#define m68ki_write_32(A, V) m68ki_write_32_fc(A, FLAG_S | FUNCTION_CODE_USER_DATA, V) +#define m68ki_write_8(A, V) m68ki_write_8_fc (cpu, A, FLAG_S | FUNCTION_CODE_USER_DATA, V) +#define m68ki_write_16(A, V) m68ki_write_16_fc(cpu, A, FLAG_S | FUNCTION_CODE_USER_DATA, V) +#define m68ki_write_32(A, V) m68ki_write_32_fc(cpu, A, FLAG_S | FUNCTION_CODE_USER_DATA, V) #if M68K_SIMULATE_PD_WRITES -#define m68ki_write_32_pd(A, V) m68ki_write_32_pd_fc(A, FLAG_S | FUNCTION_CODE_USER_DATA, V) +#define m68ki_write_32_pd(A, V) m68ki_write_32_pd_fc(cpu, A, FLAG_S | FUNCTION_CODE_USER_DATA, V) #else -#define m68ki_write_32_pd(A, V) m68ki_write_32_fc(A, FLAG_S | FUNCTION_CODE_USER_DATA, V) +#define m68ki_write_32_pd(A, V) m68ki_write_32_fc(cpu, A, FLAG_S | FUNCTION_CODE_USER_DATA, V) #endif /* map read immediate 8 to read immediate 16 */ -#define m68ki_read_imm_8() MASK_OUT_ABOVE_8(m68ki_read_imm_16()) +#define m68ki_read_imm_8() MASK_OUT_ABOVE_8(m68ki_read_imm_16(cpu)) /* Map PC-relative reads */ #define m68ki_read_pcrel_8(A) m68k_read_pcrelative_8(A) @@ -774,207 +867,130 @@ #define m68ki_read_pcrel_32(A) m68k_read_pcrelative_32(A) /* Read from the program space */ -#define m68ki_read_program_8(A) m68ki_read_8_fc(A, FLAG_S | FUNCTION_CODE_USER_PROGRAM) -#define m68ki_read_program_16(A) m68ki_read_16_fc(A, FLAG_S | FUNCTION_CODE_USER_PROGRAM) -#define m68ki_read_program_32(A) m68ki_read_32_fc(A, FLAG_S | FUNCTION_CODE_USER_PROGRAM) +#define m68ki_read_program_8(A) m68ki_read_8_fc(cpu, A, FLAG_S | FUNCTION_CODE_USER_PROGRAM) +#define m68ki_read_program_16(A) m68ki_read_16_fc(cpu, A, FLAG_S | FUNCTION_CODE_USER_PROGRAM) +#define m68ki_read_program_32(A) m68ki_read_32_fc(cpu, A, FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* Read from the data space */ -#define m68ki_read_data_8(A) m68ki_read_8_fc(A, FLAG_S | FUNCTION_CODE_USER_DATA) -#define m68ki_read_data_16(A) m68ki_read_16_fc(A, FLAG_S | FUNCTION_CODE_USER_DATA) -#define m68ki_read_data_32(A) m68ki_read_32_fc(A, FLAG_S | FUNCTION_CODE_USER_DATA) - - - -/* ======================================================================== */ -/* =============================== PROTOTYPES ============================= */ -/* ======================================================================== */ - -typedef struct -{ - uint cpu_type; /* CPU Type: 68000, 68010, 68EC020, or 68020 */ - uint dar[16]; /* Data and Address Registers */ - uint ppc; /* Previous program counter */ - uint pc; /* Program Counter */ - uint sp[7]; /* User, Interrupt, and Master Stack Pointers */ - uint vbr; /* Vector Base Register (m68010+) */ - uint sfc; /* Source Function Code Register (m68010+) */ - uint dfc; /* Destination Function Code Register (m68010+) */ - uint cacr; /* Cache Control Register (m68020, unemulated) */ - uint caar; /* Cache Address Register (m68020, unemulated) */ - uint ir; /* Instruction Register */ - uint t1_flag; /* Trace 1 */ - uint t0_flag; /* Trace 0 */ - uint s_flag; /* Supervisor */ - uint m_flag; /* Master/Interrupt state */ - uint x_flag; /* Extend */ - uint n_flag; /* Negative */ - uint not_z_flag; /* Zero, inverted for speedups */ - uint v_flag; /* Overflow */ - uint c_flag; /* Carry */ - uint int_mask; /* I0-I2 */ - uint int_level; /* State of interrupt pins IPL0-IPL2 -- ASG: changed from ints_pending */ - uint int_cycles; /* ASG: extra cycles from generated interrupts */ - uint stopped; /* Stopped state */ - uint pref_addr; /* Last prefetch address */ - uint pref_data; /* Data in the prefetch queue */ - uint address_mask; /* Available address pins */ - uint sr_mask; /* Implemented status register bits */ - uint instr_mode; /* Stores whether we are in instruction mode or group 0/1 exception mode */ - uint run_mode; /* Stores whether we are processing a reset, bus error, address error, or something else */ - - /* Clocks required for instructions / exceptions */ - uint cyc_bcc_notake_b; - uint cyc_bcc_notake_w; - uint cyc_dbcc_f_noexp; - uint cyc_dbcc_f_exp; - uint cyc_scc_r_false; - uint cyc_movem_w; - uint cyc_movem_l; - uint cyc_shift; - uint cyc_reset; - uint8* cyc_instruction; - uint8* cyc_exception; - - /* Callbacks to host */ - int (*int_ack_callback)(int int_line); /* Interrupt Acknowledge */ - void (*bkpt_ack_callback)(unsigned int data); /* Breakpoint Acknowledge */ - void (*reset_instr_callback)(void); /* Called when a RESET instruction is encountered */ - 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)(void); /* Called every instruction cycle prior to execution */ - -} m68ki_cpu_core; - - -extern m68ki_cpu_core m68ki_cpu; -extern sint m68ki_remaining_cycles; -extern uint m68ki_tracing; -extern uint8 m68ki_shift_8_table[]; -extern uint16 m68ki_shift_16_table[]; -extern uint m68ki_shift_32_table[]; -extern uint8 m68ki_exception_cycle_table[][256]; -extern uint m68ki_address_space; -extern uint8 m68ki_ea_idx_cycle_table[]; - -extern uint m68ki_aerr_address; -extern uint m68ki_aerr_write_mode; -extern uint m68ki_aerr_fc; +#define m68ki_read_data_8(A) m68ki_read_8_fc(cpu, A, FLAG_S | FUNCTION_CODE_USER_DATA) +#define m68ki_read_data_16(A) m68ki_read_16_fc(cpu, A, FLAG_S | FUNCTION_CODE_USER_DATA) +#define m68ki_read_data_32(A) m68ki_read_32_fc(cpu, A, FLAG_S | FUNCTION_CODE_USER_DATA) /* Read data immediately after the program counter */ -INLINE uint m68ki_read_imm_16(void); -INLINE uint m68ki_read_imm_32(void); +INLINE uint m68ki_read_imm_16(m68ki_cpu_core *cpu); +INLINE uint m68ki_read_imm_32(m68ki_cpu_core *cpu); /* Read data with specific function code */ -INLINE uint m68ki_read_8_fc (uint address, uint fc); -INLINE uint m68ki_read_16_fc (uint address, uint fc); -INLINE uint m68ki_read_32_fc (uint address, uint fc); +INLINE uint m68ki_read_8_fc (m68ki_cpu_core *cpu, uint address, uint fc); +INLINE uint m68ki_read_16_fc (m68ki_cpu_core *cpu, uint address, uint fc); +INLINE uint m68ki_read_32_fc (m68ki_cpu_core *cpu, uint address, uint fc); /* Write data with specific function code */ -INLINE void m68ki_write_8_fc (uint address, uint fc, uint value); -INLINE void m68ki_write_16_fc(uint address, uint fc, uint value); -INLINE void m68ki_write_32_fc(uint address, uint fc, uint value); +INLINE void m68ki_write_8_fc (m68ki_cpu_core *cpu, uint address, uint fc, uint value); +INLINE void m68ki_write_16_fc(m68ki_cpu_core *cpu, uint address, uint fc, uint value); +INLINE void m68ki_write_32_fc(m68ki_cpu_core *cpu, uint address, uint fc, uint value); #if M68K_SIMULATE_PD_WRITES -INLINE void m68ki_write_32_pd_fc(uint address, uint fc, uint value); +INLINE void m68ki_write_32_pd_fc(m68ki_cpu_core *cpu, uint address, uint fc, uint value); #endif /* M68K_SIMULATE_PD_WRITES */ /* Indexed and PC-relative ea fetching */ -INLINE uint m68ki_get_ea_pcdi(void); -INLINE uint m68ki_get_ea_pcix(void); -INLINE uint m68ki_get_ea_ix(uint An); +INLINE uint m68ki_get_ea_pcdi(m68ki_cpu_core *cpu); +INLINE uint m68ki_get_ea_pcix(m68ki_cpu_core *cpu); +INLINE uint m68ki_get_ea_ix(m68ki_cpu_core *cpu, uint An); /* Operand fetching */ -INLINE uint OPER_AY_AI_8(void); -INLINE uint OPER_AY_AI_16(void); -INLINE uint OPER_AY_AI_32(void); -INLINE uint OPER_AY_PI_8(void); -INLINE uint OPER_AY_PI_16(void); -INLINE uint OPER_AY_PI_32(void); -INLINE uint OPER_AY_PD_8(void); -INLINE uint OPER_AY_PD_16(void); -INLINE uint OPER_AY_PD_32(void); -INLINE uint OPER_AY_DI_8(void); -INLINE uint OPER_AY_DI_16(void); -INLINE uint OPER_AY_DI_32(void); -INLINE uint OPER_AY_IX_8(void); -INLINE uint OPER_AY_IX_16(void); -INLINE uint OPER_AY_IX_32(void); - -INLINE uint OPER_AX_AI_8(void); -INLINE uint OPER_AX_AI_16(void); -INLINE uint OPER_AX_AI_32(void); -INLINE uint OPER_AX_PI_8(void); -INLINE uint OPER_AX_PI_16(void); -INLINE uint OPER_AX_PI_32(void); -INLINE uint OPER_AX_PD_8(void); -INLINE uint OPER_AX_PD_16(void); -INLINE uint OPER_AX_PD_32(void); -INLINE uint OPER_AX_DI_8(void); -INLINE uint OPER_AX_DI_16(void); -INLINE uint OPER_AX_DI_32(void); -INLINE uint OPER_AX_IX_8(void); -INLINE uint OPER_AX_IX_16(void); -INLINE uint OPER_AX_IX_32(void); - -INLINE uint OPER_A7_PI_8(void); -INLINE uint OPER_A7_PD_8(void); - -INLINE uint OPER_AW_8(void); -INLINE uint OPER_AW_16(void); -INLINE uint OPER_AW_32(void); -INLINE uint OPER_AL_8(void); -INLINE uint OPER_AL_16(void); -INLINE uint OPER_AL_32(void); -INLINE uint OPER_PCDI_8(void); -INLINE uint OPER_PCDI_16(void); -INLINE uint OPER_PCDI_32(void); -INLINE uint OPER_PCIX_8(void); -INLINE uint OPER_PCIX_16(void); -INLINE uint OPER_PCIX_32(void); +INLINE uint OPER_AY_AI_8(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_AI_16(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_AI_32(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_PI_8(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_PI_16(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_PI_32(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_PD_8(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_PD_16(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_PD_32(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_DI_8(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_DI_16(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_DI_32(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_IX_8(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_IX_16(m68ki_cpu_core *cpu); +INLINE uint OPER_AY_IX_32(m68ki_cpu_core *cpu); + +INLINE uint OPER_AX_AI_8(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_AI_16(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_AI_32(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_PI_8(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_PI_16(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_PI_32(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_PD_8(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_PD_16(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_PD_32(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_DI_8(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_DI_16(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_DI_32(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_IX_8(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_IX_16(m68ki_cpu_core *cpu); +INLINE uint OPER_AX_IX_32(m68ki_cpu_core *cpu); + +INLINE uint OPER_A7_PI_8(m68ki_cpu_core *cpu); +INLINE uint OPER_A7_PD_8(m68ki_cpu_core *cpu); + +INLINE uint OPER_AW_8(m68ki_cpu_core *cpu); +INLINE uint OPER_AW_16(m68ki_cpu_core *cpu); +INLINE uint OPER_AW_32(m68ki_cpu_core *cpu); +INLINE uint OPER_AL_8(m68ki_cpu_core *cpu); +INLINE uint OPER_AL_16(m68ki_cpu_core *cpu); +INLINE uint OPER_AL_32(m68ki_cpu_core *cpu); +INLINE uint OPER_PCDI_8(m68ki_cpu_core *cpu); +INLINE uint OPER_PCDI_16(m68ki_cpu_core *cpu); +INLINE uint OPER_PCDI_32(m68ki_cpu_core *cpu); +INLINE uint OPER_PCIX_8(m68ki_cpu_core *cpu); +INLINE uint OPER_PCIX_16(m68ki_cpu_core *cpu); +INLINE uint OPER_PCIX_32(m68ki_cpu_core *cpu); /* Stack operations */ -INLINE void m68ki_push_16(uint value); -INLINE void m68ki_push_32(uint value); -INLINE uint m68ki_pull_16(void); -INLINE uint m68ki_pull_32(void); +INLINE void m68ki_push_16(m68ki_cpu_core *cpu, uint value); +INLINE void m68ki_push_32(m68ki_cpu_core *cpu, uint value); +INLINE uint m68ki_pull_16(m68ki_cpu_core *cpu); +INLINE uint m68ki_pull_32(m68ki_cpu_core *cpu); /* Program flow operations */ -INLINE void m68ki_jump(uint new_pc); -INLINE void m68ki_jump_vector(uint vector); -INLINE void m68ki_branch_8(uint offset); -INLINE void m68ki_branch_16(uint offset); -INLINE void m68ki_branch_32(uint offset); +INLINE void m68ki_jump(m68ki_cpu_core *cpu, uint new_pc); +INLINE void m68ki_jump_vector(m68ki_cpu_core *cpu, uint vector); +INLINE void m68ki_branch_8(m68ki_cpu_core *cpu, uint offset); +INLINE void m68ki_branch_16(m68ki_cpu_core *cpu, uint offset); +INLINE void m68ki_branch_32(m68ki_cpu_core *cpu, uint offset); /* Status register operations. */ -INLINE void m68ki_set_s_flag(uint value); /* Only bit 2 of value should be set (i.e. 4 or 0) */ -INLINE void m68ki_set_sm_flag(uint value); /* only bits 1 and 2 of value should be set */ -INLINE void m68ki_set_ccr(uint value); /* set the condition code register */ -INLINE void m68ki_set_sr(uint value); /* set the status register */ -INLINE void m68ki_set_sr_noint(uint value); /* set the status register */ +INLINE void m68ki_set_s_flag(m68ki_cpu_core *cpu, uint value); /* Only bit 2 of value should be set (i.e. 4 or 0) */ +INLINE void m68ki_set_sm_flag(m68ki_cpu_core *cpu, uint value); /* only bits 1 and 2 of value should be set */ +INLINE void m68ki_set_ccr(m68ki_cpu_core *cpu, uint value); /* set the condition code register */ +INLINE void m68ki_set_sr(m68ki_cpu_core *cpu, uint value); /* set the status register */ +INLINE void m68ki_set_sr_noint(m68ki_cpu_core *cpu, uint value); /* set the status register */ /* Exception processing */ -INLINE uint m68ki_init_exception(void); /* Initial exception processing */ - -INLINE void m68ki_stack_frame_3word(uint pc, uint sr); /* Stack various frame types */ -INLINE void m68ki_stack_frame_buserr(uint sr); - -INLINE void m68ki_stack_frame_0000(uint pc, uint sr, uint vector); -INLINE void m68ki_stack_frame_0001(uint pc, uint sr, uint vector); -INLINE void m68ki_stack_frame_0010(uint sr, uint vector); -INLINE void m68ki_stack_frame_1000(uint pc, uint sr, uint vector); -INLINE void m68ki_stack_frame_1010(uint sr, uint vector, uint pc); -INLINE void m68ki_stack_frame_1011(uint sr, uint vector, uint pc); - -INLINE void m68ki_exception_trap(uint vector); -INLINE void m68ki_exception_trapN(uint vector); -INLINE void m68ki_exception_trace(void); -INLINE void m68ki_exception_privilege_violation(void); -INLINE void m68ki_exception_1010(void); -INLINE void m68ki_exception_1111(void); -INLINE void m68ki_exception_illegal(void); -INLINE void m68ki_exception_format_error(void); -INLINE void m68ki_exception_address_error(void); -INLINE void m68ki_exception_interrupt(uint int_level); -INLINE void m68ki_check_interrupts(void); /* ASG: check for interrupts */ +INLINE uint m68ki_init_exception(m68ki_cpu_core *cpu); /* Initial exception processing */ + +INLINE void m68ki_stack_frame_3word(m68ki_cpu_core *cpu, uint pc, uint sr); /* Stack various frame types */ +INLINE void m68ki_stack_frame_buserr(m68ki_cpu_core *cpu, uint sr); + +INLINE void m68ki_stack_frame_0000(m68ki_cpu_core *cpu, uint pc, uint sr, uint vector); +INLINE void m68ki_stack_frame_0001(m68ki_cpu_core *cpu, uint pc, uint sr, uint vector); +INLINE void m68ki_stack_frame_0010(m68ki_cpu_core *cpu, uint sr, uint vector); +INLINE void m68ki_stack_frame_1000(m68ki_cpu_core *cpu, uint pc, uint sr, uint vector); +INLINE void m68ki_stack_frame_1010(m68ki_cpu_core *cpu, uint sr, uint vector, uint pc); +INLINE void m68ki_stack_frame_1011(m68ki_cpu_core *cpu, uint sr, uint vector, uint pc); + +INLINE void m68ki_exception_trap(m68ki_cpu_core *cpu, uint vector); +INLINE void m68ki_exception_trapN(m68ki_cpu_core *cpu, uint vector); +INLINE void m68ki_exception_trace(m68ki_cpu_core *cpu); +INLINE void m68ki_exception_privilege_violation(m68ki_cpu_core *cpu); +INLINE void m68ki_exception_1010(m68ki_cpu_core *cpu); +INLINE void m68ki_exception_1111(m68ki_cpu_core *cpu); +INLINE void m68ki_exception_illegal(m68ki_cpu_core *cpu); +INLINE void m68ki_exception_format_error(m68ki_cpu_core *cpu); +INLINE void m68ki_exception_address_error(m68ki_cpu_core *cpu); +INLINE void m68ki_exception_interrupt(m68ki_cpu_core *cpu, uint int_level); +INLINE void m68ki_check_interrupts(m68ki_cpu_core *cpu); /* ASG: check for interrupts */ /* quick disassembly (used for logging) */ char* m68ki_disassemble_quick(unsigned int pc, unsigned int cpu_type); @@ -990,7 +1006,7 @@ char* m68ki_disassemble_quick(unsigned int pc, unsigned int cpu_type); /* Handles all immediate reads, does address error check, function code setting, * and prefetching if they are enabled in m68kconf.h */ -INLINE uint m68ki_read_imm_16(void) +INLINE uint m68ki_read_imm_16(m68ki_cpu_core *cpu) { m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */ m68ki_check_address_error(REG_PC, MODE_READ, FLAG_S | FUNCTION_CODE_USER_PROGRAM); /* auto-disable (see m68kcpu.h) */ @@ -1007,7 +1023,7 @@ INLINE uint m68ki_read_imm_16(void) return m68k_read_immediate_16(ADDRESS_68K(REG_PC-2)); #endif /* M68K_EMULATE_PREFETCH */ } -INLINE uint m68ki_read_imm_32(void) +INLINE uint m68ki_read_imm_32(m68ki_cpu_core *cpu) { #if M68K_EMULATE_PREFETCH uint temp_val; @@ -1048,44 +1064,44 @@ INLINE uint m68ki_read_imm_32(void) * These functions will also check for address error and set the function * code if they are enabled in m68kconf.h. */ -INLINE uint m68ki_read_8_fc(uint address, uint fc) +INLINE uint m68ki_read_8_fc(m68ki_cpu_core *cpu, uint address, uint fc) { m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */ - return m68k_read_memory_8(ADDRESS_68K(address)); + return m68k_read_memory_8(cpu, ADDRESS_68K(address)); } -INLINE uint m68ki_read_16_fc(uint address, uint fc) +INLINE uint m68ki_read_16_fc(m68ki_cpu_core *cpu, uint address, uint fc) { m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */ m68ki_check_address_error(address, MODE_READ, fc); /* auto-disable (see m68kcpu.h) */ - return m68k_read_memory_16(ADDRESS_68K(address)); + return m68k_read_memory_16(cpu, ADDRESS_68K(address)); } -INLINE uint m68ki_read_32_fc(uint address, uint fc) +INLINE uint m68ki_read_32_fc(m68ki_cpu_core *cpu, uint address, uint fc) { m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */ m68ki_check_address_error(address, MODE_READ, fc); /* auto-disable (see m68kcpu.h) */ - return m68k_read_memory_32(ADDRESS_68K(address)); + return m68k_read_memory_32(cpu, ADDRESS_68K(address)); } -INLINE void m68ki_write_8_fc(uint address, uint fc, uint value) +INLINE void m68ki_write_8_fc(m68ki_cpu_core *cpu, uint address, uint fc, uint value) { m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */ - m68k_write_memory_8(ADDRESS_68K(address), value); + m68k_write_memory_8(cpu, ADDRESS_68K(address), value); } -INLINE void m68ki_write_16_fc(uint address, uint fc, uint value) +INLINE void m68ki_write_16_fc(m68ki_cpu_core *cpu, uint address, uint fc, uint value) { m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */ m68ki_check_address_error(address, MODE_WRITE, fc); /* auto-disable (see m68kcpu.h) */ - m68k_write_memory_16(ADDRESS_68K(address), value); + m68k_write_memory_16(cpu, ADDRESS_68K(address), value); } -INLINE void m68ki_write_32_fc(uint address, uint fc, uint value) +INLINE void m68ki_write_32_fc(m68ki_cpu_core *cpu, uint address, uint fc, uint value) { m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */ m68ki_check_address_error(address, MODE_WRITE, fc); /* auto-disable (see m68kcpu.h) */ - m68k_write_memory_32(ADDRESS_68K(address), value); + m68k_write_memory_32(cpu, ADDRESS_68K(address), value); } #if M68K_SIMULATE_PD_WRITES -INLINE void m68ki_write_32_pd_fc(uint address, uint fc, uint value) +INLINE void m68ki_write_32_pd_fc(m68ki_cpu_core *cpu, uint address, uint fc, uint value) { m68ki_set_fc(fc); /* auto-disable (see m68kcpu.h) */ m68ki_check_address_error(address, MODE_WRITE, fc); /* auto-disable (see m68kcpu.h) */ @@ -1099,18 +1115,18 @@ INLINE void m68ki_write_32_pd_fc(uint address, uint fc, uint value) /* The program counter relative addressing modes cause operands to be * retrieved from program space, not data space. */ -INLINE uint m68ki_get_ea_pcdi(void) +INLINE uint m68ki_get_ea_pcdi(m68ki_cpu_core *cpu) { uint old_pc = REG_PC; m68ki_use_program_space(); /* auto-disable */ - return old_pc + MAKE_INT_16(m68ki_read_imm_16()); + return old_pc + MAKE_INT_16(m68ki_read_imm_16(cpu)); } -INLINE uint m68ki_get_ea_pcix(void) +INLINE uint m68ki_get_ea_pcix(m68ki_cpu_core *cpu) { m68ki_use_program_space(); /* auto-disable */ - return m68ki_get_ea_ix(REG_PC); + return m68ki_get_ea_ix(cpu, REG_PC); } /* Indexed addressing modes are encoded as follows: @@ -1155,10 +1171,10 @@ INLINE uint m68ki_get_ea_pcix(void) * 1 011 mem indir with long outer * 1 100-111 reserved */ -INLINE uint m68ki_get_ea_ix(uint An) +INLINE uint m68ki_get_ea_ix(m68ki_cpu_core *cpu, uint An) { /* An = base register */ - uint extension = m68ki_read_imm_16(); + uint extension = m68ki_read_imm_16(cpu); uint Xn = 0; /* Index register */ uint bd = 0; /* Base Displacement */ uint od = 0; /* Outer Displacement */ @@ -1208,7 +1224,7 @@ INLINE uint m68ki_get_ea_ix(uint An) /* Check if base displacement is present */ if(BIT_5(extension)) /* BD SIZE */ - bd = BIT_4(extension) ? m68ki_read_imm_32() : MAKE_INT_16(m68ki_read_imm_16()); + bd = BIT_4(extension) ? m68ki_read_imm_32(cpu) : MAKE_INT_16(m68ki_read_imm_16(cpu)); /* If no indirect action, we are done */ if(!(extension&7)) /* No Memory Indirect */ @@ -1216,7 +1232,7 @@ INLINE uint m68ki_get_ea_ix(uint An) /* Check if outer displacement is present */ if(BIT_1(extension)) /* I/IS: od */ - od = BIT_0(extension) ? m68ki_read_imm_32() : MAKE_INT_16(m68ki_read_imm_16()); + od = BIT_0(extension) ? m68ki_read_imm_32(cpu) : MAKE_INT_16(m68ki_read_imm_16(cpu)); /* Postindex */ if(BIT_2(extension)) /* I/IS: 0 = preindex, 1 = postindex */ @@ -1228,78 +1244,78 @@ INLINE uint m68ki_get_ea_ix(uint An) /* Fetch operands */ -INLINE uint OPER_AY_AI_8(void) {uint ea = EA_AY_AI_8(); return m68ki_read_8(ea); } -INLINE uint OPER_AY_AI_16(void) {uint ea = EA_AY_AI_16(); return m68ki_read_16(ea);} -INLINE uint OPER_AY_AI_32(void) {uint ea = EA_AY_AI_32(); return m68ki_read_32(ea);} -INLINE uint OPER_AY_PI_8(void) {uint ea = EA_AY_PI_8(); return m68ki_read_8(ea); } -INLINE uint OPER_AY_PI_16(void) {uint ea = EA_AY_PI_16(); return m68ki_read_16(ea);} -INLINE uint OPER_AY_PI_32(void) {uint ea = EA_AY_PI_32(); return m68ki_read_32(ea);} -INLINE uint OPER_AY_PD_8(void) {uint ea = EA_AY_PD_8(); return m68ki_read_8(ea); } -INLINE uint OPER_AY_PD_16(void) {uint ea = EA_AY_PD_16(); return m68ki_read_16(ea);} -INLINE uint OPER_AY_PD_32(void) {uint ea = EA_AY_PD_32(); return m68ki_read_32(ea);} -INLINE uint OPER_AY_DI_8(void) {uint ea = EA_AY_DI_8(); return m68ki_read_8(ea); } -INLINE uint OPER_AY_DI_16(void) {uint ea = EA_AY_DI_16(); return m68ki_read_16(ea);} -INLINE uint OPER_AY_DI_32(void) {uint ea = EA_AY_DI_32(); return m68ki_read_32(ea);} -INLINE uint OPER_AY_IX_8(void) {uint ea = EA_AY_IX_8(); return m68ki_read_8(ea); } -INLINE uint OPER_AY_IX_16(void) {uint ea = EA_AY_IX_16(); return m68ki_read_16(ea);} -INLINE uint OPER_AY_IX_32(void) {uint ea = EA_AY_IX_32(); return m68ki_read_32(ea);} - -INLINE uint OPER_AX_AI_8(void) {uint ea = EA_AX_AI_8(); return m68ki_read_8(ea); } -INLINE uint OPER_AX_AI_16(void) {uint ea = EA_AX_AI_16(); return m68ki_read_16(ea);} -INLINE uint OPER_AX_AI_32(void) {uint ea = EA_AX_AI_32(); return m68ki_read_32(ea);} -INLINE uint OPER_AX_PI_8(void) {uint ea = EA_AX_PI_8(); return m68ki_read_8(ea); } -INLINE uint OPER_AX_PI_16(void) {uint ea = EA_AX_PI_16(); return m68ki_read_16(ea);} -INLINE uint OPER_AX_PI_32(void) {uint ea = EA_AX_PI_32(); return m68ki_read_32(ea);} -INLINE uint OPER_AX_PD_8(void) {uint ea = EA_AX_PD_8(); return m68ki_read_8(ea); } -INLINE uint OPER_AX_PD_16(void) {uint ea = EA_AX_PD_16(); return m68ki_read_16(ea);} -INLINE uint OPER_AX_PD_32(void) {uint ea = EA_AX_PD_32(); return m68ki_read_32(ea);} -INLINE uint OPER_AX_DI_8(void) {uint ea = EA_AX_DI_8(); return m68ki_read_8(ea); } -INLINE uint OPER_AX_DI_16(void) {uint ea = EA_AX_DI_16(); return m68ki_read_16(ea);} -INLINE uint OPER_AX_DI_32(void) {uint ea = EA_AX_DI_32(); return m68ki_read_32(ea);} -INLINE uint OPER_AX_IX_8(void) {uint ea = EA_AX_IX_8(); return m68ki_read_8(ea); } -INLINE uint OPER_AX_IX_16(void) {uint ea = EA_AX_IX_16(); return m68ki_read_16(ea);} -INLINE uint OPER_AX_IX_32(void) {uint ea = EA_AX_IX_32(); return m68ki_read_32(ea);} - -INLINE uint OPER_A7_PI_8(void) {uint ea = EA_A7_PI_8(); return m68ki_read_8(ea); } -INLINE uint OPER_A7_PD_8(void) {uint ea = EA_A7_PD_8(); return m68ki_read_8(ea); } - -INLINE uint OPER_AW_8(void) {uint ea = EA_AW_8(); return m68ki_read_8(ea); } -INLINE uint OPER_AW_16(void) {uint ea = EA_AW_16(); return m68ki_read_16(ea);} -INLINE uint OPER_AW_32(void) {uint ea = EA_AW_32(); return m68ki_read_32(ea);} -INLINE uint OPER_AL_8(void) {uint ea = EA_AL_8(); return m68ki_read_8(ea); } -INLINE uint OPER_AL_16(void) {uint ea = EA_AL_16(); return m68ki_read_16(ea);} -INLINE uint OPER_AL_32(void) {uint ea = EA_AL_32(); return m68ki_read_32(ea);} -INLINE uint OPER_PCDI_8(void) {uint ea = EA_PCDI_8(); return m68ki_read_pcrel_8(ea); } -INLINE uint OPER_PCDI_16(void) {uint ea = EA_PCDI_16(); return m68ki_read_pcrel_16(ea);} -INLINE uint OPER_PCDI_32(void) {uint ea = EA_PCDI_32(); return m68ki_read_pcrel_32(ea);} -INLINE uint OPER_PCIX_8(void) {uint ea = EA_PCIX_8(); return m68ki_read_pcrel_8(ea); } -INLINE uint OPER_PCIX_16(void) {uint ea = EA_PCIX_16(); return m68ki_read_pcrel_16(ea);} -INLINE uint OPER_PCIX_32(void) {uint ea = EA_PCIX_32(); return m68ki_read_pcrel_32(ea);} +INLINE uint OPER_AY_AI_8(m68ki_cpu_core *cpu) {uint ea = EA_AY_AI_8(); return m68ki_read_8(ea); } +INLINE uint OPER_AY_AI_16(m68ki_cpu_core *cpu) {uint ea = EA_AY_AI_16(); return m68ki_read_16(ea);} +INLINE uint OPER_AY_AI_32(m68ki_cpu_core *cpu) {uint ea = EA_AY_AI_32(); return m68ki_read_32(ea);} +INLINE uint OPER_AY_PI_8(m68ki_cpu_core *cpu) {uint ea = EA_AY_PI_8(); return m68ki_read_8(ea); } +INLINE uint OPER_AY_PI_16(m68ki_cpu_core *cpu) {uint ea = EA_AY_PI_16(); return m68ki_read_16(ea);} +INLINE uint OPER_AY_PI_32(m68ki_cpu_core *cpu) {uint ea = EA_AY_PI_32(); return m68ki_read_32(ea);} +INLINE uint OPER_AY_PD_8(m68ki_cpu_core *cpu) {uint ea = EA_AY_PD_8(); return m68ki_read_8(ea); } +INLINE uint OPER_AY_PD_16(m68ki_cpu_core *cpu) {uint ea = EA_AY_PD_16(); return m68ki_read_16(ea);} +INLINE uint OPER_AY_PD_32(m68ki_cpu_core *cpu) {uint ea = EA_AY_PD_32(); return m68ki_read_32(ea);} +INLINE uint OPER_AY_DI_8(m68ki_cpu_core *cpu) {uint ea = EA_AY_DI_8(); return m68ki_read_8(ea); } +INLINE uint OPER_AY_DI_16(m68ki_cpu_core *cpu) {uint ea = EA_AY_DI_16(); return m68ki_read_16(ea);} +INLINE uint OPER_AY_DI_32(m68ki_cpu_core *cpu) {uint ea = EA_AY_DI_32(); return m68ki_read_32(ea);} +INLINE uint OPER_AY_IX_8(m68ki_cpu_core *cpu) {uint ea = EA_AY_IX_8(); return m68ki_read_8(ea); } +INLINE uint OPER_AY_IX_16(m68ki_cpu_core *cpu) {uint ea = EA_AY_IX_16(); return m68ki_read_16(ea);} +INLINE uint OPER_AY_IX_32(m68ki_cpu_core *cpu) {uint ea = EA_AY_IX_32(); return m68ki_read_32(ea);} + +INLINE uint OPER_AX_AI_8(m68ki_cpu_core *cpu) {uint ea = EA_AX_AI_8(); return m68ki_read_8(ea); } +INLINE uint OPER_AX_AI_16(m68ki_cpu_core *cpu) {uint ea = EA_AX_AI_16(); return m68ki_read_16(ea);} +INLINE uint OPER_AX_AI_32(m68ki_cpu_core *cpu) {uint ea = EA_AX_AI_32(); return m68ki_read_32(ea);} +INLINE uint OPER_AX_PI_8(m68ki_cpu_core *cpu) {uint ea = EA_AX_PI_8(); return m68ki_read_8(ea); } +INLINE uint OPER_AX_PI_16(m68ki_cpu_core *cpu) {uint ea = EA_AX_PI_16(); return m68ki_read_16(ea);} +INLINE uint OPER_AX_PI_32(m68ki_cpu_core *cpu) {uint ea = EA_AX_PI_32(); return m68ki_read_32(ea);} +INLINE uint OPER_AX_PD_8(m68ki_cpu_core *cpu) {uint ea = EA_AX_PD_8(); return m68ki_read_8(ea); } +INLINE uint OPER_AX_PD_16(m68ki_cpu_core *cpu) {uint ea = EA_AX_PD_16(); return m68ki_read_16(ea);} +INLINE uint OPER_AX_PD_32(m68ki_cpu_core *cpu) {uint ea = EA_AX_PD_32(); return m68ki_read_32(ea);} +INLINE uint OPER_AX_DI_8(m68ki_cpu_core *cpu) {uint ea = EA_AX_DI_8(); return m68ki_read_8(ea); } +INLINE uint OPER_AX_DI_16(m68ki_cpu_core *cpu) {uint ea = EA_AX_DI_16(); return m68ki_read_16(ea);} +INLINE uint OPER_AX_DI_32(m68ki_cpu_core *cpu) {uint ea = EA_AX_DI_32(); return m68ki_read_32(ea);} +INLINE uint OPER_AX_IX_8(m68ki_cpu_core *cpu) {uint ea = EA_AX_IX_8(); return m68ki_read_8(ea); } +INLINE uint OPER_AX_IX_16(m68ki_cpu_core *cpu) {uint ea = EA_AX_IX_16(); return m68ki_read_16(ea);} +INLINE uint OPER_AX_IX_32(m68ki_cpu_core *cpu) {uint ea = EA_AX_IX_32(); return m68ki_read_32(ea);} + +INLINE uint OPER_A7_PI_8(m68ki_cpu_core *cpu) {uint ea = EA_A7_PI_8(); return m68ki_read_8(ea); } +INLINE uint OPER_A7_PD_8(m68ki_cpu_core *cpu) {uint ea = EA_A7_PD_8(); return m68ki_read_8(ea); } + +INLINE uint OPER_AW_8(m68ki_cpu_core *cpu) {uint ea = EA_AW_8(); return m68ki_read_8(ea); } +INLINE uint OPER_AW_16(m68ki_cpu_core *cpu) {uint ea = EA_AW_16(); return m68ki_read_16(ea);} +INLINE uint OPER_AW_32(m68ki_cpu_core *cpu) {uint ea = EA_AW_32(); return m68ki_read_32(ea);} +INLINE uint OPER_AL_8(m68ki_cpu_core *cpu) {uint ea = EA_AL_8(); return m68ki_read_8(ea); } +INLINE uint OPER_AL_16(m68ki_cpu_core *cpu) {uint ea = EA_AL_16(); return m68ki_read_16(ea);} +INLINE uint OPER_AL_32(m68ki_cpu_core *cpu) {uint ea = EA_AL_32(); return m68ki_read_32(ea);} +INLINE uint OPER_PCDI_8(m68ki_cpu_core *cpu) {uint ea = EA_PCDI_8(); return m68ki_read_pcrel_8(ea); } +INLINE uint OPER_PCDI_16(m68ki_cpu_core *cpu) {uint ea = EA_PCDI_16(); return m68ki_read_pcrel_16(ea);} +INLINE uint OPER_PCDI_32(m68ki_cpu_core *cpu) {uint ea = EA_PCDI_32(); return m68ki_read_pcrel_32(ea);} +INLINE uint OPER_PCIX_8(m68ki_cpu_core *cpu) {uint ea = EA_PCIX_8(); return m68ki_read_pcrel_8(ea); } +INLINE uint OPER_PCIX_16(m68ki_cpu_core *cpu) {uint ea = EA_PCIX_16(); return m68ki_read_pcrel_16(ea);} +INLINE uint OPER_PCIX_32(m68ki_cpu_core *cpu) {uint ea = EA_PCIX_32(); return m68ki_read_pcrel_32(ea);} /* ---------------------------- Stack Functions --------------------------- */ /* Push/pull data from the stack */ -INLINE void m68ki_push_16(uint value) +INLINE void m68ki_push_16(m68ki_cpu_core *cpu, uint value) { REG_SP = MASK_OUT_ABOVE_32(REG_SP - 2); m68ki_write_16(REG_SP, value); } -INLINE void m68ki_push_32(uint value) +INLINE void m68ki_push_32(m68ki_cpu_core *cpu, uint value) { REG_SP = MASK_OUT_ABOVE_32(REG_SP - 4); m68ki_write_32(REG_SP, value); } -INLINE uint m68ki_pull_16(void) +INLINE uint m68ki_pull_16(m68ki_cpu_core *cpu) { REG_SP = MASK_OUT_ABOVE_32(REG_SP + 2); return m68ki_read_16(REG_SP-2); } -INLINE uint m68ki_pull_32(void) +INLINE uint m68ki_pull_32(m68ki_cpu_core *cpu) { REG_SP = MASK_OUT_ABOVE_32(REG_SP + 4); return m68ki_read_32(REG_SP-4); @@ -1309,22 +1325,22 @@ INLINE uint m68ki_pull_32(void) /* Increment/decrement the stack as if doing a push/pull but * don't do any memory access. */ -INLINE void m68ki_fake_push_16(void) +INLINE void m68ki_fake_push_16(m68ki_cpu_core *cpu) { REG_SP = MASK_OUT_ABOVE_32(REG_SP - 2); } -INLINE void m68ki_fake_push_32(void) +INLINE void m68ki_fake_push_32(m68ki_cpu_core *cpu) { REG_SP = MASK_OUT_ABOVE_32(REG_SP - 4); } -INLINE void m68ki_fake_pull_16(void) +INLINE void m68ki_fake_pull_16(m68ki_cpu_core *cpu) { REG_SP = MASK_OUT_ABOVE_32(REG_SP + 2); } -INLINE void m68ki_fake_pull_32(void) +INLINE void m68ki_fake_pull_32(m68ki_cpu_core *cpu) { REG_SP = MASK_OUT_ABOVE_32(REG_SP + 4); } @@ -1336,13 +1352,13 @@ INLINE void m68ki_fake_pull_32(void) * These functions will also call the pc_changed callback if it was enabled * in m68kconf.h. */ -INLINE void m68ki_jump(uint new_pc) +INLINE void m68ki_jump(m68ki_cpu_core *cpu, uint new_pc) { REG_PC = new_pc; m68ki_pc_changed(REG_PC); } -INLINE void m68ki_jump_vector(uint vector) +INLINE void m68ki_jump_vector(m68ki_cpu_core *cpu, uint vector) { REG_PC = (vector<<2) + REG_VBR; REG_PC = m68ki_read_data_32(REG_PC); @@ -1355,17 +1371,17 @@ INLINE void m68ki_jump_vector(uint vector) * So far I've found no problems with not calling pc_changed for 8 or 16 * bit branches. */ -INLINE void m68ki_branch_8(uint offset) +INLINE void m68ki_branch_8(m68ki_cpu_core *cpu, uint offset) { REG_PC += MAKE_INT_8(offset); } -INLINE void m68ki_branch_16(uint offset) +INLINE void m68ki_branch_16(m68ki_cpu_core *cpu, uint offset) { REG_PC += MAKE_INT_16(offset); } -INLINE void m68ki_branch_32(uint offset) +INLINE void m68ki_branch_32(m68ki_cpu_core *cpu, uint offset) { REG_PC += offset; m68ki_pc_changed(REG_PC); @@ -1378,7 +1394,7 @@ INLINE void m68ki_branch_32(uint offset) /* Set the S flag and change the active stack pointer. * Note that value MUST be 4 or 0. */ -INLINE void m68ki_set_s_flag(uint value) +INLINE void m68ki_set_s_flag(m68ki_cpu_core *cpu, uint value) { /* Backup the old stack pointer */ REG_SP_BASE[FLAG_S | ((FLAG_S>>1) & FLAG_M)] = REG_SP; @@ -1391,7 +1407,7 @@ INLINE void m68ki_set_s_flag(uint value) /* Set the S and M flags and change the active stack pointer. * Note that value MUST be 0, 2, 4, or 6 (bit2 = S, bit1 = M). */ -INLINE void m68ki_set_sm_flag(uint value) +INLINE void m68ki_set_sm_flag(m68ki_cpu_core *cpu, uint value) { /* Backup the old stack pointer */ REG_SP_BASE[FLAG_S | ((FLAG_S>>1) & FLAG_M)] = REG_SP; @@ -1403,7 +1419,7 @@ INLINE void m68ki_set_sm_flag(uint value) } /* Set the S and M flags. Don't touch the stack pointer. */ -INLINE void m68ki_set_sm_flag_nosp(uint value) +INLINE void m68ki_set_sm_flag_nosp(m68ki_cpu_core *cpu, uint value) { /* Set the S and M flags */ FLAG_S = value & SFLAG_SET; @@ -1412,7 +1428,7 @@ INLINE void m68ki_set_sm_flag_nosp(uint value) /* Set the condition code register */ -INLINE void m68ki_set_ccr(uint value) +INLINE void m68ki_set_ccr(m68ki_cpu_core *cpu, uint value) { FLAG_X = BIT_4(value) << 4; FLAG_N = BIT_3(value) << 4; @@ -1422,7 +1438,7 @@ INLINE void m68ki_set_ccr(uint value) } /* Set the status register but don't check for interrupts */ -INLINE void m68ki_set_sr_noint(uint value) +INLINE void m68ki_set_sr_noint(m68ki_cpu_core *cpu, uint value) { /* Mask out the "unimplemented" bits */ value &= CPU_SR_MASK; @@ -1431,14 +1447,14 @@ INLINE void m68ki_set_sr_noint(uint value) FLAG_T1 = BIT_F(value); FLAG_T0 = BIT_E(value); FLAG_INT_MASK = value & 0x0700; - m68ki_set_ccr(value); - m68ki_set_sm_flag((value >> 11) & 6); + m68ki_set_ccr(cpu, value); + m68ki_set_sm_flag(cpu, (value >> 11) & 6); } /* Set the status register but don't check for interrupts nor * change the stack pointer */ -INLINE void m68ki_set_sr_noint_nosp(uint value) +INLINE void m68ki_set_sr_noint_nosp(m68ki_cpu_core *cpu, uint value) { /* Mask out the "unimplemented" bits */ value &= CPU_SR_MASK; @@ -1447,22 +1463,22 @@ INLINE void m68ki_set_sr_noint_nosp(uint value) FLAG_T1 = BIT_F(value); FLAG_T0 = BIT_E(value); FLAG_INT_MASK = value & 0x0700; - m68ki_set_ccr(value); - m68ki_set_sm_flag_nosp((value >> 11) & 6); + m68ki_set_ccr(cpu, value); + m68ki_set_sm_flag_nosp(cpu, (value >> 11) & 6); } /* Set the status register and check for interrupts */ -INLINE void m68ki_set_sr(uint value) +INLINE void m68ki_set_sr(m68ki_cpu_core *cpu, uint value) { - m68ki_set_sr_noint(value); - m68ki_check_interrupts(); + m68ki_set_sr_noint(cpu, value); + m68ki_check_interrupts(cpu); } /* ------------------------- Exception Processing ------------------------- */ /* Initiate exception processing */ -INLINE uint m68ki_init_exception(void) +INLINE uint m68ki_init_exception(m68ki_cpu_core *cpu) { /* Save the old status register */ uint sr = m68ki_get_sr(); @@ -1471,122 +1487,122 @@ INLINE uint m68ki_init_exception(void) FLAG_T1 = FLAG_T0 = 0; m68ki_clear_trace(); /* Enter supervisor mode */ - m68ki_set_s_flag(SFLAG_SET); + m68ki_set_s_flag(cpu, SFLAG_SET); return sr; } /* 3 word stack frame (68000 only) */ -INLINE void m68ki_stack_frame_3word(uint pc, uint sr) +INLINE void m68ki_stack_frame_3word(m68ki_cpu_core *cpu, uint pc, uint sr) { - m68ki_push_32(pc); - m68ki_push_16(sr); + m68ki_push_32(cpu, pc); + m68ki_push_16(cpu, sr); } /* Format 0 stack frame. * This is the standard stack frame for 68010+. */ -INLINE void m68ki_stack_frame_0000(uint pc, uint sr, uint vector) +INLINE void m68ki_stack_frame_0000(m68ki_cpu_core *cpu, uint pc, uint sr, uint vector) { /* Stack a 3-word frame if we are 68000 */ if(CPU_TYPE == CPU_TYPE_000) { - m68ki_stack_frame_3word(pc, sr); + m68ki_stack_frame_3word(cpu, pc, sr); return; } - m68ki_push_16(vector<<2); - m68ki_push_32(pc); - m68ki_push_16(sr); + m68ki_push_16(cpu, vector<<2); + m68ki_push_32(cpu, pc); + m68ki_push_16(cpu, sr); } /* Format 1 stack frame (68020). * For 68020, this is the 4 word throwaway frame. */ -INLINE void m68ki_stack_frame_0001(uint pc, uint sr, uint vector) +INLINE void m68ki_stack_frame_0001(m68ki_cpu_core *cpu, uint pc, uint sr, uint vector) { - m68ki_push_16(0x1000 | (vector<<2)); - m68ki_push_32(pc); - m68ki_push_16(sr); + m68ki_push_16(cpu, 0x1000 | (vector<<2)); + m68ki_push_32(cpu, pc); + m68ki_push_16(cpu, sr); } /* Format 2 stack frame. * This is used only by 68020 for trap exceptions. */ -INLINE void m68ki_stack_frame_0010(uint sr, uint vector) +INLINE void m68ki_stack_frame_0010(m68ki_cpu_core *cpu, uint sr, uint vector) { - m68ki_push_32(REG_PPC); - m68ki_push_16(0x2000 | (vector<<2)); - m68ki_push_32(REG_PC); - m68ki_push_16(sr); + m68ki_push_32(cpu, REG_PPC); + m68ki_push_16(cpu, 0x2000 | (vector<<2)); + m68ki_push_32(cpu, REG_PC); + m68ki_push_16(cpu, sr); } /* Bus error stack frame (68000 only). */ -INLINE void m68ki_stack_frame_buserr(uint sr) +INLINE void m68ki_stack_frame_buserr(m68ki_cpu_core *cpu, uint sr) { - m68ki_push_32(REG_PC); - m68ki_push_16(sr); - m68ki_push_16(REG_IR); - m68ki_push_32(m68ki_aerr_address); /* access address */ + m68ki_push_32(cpu,REG_PC); + m68ki_push_16(cpu,sr); + m68ki_push_16(cpu,REG_IR); + m68ki_push_32(cpu,cpu->m68ki_aerr_address); /* access address */ /* 0 0 0 0 0 0 0 0 0 0 0 R/W I/N FC * R/W 0 = write, 1 = read * I/N 0 = instruction, 1 = not * FC 3-bit function code */ - m68ki_push_16(m68ki_aerr_write_mode | CPU_INSTR_MODE | m68ki_aerr_fc); + m68ki_push_16(cpu,cpu->m68ki_aerr_write_mode | CPU_INSTR_MODE | cpu->m68ki_aerr_fc); } /* Format 8 stack frame (68010). * 68010 only. This is the 29 word bus/address error frame. */ -void m68ki_stack_frame_1000(uint pc, uint sr, uint vector) +void m68ki_stack_frame_1000(m68ki_cpu_core *cpu, uint pc, uint sr, uint vector) { /* VERSION * NUMBER * INTERNAL INFORMATION, 16 WORDS */ - m68ki_fake_push_32(); - m68ki_fake_push_32(); - m68ki_fake_push_32(); - m68ki_fake_push_32(); - m68ki_fake_push_32(); - m68ki_fake_push_32(); - m68ki_fake_push_32(); - m68ki_fake_push_32(); + m68ki_fake_push_32(cpu); + m68ki_fake_push_32(cpu); + m68ki_fake_push_32(cpu); + m68ki_fake_push_32(cpu); + m68ki_fake_push_32(cpu); + m68ki_fake_push_32(cpu); + m68ki_fake_push_32(cpu); + m68ki_fake_push_32(cpu); /* INSTRUCTION INPUT BUFFER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* UNUSED, RESERVED (not written) */ - m68ki_fake_push_16(); + m68ki_fake_push_16(cpu); /* DATA INPUT BUFFER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* UNUSED, RESERVED (not written) */ - m68ki_fake_push_16(); + m68ki_fake_push_16(cpu); /* DATA OUTPUT BUFFER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* UNUSED, RESERVED (not written) */ - m68ki_fake_push_16(); + m68ki_fake_push_16(cpu); /* FAULT ADDRESS */ - m68ki_push_32(0); + m68ki_push_32(cpu,0); /* SPECIAL STATUS WORD */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* 1000, VECTOR OFFSET */ - m68ki_push_16(0x8000 | (vector<<2)); + m68ki_push_16(cpu,0x8000 | (vector<<2)); /* PROGRAM COUNTER */ - m68ki_push_32(pc); + m68ki_push_32(cpu,pc); /* STATUS REGISTER */ - m68ki_push_16(sr); + m68ki_push_16(cpu,sr); } /* Format A stack frame (short bus fault). @@ -1594,46 +1610,46 @@ void m68ki_stack_frame_1000(uint pc, uint sr, uint vector) * if the error happens at an instruction boundary. * PC stacked is address of next instruction. */ -void m68ki_stack_frame_1010(uint sr, uint vector, uint pc) +void m68ki_stack_frame_1010(m68ki_cpu_core *cpu, uint sr, uint vector, uint pc) { /* INTERNAL REGISTER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* INTERNAL REGISTER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* DATA OUTPUT BUFFER (2 words) */ - m68ki_push_32(0); + m68ki_push_32(cpu,0); /* INTERNAL REGISTER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* INTERNAL REGISTER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* DATA CYCLE FAULT ADDRESS (2 words) */ - m68ki_push_32(0); + m68ki_push_32(cpu,0); /* INSTRUCTION PIPE STAGE B */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* INSTRUCTION PIPE STAGE C */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* SPECIAL STATUS REGISTER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* INTERNAL REGISTER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* 1010, VECTOR OFFSET */ - m68ki_push_16(0xa000 | (vector<<2)); + m68ki_push_16(cpu,0xa000 | (vector<<2)); /* PROGRAM COUNTER */ - m68ki_push_32(pc); + m68ki_push_32(cpu,pc); /* STATUS REGISTER */ - m68ki_push_16(sr); + m68ki_push_16(cpu,sr); } /* Format B stack frame (long bus fault). @@ -1641,107 +1657,107 @@ void m68ki_stack_frame_1010(uint sr, uint vector, uint pc) * if the error happens during instruction execution. * PC stacked is address of instruction in progress. */ -void m68ki_stack_frame_1011(uint sr, uint vector, uint pc) +void m68ki_stack_frame_1011(m68ki_cpu_core *cpu, uint sr, uint vector, uint pc) { /* INTERNAL REGISTERS (18 words) */ - m68ki_push_32(0); - m68ki_push_32(0); - m68ki_push_32(0); - m68ki_push_32(0); - m68ki_push_32(0); - m68ki_push_32(0); - m68ki_push_32(0); - m68ki_push_32(0); - m68ki_push_32(0); + m68ki_push_32(cpu,0); + m68ki_push_32(cpu,0); + m68ki_push_32(cpu,0); + m68ki_push_32(cpu,0); + m68ki_push_32(cpu,0); + m68ki_push_32(cpu,0); + m68ki_push_32(cpu,0); + m68ki_push_32(cpu,0); + m68ki_push_32(cpu,0); /* VERSION# (4 bits), INTERNAL INFORMATION */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* INTERNAL REGISTERS (3 words) */ - m68ki_push_32(0); - m68ki_push_16(0); + m68ki_push_32(cpu,0); + m68ki_push_16(cpu,0); /* DATA INTPUT BUFFER (2 words) */ - m68ki_push_32(0); + m68ki_push_32(cpu,0); /* INTERNAL REGISTERS (2 words) */ - m68ki_push_32(0); + m68ki_push_32(cpu,0); /* STAGE B ADDRESS (2 words) */ - m68ki_push_32(0); + m68ki_push_32(cpu,0); /* INTERNAL REGISTER (4 words) */ - m68ki_push_32(0); - m68ki_push_32(0); + m68ki_push_32(cpu,0); + m68ki_push_32(cpu,0); /* DATA OUTPUT BUFFER (2 words) */ - m68ki_push_32(0); + m68ki_push_32(cpu,0); /* INTERNAL REGISTER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* INTERNAL REGISTER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* DATA CYCLE FAULT ADDRESS (2 words) */ - m68ki_push_32(0); + m68ki_push_32(cpu,0); /* INSTRUCTION PIPE STAGE B */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* INSTRUCTION PIPE STAGE C */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* SPECIAL STATUS REGISTER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* INTERNAL REGISTER */ - m68ki_push_16(0); + m68ki_push_16(cpu,0); /* 1011, VECTOR OFFSET */ - m68ki_push_16(0xb000 | (vector<<2)); + m68ki_push_16(cpu,0xb000 | (vector<<2)); /* PROGRAM COUNTER */ - m68ki_push_32(pc); + m68ki_push_32(cpu,pc); /* STATUS REGISTER */ - m68ki_push_16(sr); + m68ki_push_16(cpu,sr); } /* Used for Group 2 exceptions. * These stack a type 2 frame on the 020. */ -INLINE void m68ki_exception_trap(uint vector) +INLINE void m68ki_exception_trap(m68ki_cpu_core *cpu, uint vector) { - uint sr = m68ki_init_exception(); + uint sr = m68ki_init_exception(cpu); if(CPU_TYPE_IS_010_LESS(CPU_TYPE)) - m68ki_stack_frame_0000(REG_PC, sr, vector); + m68ki_stack_frame_0000(cpu, REG_PC, sr, vector); else - m68ki_stack_frame_0010(sr, vector); + m68ki_stack_frame_0010(cpu, sr, vector); - m68ki_jump_vector(vector); + m68ki_jump_vector(cpu, vector); /* Use up some clock cycles */ USE_CYCLES(CYC_EXCEPTION[vector]); } /* Trap#n stacks a 0 frame but behaves like group2 otherwise */ -INLINE void m68ki_exception_trapN(uint vector) +INLINE void m68ki_exception_trapN(m68ki_cpu_core *cpu, uint vector) { - uint sr = m68ki_init_exception(); - m68ki_stack_frame_0000(REG_PC, sr, vector); - m68ki_jump_vector(vector); + uint sr = m68ki_init_exception(cpu); + m68ki_stack_frame_0000(cpu, REG_PC, sr, vector); + m68ki_jump_vector(cpu, vector); /* Use up some clock cycles */ USE_CYCLES(CYC_EXCEPTION[vector]); } /* Exception for trace mode */ -INLINE void m68ki_exception_trace(void) +INLINE void m68ki_exception_trace(m68ki_cpu_core *cpu) { - uint sr = m68ki_init_exception(); + uint sr = m68ki_init_exception(cpu); if(CPU_TYPE_IS_010_LESS(CPU_TYPE)) { @@ -1751,12 +1767,12 @@ INLINE void m68ki_exception_trace(void) CPU_INSTR_MODE = INSTRUCTION_NO; } #endif /* M68K_EMULATE_ADDRESS_ERROR */ - m68ki_stack_frame_0000(REG_PC, sr, EXCEPTION_TRACE); + m68ki_stack_frame_0000(cpu, REG_PC, sr, EXCEPTION_TRACE); } else - m68ki_stack_frame_0010(sr, EXCEPTION_TRACE); + m68ki_stack_frame_0010(cpu, sr, EXCEPTION_TRACE); - m68ki_jump_vector(EXCEPTION_TRACE); + m68ki_jump_vector(cpu, EXCEPTION_TRACE); /* Trace nullifies a STOP instruction */ CPU_STOPPED &= ~STOP_LEVEL_STOP; @@ -1766,9 +1782,9 @@ INLINE void m68ki_exception_trace(void) } /* Exception for privilege violation */ -INLINE void m68ki_exception_privilege_violation(void) +INLINE void m68ki_exception_privilege_violation(m68ki_cpu_core *cpu) { - uint sr = m68ki_init_exception(); + uint sr = m68ki_init_exception(cpu); #if M68K_EMULATE_ADDRESS_ERROR == OPT_ON if(CPU_TYPE_IS_000(CPU_TYPE)) @@ -1777,15 +1793,15 @@ INLINE void m68ki_exception_privilege_violation(void) } #endif /* M68K_EMULATE_ADDRESS_ERROR */ - m68ki_stack_frame_0000(REG_PPC, sr, EXCEPTION_PRIVILEGE_VIOLATION); - m68ki_jump_vector(EXCEPTION_PRIVILEGE_VIOLATION); + m68ki_stack_frame_0000(cpu, REG_PPC, sr, EXCEPTION_PRIVILEGE_VIOLATION); + m68ki_jump_vector(cpu, EXCEPTION_PRIVILEGE_VIOLATION); /* Use up some clock cycles and undo the instruction's cycles */ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_PRIVILEGE_VIOLATION] - CYC_INSTRUCTION[REG_IR]); } /* Exception for A-Line instructions */ -INLINE void m68ki_exception_1010(void) +INLINE void m68ki_exception_1010(m68ki_cpu_core *cpu) { uint sr; #if M68K_LOG_1010_1111 == OPT_ON @@ -1794,16 +1810,16 @@ INLINE void m68ki_exception_1010(void) m68ki_disassemble_quick(ADDRESS_68K(REG_PPC)))); #endif - sr = m68ki_init_exception(); - m68ki_stack_frame_0000(REG_PPC, sr, EXCEPTION_1010); - m68ki_jump_vector(EXCEPTION_1010); + sr = m68ki_init_exception(cpu); + m68ki_stack_frame_0000(cpu, REG_PPC, sr, EXCEPTION_1010); + m68ki_jump_vector(cpu, EXCEPTION_1010); /* Use up some clock cycles and undo the instruction's cycles */ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_1010] - CYC_INSTRUCTION[REG_IR]); } /* Exception for F-Line instructions */ -INLINE void m68ki_exception_1111(void) +INLINE void m68ki_exception_1111(m68ki_cpu_core *cpu) { uint sr; @@ -1813,16 +1829,16 @@ INLINE void m68ki_exception_1111(void) m68ki_disassemble_quick(ADDRESS_68K(REG_PPC)))); #endif - sr = m68ki_init_exception(); - m68ki_stack_frame_0000(REG_PPC, sr, EXCEPTION_1111); - m68ki_jump_vector(EXCEPTION_1111); + sr = m68ki_init_exception(cpu); + m68ki_stack_frame_0000(cpu, REG_PPC, sr, EXCEPTION_1111); + m68ki_jump_vector(cpu, EXCEPTION_1111); /* Use up some clock cycles and undo the instruction's cycles */ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_1111] - CYC_INSTRUCTION[REG_IR]); } /* Exception for illegal instructions */ -INLINE void m68ki_exception_illegal(void) +INLINE void m68ki_exception_illegal(m68ki_cpu_core *cpu) { uint sr; @@ -1830,7 +1846,7 @@ INLINE void m68ki_exception_illegal(void) m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PPC), REG_IR, m68ki_disassemble_quick(ADDRESS_68K(REG_PPC)))); - sr = m68ki_init_exception(); + sr = m68ki_init_exception(cpu); #if M68K_EMULATE_ADDRESS_ERROR == OPT_ON if(CPU_TYPE_IS_000(CPU_TYPE)) @@ -1839,28 +1855,28 @@ INLINE void m68ki_exception_illegal(void) } #endif /* M68K_EMULATE_ADDRESS_ERROR */ - m68ki_stack_frame_0000(REG_PPC, sr, EXCEPTION_ILLEGAL_INSTRUCTION); - m68ki_jump_vector(EXCEPTION_ILLEGAL_INSTRUCTION); + m68ki_stack_frame_0000(cpu, REG_PPC, sr, EXCEPTION_ILLEGAL_INSTRUCTION); + m68ki_jump_vector(cpu, EXCEPTION_ILLEGAL_INSTRUCTION); /* Use up some clock cycles and undo the instruction's cycles */ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_ILLEGAL_INSTRUCTION] - CYC_INSTRUCTION[REG_IR]); } /* Exception for format errror in RTE */ -INLINE void m68ki_exception_format_error(void) +INLINE void m68ki_exception_format_error(m68ki_cpu_core *cpu) { - uint sr = m68ki_init_exception(); - m68ki_stack_frame_0000(REG_PC, sr, EXCEPTION_FORMAT_ERROR); - m68ki_jump_vector(EXCEPTION_FORMAT_ERROR); + uint sr = m68ki_init_exception(cpu); + m68ki_stack_frame_0000(cpu, REG_PC, sr, EXCEPTION_FORMAT_ERROR); + m68ki_jump_vector(cpu, EXCEPTION_FORMAT_ERROR); /* Use up some clock cycles and undo the instruction's cycles */ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_FORMAT_ERROR] - CYC_INSTRUCTION[REG_IR]); } /* Exception for address error */ -INLINE void m68ki_exception_address_error(void) +INLINE void m68ki_exception_address_error(m68ki_cpu_core *cpu) { - uint sr = m68ki_init_exception(); + uint sr = m68ki_init_exception(cpu); /* If we were processing a bus error, address error, or reset, * this is a catastrophic failure. @@ -1868,16 +1884,16 @@ INLINE void m68ki_exception_address_error(void) */ if(CPU_RUN_MODE == RUN_MODE_BERR_AERR_RESET) { -m68k_read_memory_8(0x00ffff01); + m68k_read_memory_8(cpu, 0x00ffff01); CPU_STOPPED = STOP_LEVEL_HALT; return; } CPU_RUN_MODE = RUN_MODE_BERR_AERR_RESET; /* Note: This is implemented for 68000 only! */ - m68ki_stack_frame_buserr(sr); + m68ki_stack_frame_buserr(cpu, sr); - m68ki_jump_vector(EXCEPTION_ADDRESS_ERROR); + m68ki_jump_vector(cpu, EXCEPTION_ADDRESS_ERROR); /* Use up some clock cycles and undo the instruction's cycles */ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_ADDRESS_ERROR] - CYC_INSTRUCTION[REG_IR]); @@ -1885,7 +1901,7 @@ m68k_read_memory_8(0x00ffff01); /* Service an interrupt request and start exception processing */ -void m68ki_exception_interrupt(uint int_level) +void m68ki_exception_interrupt(m68ki_cpu_core *cpu, uint int_level) { uint vector; uint sr; @@ -1906,7 +1922,7 @@ void m68ki_exception_interrupt(uint int_level) return; /* Acknowledge the interrupt */ - vector = m68ki_int_ack(int_level); + vector = m68ki_int_ack(cpu, int_level); /* Get the interrupt vector */ if(vector == M68K_INT_ACK_AUTOVECTOR) @@ -1923,7 +1939,7 @@ void m68ki_exception_interrupt(uint int_level) } /* Start exception processing */ - sr = m68ki_init_exception(); + sr = m68ki_init_exception(cpu); /* Set the interrupt mask to the level of the one being serviced */ FLAG_INT_MASK = int_level<<8; @@ -1936,16 +1952,16 @@ void m68ki_exception_interrupt(uint int_level) new_pc = m68ki_read_data_32((EXCEPTION_UNINITIALIZED_INTERRUPT<<2) + REG_VBR); /* Generate a stack frame */ - m68ki_stack_frame_0000(REG_PC, sr, vector); + m68ki_stack_frame_0000(cpu, REG_PC, sr, vector); if(FLAG_M && CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) { /* Create throwaway frame */ - m68ki_set_sm_flag(FLAG_S); /* clear M */ + m68ki_set_sm_flag(cpu, FLAG_S); /* clear M */ sr |= 0x2000; /* Same as SR in master stack frame except S is forced high */ - m68ki_stack_frame_0001(REG_PC, sr, vector); + m68ki_stack_frame_0001(cpu, REG_PC, sr, vector); } - m68ki_jump(new_pc); + m68ki_jump(cpu, new_pc); /* Defer cycle counting until later */ CPU_INT_CYCLES += CYC_EXCEPTION[vector]; @@ -1958,10 +1974,10 @@ void m68ki_exception_interrupt(uint int_level) /* ASG: Check for interrupts */ -INLINE void m68ki_check_interrupts(void) +INLINE void m68ki_check_interrupts(m68ki_cpu_core *cpu) { if(CPU_INT_LEVEL > FLAG_INT_MASK) - m68ki_exception_interrupt(CPU_INT_LEVEL>>8); + m68ki_exception_interrupt(cpu, CPU_INT_LEVEL>>8); } |