The-Homebrew-Cloud/Genesis-Plus-GX
2
0
Fork 0
mirror of https://github.com/ekeeke/Genesis-Plus-GX.git synced 2025-02-28 17:03:39 +01:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Update m68k"

Browse Source 
This reverts commit 24acab9e513d505f5b2d7bfef78fb7a27420a113.
This commit is contained in:
twinaphex 2017-07-25 10:20:16 +02:00
parent effdec65ed
commit 30378fad52
3 changed files with 3757 additions and 3759 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/m68k/m68kcpu.c
View File

@ -304,7 +304,7 @@ void m68k_run(unsigned int cycles)
void m68k_init(void)
{
#ifdef BUILD_TABLES
static uint32_t emulation_initialized = 0;
static uint emulation_initialized = 0;
/* The first call to this function initializes the opcode handler jump table */
if(!emulation_initialized)

304
core/m68k/m68kcpu.h
View File

@ -567,7 +567,7 @@ static const uint16 m68ki_shift_16_table[65] =
0xffff, 0xffff
};
static const uint32_t m68ki_shift_32_table[65] =
static const uint m68ki_shift_32_table[65] =
{
0x00000000, 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000, 0xf8000000,
0xfc000000, 0xfe000000, 0xff000000, 0xff800000, 0xffc00000, 0xffe00000,
@ -662,8 +662,8 @@ static const uint16 m68ki_exception_cycle_table[256] =
};
/* Read data immediately after the program counter */
INLINE uint32_t m68ki_read_imm_16(void);
INLINE uint32_t m68ki_read_imm_32(void);
INLINE uint m68ki_read_imm_16(void);
INLINE uint m68ki_read_imm_32(void);
/* Read from the current address space */
INLINE uint m68ki_read_8(uint address);
@ -676,85 +676,85 @@ INLINE void m68ki_write_16(uint address, uint value);
INLINE void m68ki_write_32(uint address, uint value);
/* Indexed and PC-relative ea fetching */
INLINE uint32_t m68ki_get_ea_pcdi(void);
INLINE uint32_t m68ki_get_ea_pcix(void);
INLINE uint32_t m68ki_get_ea_ix(uint32_t An);
INLINE uint m68ki_get_ea_pcdi(void);
INLINE uint m68ki_get_ea_pcix(void);
INLINE uint m68ki_get_ea_ix(uint An);
/* Operand fetching */
INLINE uint32_t OPER_AY_AI_8(void);
INLINE uint32_t OPER_AY_AI_16(void);
INLINE uint32_t OPER_AY_AI_32(void);
INLINE uint32_t OPER_AY_PI_8(void);
INLINE uint32_t OPER_AY_PI_16(void);
INLINE uint32_t OPER_AY_PI_32(void);
INLINE uint32_t OPER_AY_PD_8(void);
INLINE uint32_t OPER_AY_PD_16(void);
INLINE uint32_t OPER_AY_PD_32(void);
INLINE uint32_t OPER_AY_DI_8(void);
INLINE uint32_t OPER_AY_DI_16(void);
INLINE uint32_t OPER_AY_DI_32(void);
INLINE uint32_t OPER_AY_IX_8(void);
INLINE uint32_t OPER_AY_IX_16(void);
INLINE uint32_t OPER_AY_IX_32(void);
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 uint32_t OPER_AX_AI_8(void);
INLINE uint32_t OPER_AX_AI_16(void);
INLINE uint32_t OPER_AX_AI_32(void);
INLINE uint32_t OPER_AX_PI_8(void);
INLINE uint32_t OPER_AX_PI_16(void);
INLINE uint32_t OPER_AX_PI_32(void);
INLINE uint32_t OPER_AX_PD_8(void);
INLINE uint32_t OPER_AX_PD_16(void);
INLINE uint32_t OPER_AX_PD_32(void);
INLINE uint32_t OPER_AX_DI_8(void);
INLINE uint32_t OPER_AX_DI_16(void);
INLINE uint32_t OPER_AX_DI_32(void);
INLINE uint32_t OPER_AX_IX_8(void);
INLINE uint32_t OPER_AX_IX_16(void);
INLINE uint32_t OPER_AX_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 uint32_t OPER_A7_PI_8(void);
INLINE uint32_t OPER_A7_PD_8(void);
INLINE uint OPER_A7_PI_8(void);
INLINE uint OPER_A7_PD_8(void);
INLINE uint32_t OPER_AW_8(void);
INLINE uint32_t OPER_AW_16(void);
INLINE uint32_t OPER_AW_32(void);
INLINE uint32_t OPER_AL_8(void);
INLINE uint32_t OPER_AL_16(void);
INLINE uint32_t OPER_AL_32(void);
INLINE uint32_t OPER_PCDI_8(void);
INLINE uint32_t OPER_PCDI_16(void);
INLINE uint32_t OPER_PCDI_32(void);
INLINE uint32_t OPER_PCIX_8(void);
INLINE uint32_t OPER_PCIX_16(void);
INLINE uint32_t OPER_PCIX_32(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);
/* Stack operations */
INLINE void m68ki_push_16(uint32_t value);
INLINE void m68ki_push_32(uint32_t value);
INLINE uint32_t m68ki_pull_16(void);
INLINE uint32_t m68ki_pull_32(void);
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);
/* Program flow operations */
INLINE void m68ki_jump(uint32_t new_pc);
INLINE void m68ki_jump_vector(uint32_t vector);
INLINE void m68ki_branch_8(uint32_t offset);
INLINE void m68ki_branch_16(uint32_t offset);
INLINE void m68ki_branch_32(uint32_t offset);
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);
/* Status register operations. */
INLINE void m68ki_set_s_flag(uint32_t value); /* Only bit 2 of value should be set (i.e. 4 or 0) */
INLINE void m68ki_set_ccr(uint32_t value); /* set the condition code register */
INLINE void m68ki_set_sr(uint32_t value); /* set the status register */
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_ccr(uint value); /* set the condition code register */
INLINE void m68ki_set_sr(uint value); /* set the status register */
/* Exception processing */
INLINE uint32_t m68ki_init_exception(void); /* Initial exception processing */
INLINE void m68ki_stack_frame_3word(uint32_t pc, uint32_t sr); /* Stack various frame types */
INLINE uint m68ki_init_exception(void); /* Initial exception processing */
INLINE void m68ki_stack_frame_3word(uint pc, uint sr); /* Stack various frame types */
#if M68K_EMULATE_ADDRESS_ERROR
INLINE void m68ki_stack_frame_buserr(uint32_t sr);
INLINE void m68ki_stack_frame_buserr(uint sr);
#endif
INLINE void m68ki_exception_trap(uint32_t vector);
INLINE void m68ki_exception_trapN(uint32_t vector);
INLINE void m68ki_exception_trap(uint vector);
INLINE void m68ki_exception_trapN(uint vector);
#if M68K_EMULATE_TRACE
INLINE void m68ki_exception_trace(void);
#endif
@ -765,7 +765,7 @@ INLINE void m68ki_exception_illegal(void);
#if M68K_EMULATE_ADDRESS_ERROR
INLINE void m68ki_exception_address_error(void);
#endif
INLINE void m68ki_exception_interrupt(uint32_t int_level);
INLINE void m68ki_exception_interrupt(uint int_level);
INLINE void m68ki_check_interrupts(void); /* ASG: check for interrupts */
/* ======================================================================== */
@ -778,7 +778,7 @@ INLINE void m68ki_check_interrupts(void); /* ASG: check for interrupt
/* Handles all immediate reads, does address error check, function code setting,
* and prefetching if they are enabled in m68kconf.h
*/
INLINE uint32_t m68ki_read_imm_16(void)
INLINE uint m68ki_read_imm_16(void)
{
m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */
#if M68K_CHECK_PC_ADDRESS_ERROR
@ -793,16 +793,16 @@ INLINE uint32_t m68ki_read_imm_16(void)
REG_PC += 2;
return MASK_OUT_ABOVE_16(CPU_PREF_DATA >> ((2-((REG_PC-2)&2))<<3));
#else
uint32_t pc = REG_PC;
uint pc = REG_PC;
REG_PC += 2;
return m68k_read_immediate_16(pc);
#endif /* M68K_EMULATE_PREFETCH */
}
INLINE uint32_t m68ki_read_imm_32(void)
INLINE uint m68ki_read_imm_32(void)
{
#if M68K_EMULATE_PREFETCH
uint32_t temp_val;
uint temp_val;
m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */
#if M68K_CHECK_PC_ADDRESS_ERROR
@ -829,7 +829,7 @@ INLINE uint32_t m68ki_read_imm_32(void)
#if M68K_CHECK_PC_ADDRESS_ERROR
m68ki_check_address_error(REG_PC, MODE_READ, FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */
#endif
uint32_t pc = REG_PC;
uint pc = REG_PC;
REG_PC += 4;
return m68k_read_immediate_32(pc);
#endif /* M68K_EMULATE_PREFETCH */
@ -924,15 +924,15 @@ INLINE void m68ki_write_32(uint address, uint value)
/* The program counter relative addressing modes cause operands to be
* retrieved from program space, not data space.
*/
INLINE uint32_t m68ki_get_ea_pcdi(void)
INLINE uint m68ki_get_ea_pcdi(void)
{
uint32_t old_pc = REG_PC;
uint old_pc = REG_PC;
m68ki_use_program_space() /* auto-disable */
return old_pc + MAKE_INT_16(m68ki_read_imm_16());
}
INLINE uint32_t m68ki_get_ea_pcix(void)
INLINE uint m68ki_get_ea_pcix(void)
{
m68ki_use_program_space() /* auto-disable */
return m68ki_get_ea_ix(REG_PC);
@ -980,12 +980,12 @@ INLINE uint32_t m68ki_get_ea_pcix(void)
* 1 011 mem indir with long outer
* 1 100-111 reserved
*/
INLINE uint32_t m68ki_get_ea_ix(uint32_t An)
INLINE uint m68ki_get_ea_ix(uint An)
{
/* An = base register */
uint32_t extension = m68ki_read_imm_16();
uint extension = m68ki_read_imm_16();
uint32_t Xn = 0; /* Index register */
uint Xn = 0; /* Index register */
/* Calculate index */
Xn = REG_DA[extension>>12]; /* Xn */
@ -998,53 +998,53 @@ INLINE uint32_t m68ki_get_ea_ix(uint32_t An)
/* Fetch operands */
INLINE uint32_t OPER_AY_AI_8(void) {uint32_t ea = EA_AY_AI_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_AY_AI_16(void) {uint32_t ea = EA_AY_AI_16(); return m68ki_read_16(ea);}
INLINE uint32_t OPER_AY_AI_32(void) {uint32_t ea = EA_AY_AI_32(); return m68ki_read_32(ea);}
INLINE uint32_t OPER_AY_PI_8(void) {uint32_t ea = EA_AY_PI_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_AY_PI_16(void) {uint32_t ea = EA_AY_PI_16(); return m68ki_read_16(ea);}
INLINE uint32_t OPER_AY_PI_32(void) {uint32_t ea = EA_AY_PI_32(); return m68ki_read_32(ea);}
INLINE uint32_t OPER_AY_PD_8(void) {uint32_t ea = EA_AY_PD_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_AY_PD_16(void) {uint32_t ea = EA_AY_PD_16(); return m68ki_read_16(ea);}
INLINE uint32_t OPER_AY_PD_32(void) {uint32_t ea = EA_AY_PD_32(); return m68ki_read_32(ea);}
INLINE uint32_t OPER_AY_DI_8(void) {uint32_t ea = EA_AY_DI_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_AY_DI_16(void) {uint32_t ea = EA_AY_DI_16(); return m68ki_read_16(ea);}
INLINE uint32_t OPER_AY_DI_32(void) {uint32_t ea = EA_AY_DI_32(); return m68ki_read_32(ea);}
INLINE uint32_t OPER_AY_IX_8(void) {uint32_t ea = EA_AY_IX_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_AY_IX_16(void) {uint32_t ea = EA_AY_IX_16(); return m68ki_read_16(ea);}
INLINE uint32_t OPER_AY_IX_32(void) {uint32_t ea = EA_AY_IX_32(); return m68ki_read_32(ea);}
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 uint32_t OPER_AX_AI_8(void) {uint32_t ea = EA_AX_AI_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_AX_AI_16(void) {uint32_t ea = EA_AX_AI_16(); return m68ki_read_16(ea);}
INLINE uint32_t OPER_AX_AI_32(void) {uint32_t ea = EA_AX_AI_32(); return m68ki_read_32(ea);}
INLINE uint32_t OPER_AX_PI_8(void) {uint32_t ea = EA_AX_PI_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_AX_PI_16(void) {uint32_t ea = EA_AX_PI_16(); return m68ki_read_16(ea);}
INLINE uint32_t OPER_AX_PI_32(void) {uint32_t ea = EA_AX_PI_32(); return m68ki_read_32(ea);}
INLINE uint32_t OPER_AX_PD_8(void) {uint32_t ea = EA_AX_PD_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_AX_PD_16(void) {uint32_t ea = EA_AX_PD_16(); return m68ki_read_16(ea);}
INLINE uint32_t OPER_AX_PD_32(void) {uint32_t ea = EA_AX_PD_32(); return m68ki_read_32(ea);}
INLINE uint32_t OPER_AX_DI_8(void) {uint32_t ea = EA_AX_DI_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_AX_DI_16(void) {uint32_t ea = EA_AX_DI_16(); return m68ki_read_16(ea);}
INLINE uint32_t OPER_AX_DI_32(void) {uint32_t ea = EA_AX_DI_32(); return m68ki_read_32(ea);}
INLINE uint32_t OPER_AX_IX_8(void) {uint32_t ea = EA_AX_IX_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_AX_IX_16(void) {uint32_t ea = EA_AX_IX_16(); return m68ki_read_16(ea);}
INLINE uint32_t OPER_AX_IX_32(void) {uint32_t ea = EA_AX_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 uint32_t OPER_A7_PI_8(void) {uint32_t ea = EA_A7_PI_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_A7_PD_8(void) {uint32_t ea = EA_A7_PD_8(); return m68ki_read_8(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 uint32_t OPER_AW_8(void) {uint32_t ea = EA_AW_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_AW_16(void) {uint32_t ea = EA_AW_16(); return m68ki_read_16(ea);}
INLINE uint32_t OPER_AW_32(void) {uint32_t ea = EA_AW_32(); return m68ki_read_32(ea);}
INLINE uint32_t OPER_AL_8(void) {uint32_t ea = EA_AL_8(); return m68ki_read_8(ea); }
INLINE uint32_t OPER_AL_16(void) {uint32_t ea = EA_AL_16(); return m68ki_read_16(ea);}
INLINE uint32_t OPER_AL_32(void) {uint32_t ea = EA_AL_32(); return m68ki_read_32(ea);}
INLINE uint32_t OPER_PCDI_8(void) {uint32_t ea = EA_PCDI_8(); return m68ki_read_pcrel_8(ea); }
INLINE uint32_t OPER_PCDI_16(void) {uint32_t ea = EA_PCDI_16(); return m68ki_read_pcrel_16(ea);}
INLINE uint32_t OPER_PCDI_32(void) {uint32_t ea = EA_PCDI_32(); return m68ki_read_pcrel_32(ea);}
INLINE uint32_t OPER_PCIX_8(void) {uint32_t ea = EA_PCIX_8(); return m68ki_read_pcrel_8(ea); }
INLINE uint32_t OPER_PCIX_16(void) {uint32_t ea = EA_PCIX_16(); return m68ki_read_pcrel_16(ea);}
INLINE uint32_t OPER_PCIX_32(void) {uint32_t ea = EA_PCIX_32(); return m68ki_read_pcrel_32(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);}
@ -1057,22 +1057,22 @@ INLINE void m68ki_push_16(uint value)
m68ki_write_16(REG_SP, value);
}
INLINE void m68ki_push_32(uint32_t value)
INLINE void m68ki_push_32(uint value)
{
REG_SP = MASK_OUT_ABOVE_32(REG_SP - 4);
m68ki_write_32(REG_SP, value);
}
INLINE uint32_t m68ki_pull_16(void)
INLINE uint m68ki_pull_16(void)
{
uint32_t sp = REG_SP;
uint sp = REG_SP;
REG_SP = MASK_OUT_ABOVE_32(REG_SP + 2);
return m68ki_read_16(sp);
}
INLINE uint32_t m68ki_pull_32(void)
INLINE uint m68ki_pull_32(void)
{
uint32_t sp = REG_SP;
uint sp = REG_SP;
REG_SP = MASK_OUT_ABOVE_32(REG_SP + 4);
return m68ki_read_32(sp);
}
@ -1085,12 +1085,12 @@ INLINE uint32_t m68ki_pull_32(void)
* These functions will also call the pc_changed callback if it was enabled
* in m68kconf.h.
*/
INLINE void m68ki_jump(uint32_t new_pc)
INLINE void m68ki_jump(uint new_pc)
{
REG_PC = new_pc;
}
INLINE void m68ki_jump_vector(uint32_t vector)
INLINE void m68ki_jump_vector(uint vector)
{
m68ki_use_data_space() /* auto-disable (see m68kcpu.h) */
REG_PC = m68ki_read_32(vector<<2);
@ -1102,17 +1102,17 @@ INLINE void m68ki_jump_vector(uint32_t vector)
* So far I've found no problems with not calling pc_changed for 8 or 16
* bit branches.
*/
INLINE void m68ki_branch_8(uint32_t offset)
INLINE void m68ki_branch_8(uint offset)
{
REG_PC += MAKE_INT_8(offset);
}
INLINE void m68ki_branch_16(uint32_t offset)
INLINE void m68ki_branch_16(uint offset)
{
REG_PC += MAKE_INT_16(offset);
}
INLINE void m68ki_branch_32(uint32_t offset)
INLINE void m68ki_branch_32(uint offset)
{
REG_PC += offset;
}
@ -1124,7 +1124,7 @@ INLINE void m68ki_branch_32(uint32_t 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(uint32_t value)
INLINE void m68ki_set_s_flag(uint value)
{
/* Backup the old stack pointer */
REG_SP_BASE[FLAG_S] = REG_SP;
@ -1136,7 +1136,7 @@ INLINE void m68ki_set_s_flag(uint32_t value)
/* Set the condition code register */
INLINE void m68ki_set_ccr(uint32_t value)
INLINE void m68ki_set_ccr(uint value)
{
FLAG_X = BIT_4(value) << 4;
FLAG_N = BIT_3(value) << 4;
@ -1147,7 +1147,7 @@ INLINE void m68ki_set_ccr(uint32_t value)
/* Set the status register and check for interrupts */
INLINE void m68ki_set_sr(uint32_t value)
INLINE void m68ki_set_sr(uint value)
{
/* Set the status register */
FLAG_T1 = BIT_F(value);
@ -1163,10 +1163,10 @@ INLINE void m68ki_set_sr(uint32_t value)
/* ------------------------- Exception Processing ------------------------- */
/* Initiate exception processing */
INLINE uint32_t m68ki_init_exception(void)
INLINE uint m68ki_init_exception(void)
{
/* Save the old status register */
uint32_t sr = m68ki_get_sr();
uint sr = m68ki_get_sr();
/* Turn off trace flag, clear pending traces */
FLAG_T1 = 0;
@ -1179,7 +1179,7 @@ INLINE uint32_t m68ki_init_exception(void)
}
/* 3 word stack frame (68000 only) */
INLINE void m68ki_stack_frame_3word(uint32_t pc, uint32_t sr)
INLINE void m68ki_stack_frame_3word(uint pc, uint sr)
{
m68ki_push_32(pc);
m68ki_push_16(sr);
@ -1188,7 +1188,7 @@ INLINE void m68ki_stack_frame_3word(uint32_t pc, uint32_t sr)
#if M68K_EMULATE_ADDRESS_ERROR
/* Bus error stack frame (68000 only).
*/
INLINE void m68ki_stack_frame_buserr(uint32_t sr)
INLINE void m68ki_stack_frame_buserr(uint sr)
{
m68ki_push_32(REG_PC);
m68ki_push_16(sr);
@ -1205,9 +1205,9 @@ INLINE void m68ki_stack_frame_buserr(uint32_t sr)
/* Used for Group 2 exceptions.
*/
INLINE void m68ki_exception_trap(uint32_t vector)
INLINE void m68ki_exception_trap(uint vector)
{
uint32_t sr = m68ki_init_exception();
uint sr = m68ki_init_exception();
m68ki_stack_frame_3word(REG_PC, sr);
@ -1218,9 +1218,9 @@ INLINE void m68ki_exception_trap(uint32_t vector)
}
/* Trap#n stacks a 0 frame but behaves like group2 otherwise */
INLINE void m68ki_exception_trapN(uint32_t vector)
INLINE void m68ki_exception_trapN(uint vector)
{
uint32_t sr = m68ki_init_exception();
uint sr = m68ki_init_exception();
m68ki_stack_frame_3word(REG_PC, sr);
m68ki_jump_vector(vector);
@ -1232,7 +1232,7 @@ INLINE void m68ki_exception_trapN(uint32_t vector)
/* Exception for trace mode */
INLINE void m68ki_exception_trace(void)
{
uint32_t sr = m68ki_init_exception();
uint sr = m68ki_init_exception();
#if M68K_EMULATE_ADDRESS_ERROR == OPT_ON
CPU_INSTR_MODE = INSTRUCTION_NO;
@ -1252,7 +1252,7 @@ INLINE void m68ki_exception_trace(void)
/* Exception for privilege violation */
static void m68ki_exception_privilege_violation(void)
{
uint32_t sr = m68ki_init_exception();
uint sr = m68ki_init_exception();
#if M68K_EMULATE_ADDRESS_ERROR == OPT_ON
CPU_INSTR_MODE = INSTRUCTION_NO;
@ -1268,7 +1268,7 @@ static void m68ki_exception_privilege_violation(void)
/* Exception for A-Line instructions */
INLINE void m68ki_exception_1010(void)
{
uint32_t sr = m68ki_init_exception();
uint sr = m68ki_init_exception();
m68ki_stack_frame_3word(REG_PC-2, sr);
m68ki_jump_vector(EXCEPTION_1010);
@ -1279,7 +1279,7 @@ INLINE void m68ki_exception_1010(void)
/* Exception for F-Line instructions */
INLINE void m68ki_exception_1111(void)
{
uint32_t sr = m68ki_init_exception();
uint sr = m68ki_init_exception();
m68ki_stack_frame_3word(REG_PC-2, sr);
m68ki_jump_vector(EXCEPTION_1111);
@ -1290,7 +1290,7 @@ INLINE void m68ki_exception_1111(void)
/* Exception for illegal instructions */
INLINE void m68ki_exception_illegal(void)
{
uint32_t sr = m68ki_init_exception();
uint sr = m68ki_init_exception();
#if M68K_EMULATE_ADDRESS_ERROR == OPT_ON
CPU_INSTR_MODE = INSTRUCTION_NO;
@ -1308,7 +1308,7 @@ INLINE void m68ki_exception_illegal(void)
/* Exception for address error */
INLINE void m68ki_exception_address_error(void)
{
uint32_t sr = m68ki_init_exception();
uint sr = m68ki_init_exception();
/* If we were processing a bus error, address error, or reset,
* this is a catastrophic failure.
@ -1333,9 +1333,9 @@ INLINE void m68ki_exception_address_error(void)
#endif
/* Service an interrupt request and start exception processing */
INLINE void m68ki_exception_interrupt(uint32_t int_level)
INLINE void m68ki_exception_interrupt(uint int_level)
{
uint32_t vector, sr, new_pc;
uint vector, sr, new_pc;
#if M68K_EMULATE_ADDRESS_ERROR == OPT_ON
CPU_INSTR_MODE = INSTRUCTION_NO;

7210
core/m68k/m68kops.h
View File

File diff suppressed because it is too large Load Diff