From 18f166bc97548e2d260d66d9904981883ac1e2f3 Mon Sep 17 00:00:00 2001 From: rofl0r Date: Fri, 6 Dec 2024 18:03:16 +0000 Subject: [PATCH] rename FASTCALL to DESMUME_FASTCALL mingw's winnt.h uses FASTCALL for its own purposes, so depending on the include order the code uses either mingw's definition, or the one from types.h. that makes it almost impossible to reason which definition ends up being used, even though it's of utmost importance to have the jit perform correctly. --- desmume/src/MMU.cpp | 76 +- desmume/src/MMU.h | 68 +- desmume/src/arm_instructions.cpp | 1042 ++++++++++----------- desmume/src/arm_jit.cpp | 44 +- desmume/src/arm_jit.h | 2 +- desmume/src/armcpu.cpp | 32 +- desmume/src/gdbstub/gdbstub.cpp | 16 +- desmume/src/instructions.h | 2 +- desmume/src/thumb_instructions.cpp | 140 +-- desmume/src/types.h | 8 +- desmume/src/utils/arm_jit/arm_jit_arm.cpp | 44 +- 11 files changed, 737 insertions(+), 737 deletions(-) diff --git a/desmume/src/MMU.cpp b/desmume/src/MMU.cpp index 28cadaa30..581996a21 100644 --- a/desmume/src/MMU.cpp +++ b/desmume/src/MMU.cpp @@ -1293,7 +1293,7 @@ void GC_Command::fromCryptoBuffer(u32 buf[2]) } template -void FASTCALL MMU_writeToGCControl(u32 val) +void DESMUME_FASTCALL MMU_writeToGCControl(u32 val) { int dbsize = (val>>24)&7; @@ -1374,7 +1374,7 @@ void FASTCALL MMU_writeToGCControl(u32 val) } /*template -u32 FASTCALL MMU_readFromGCControl() +u32 DESMUME_FASTCALL MMU_readFromGCControl() { return T1ReadLong(MMU.MMU_MEM[0][0x40], 0x1A4); }*/ @@ -1452,7 +1452,7 @@ static void CalculateTouchPressure(int pressurePercent, u16 &z1, u16& z2) } -void FASTCALL MMU_writeToSPIData(u16 val) +void DESMUME_FASTCALL MMU_writeToSPIData(u16 val) { enum PM_Bits //from libnds @@ -3332,7 +3332,7 @@ template bool MMU_WriteFromExternal(const int targetProc, const u32 targ //========================================================================================================= //========================================================================================================= //================================================= MMU write 08 -void FASTCALL _MMU_ARM9_write08(u32 adr, u8 val) +void DESMUME_FASTCALL _MMU_ARM9_write08(u32 adr, u8 val) { adr &= 0x0FFFFFFF; const u32 adrBank = (adr >> 24); @@ -3888,7 +3888,7 @@ void FASTCALL _MMU_ARM9_write08(u32 adr, u8 val) } //================================================= MMU ARM9 write 16 -void FASTCALL _MMU_ARM9_write16(u32 adr, u16 val) +void DESMUME_FASTCALL _MMU_ARM9_write16(u32 adr, u16 val) { adr &= 0x0FFFFFFE; const u32 adrBank = (adr >> 24); @@ -4604,7 +4604,7 @@ void FASTCALL _MMU_ARM9_write16(u32 adr, u16 val) } //================================================= MMU ARM9 write 32 -void FASTCALL _MMU_ARM9_write32(u32 adr, u32 val) +void DESMUME_FASTCALL _MMU_ARM9_write32(u32 adr, u32 val) { adr &= 0x0FFFFFFC; const u32 adrBank = (adr >> 24); @@ -5147,7 +5147,7 @@ void FASTCALL _MMU_ARM9_write32(u32 adr, u32 val) } //================================================= MMU ARM9 read 08 -u8 FASTCALL _MMU_ARM9_read08(u32 adr) +u8 DESMUME_FASTCALL _MMU_ARM9_read08(u32 adr) { adr &= 0x0FFFFFFF; @@ -5270,7 +5270,7 @@ u8 FASTCALL _MMU_ARM9_read08(u32 adr) } //================================================= MMU ARM9 read 16 -u16 FASTCALL _MMU_ARM9_read16(u32 adr) +u16 DESMUME_FASTCALL _MMU_ARM9_read16(u32 adr) { adr &= 0x0FFFFFFE; @@ -5380,7 +5380,7 @@ u16 FASTCALL _MMU_ARM9_read16(u32 adr) } //================================================= MMU ARM9 read 32 -u32 FASTCALL _MMU_ARM9_read32(u32 adr) +u32 DESMUME_FASTCALL _MMU_ARM9_read32(u32 adr) { adr &= 0x0FFFFFFC; @@ -5530,7 +5530,7 @@ u32 FASTCALL _MMU_ARM9_read32(u32 adr) //========================================================================================================= //========================================================================================================= //================================================= MMU ARM7 write 08 -void FASTCALL _MMU_ARM7_write08(u32 adr, u8 val) +void DESMUME_FASTCALL _MMU_ARM7_write08(u32 adr, u8 val) { adr &= 0x0FFFFFFF; @@ -5658,7 +5658,7 @@ void FASTCALL _MMU_ARM7_write08(u32 adr, u8 val) } //================================================= MMU ARM7 write 16 -void FASTCALL _MMU_ARM7_write16(u32 adr, u16 val) +void DESMUME_FASTCALL _MMU_ARM7_write16(u32 adr, u16 val) { adr &= 0x0FFFFFFE; @@ -5843,7 +5843,7 @@ void FASTCALL _MMU_ARM7_write16(u32 adr, u16 val) T1WriteWord(MMU.MMU_MEM[ARMCPU_ARM7][adr>>20], adr&MMU.MMU_MASK[ARMCPU_ARM7][adr>>20], val); } //================================================= MMU ARM7 write 32 -void FASTCALL _MMU_ARM7_write32(u32 adr, u32 val) +void DESMUME_FASTCALL _MMU_ARM7_write32(u32 adr, u32 val) { adr &= 0x0FFFFFFC; @@ -5946,7 +5946,7 @@ void FASTCALL _MMU_ARM7_write32(u32 adr, u32 val) } //================================================= MMU ARM7 read 08 -u8 FASTCALL _MMU_ARM7_read08(u32 adr) +u8 DESMUME_FASTCALL _MMU_ARM7_read08(u32 adr) { adr &= 0x0FFFFFFF; @@ -6028,7 +6028,7 @@ u8 FASTCALL _MMU_ARM7_read08(u32 adr) return MMU.MMU_MEM[ARMCPU_ARM7][adr>>20][adr&MMU.MMU_MASK[ARMCPU_ARM7][adr>>20]]; } //================================================= MMU ARM7 read 16 -u16 FASTCALL _MMU_ARM7_read16(u32 adr) +u16 DESMUME_FASTCALL _MMU_ARM7_read16(u32 adr) { adr &= 0x0FFFFFFE; @@ -6114,7 +6114,7 @@ u16 FASTCALL _MMU_ARM7_read16(u32 adr) return T1ReadWord_guaranteedAligned(MMU.MMU_MEM[ARMCPU_ARM7][adr >> 20], adr & MMU.MMU_MASK[ARMCPU_ARM7][adr >> 20]); } //================================================= MMU ARM7 read 32 -u32 FASTCALL _MMU_ARM7_read32(u32 adr) +u32 DESMUME_FASTCALL _MMU_ARM7_read32(u32 adr) { adr &= 0x0FFFFFFC; @@ -6198,7 +6198,7 @@ u32 FASTCALL _MMU_ARM7_read32(u32 adr) //========================================================================================================= -u32 FASTCALL MMU_read32(u32 proc, u32 adr) +u32 DESMUME_FASTCALL MMU_read32(u32 proc, u32 adr) { ASSERT_UNALIGNED((adr&3)==0); @@ -6208,7 +6208,7 @@ u32 FASTCALL MMU_read32(u32 proc, u32 adr) return _MMU_ARM7_read32(adr); } -u16 FASTCALL MMU_read16(u32 proc, u32 adr) +u16 DESMUME_FASTCALL MMU_read16(u32 proc, u32 adr) { ASSERT_UNALIGNED((adr&1)==0); @@ -6218,7 +6218,7 @@ u16 FASTCALL MMU_read16(u32 proc, u32 adr) return _MMU_ARM7_read16(adr); } -u8 FASTCALL MMU_read8(u32 proc, u32 adr) +u8 DESMUME_FASTCALL MMU_read8(u32 proc, u32 adr) { if(proc==0) return _MMU_ARM9_read08(adr); @@ -6226,7 +6226,7 @@ u8 FASTCALL MMU_read8(u32 proc, u32 adr) return _MMU_ARM7_read08(adr); } -void FASTCALL MMU_write32(u32 proc, u32 adr, u32 val) +void DESMUME_FASTCALL MMU_write32(u32 proc, u32 adr, u32 val) { ASSERT_UNALIGNED((adr&3)==0); @@ -6236,7 +6236,7 @@ void FASTCALL MMU_write32(u32 proc, u32 adr, u32 val) _MMU_ARM7_write32(adr,val); } -void FASTCALL MMU_write16(u32 proc, u32 adr, u16 val) +void DESMUME_FASTCALL MMU_write16(u32 proc, u32 adr, u16 val) { ASSERT_UNALIGNED((adr&1)==0); @@ -6246,7 +6246,7 @@ void FASTCALL MMU_write16(u32 proc, u32 adr, u16 val) _MMU_ARM7_write16(adr,val); } -void FASTCALL MMU_write8(u32 proc, u32 adr, u8 val) +void DESMUME_FASTCALL MMU_write8(u32 proc, u32 adr, u8 val) { if(proc==0) _MMU_ARM9_write08(adr, val); @@ -6254,7 +6254,7 @@ void FASTCALL MMU_write8(u32 proc, u32 adr, u8 val) _MMU_ARM7_write08(adr,val); } -void FASTCALL MMU_DumpMemBlock(u8 proc, u32 address, u32 size, u8 *buffer) +void DESMUME_FASTCALL MMU_DumpMemBlock(u8 proc, u32 address, u32 size, u8 *buffer) { u32 i; u32 curaddr; @@ -6273,67 +6273,67 @@ template u32 MMU_struct::gen_IF(); //////////////////////////////////////////////////////////// //function pointer handlers for gdb stub stuff -static u16 FASTCALL arm9_prefetch16( void *data, u32 adr) { +static u16 DESMUME_FASTCALL arm9_prefetch16( void *data, u32 adr) { return _MMU_read16(adr); } -static u32 FASTCALL arm9_prefetch32( void *data, u32 adr) { +static u32 DESMUME_FASTCALL arm9_prefetch32( void *data, u32 adr) { return _MMU_read32(adr); } -static u8 FASTCALL arm9_read8( void *data, u32 adr) { +static u8 DESMUME_FASTCALL arm9_read8( void *data, u32 adr) { return _MMU_read08(adr); } -static u16 FASTCALL arm9_read16( void *data, u32 adr) { +static u16 DESMUME_FASTCALL arm9_read16( void *data, u32 adr) { return _MMU_read16(adr); } -static u32 FASTCALL arm9_read32( void *data, u32 adr) { +static u32 DESMUME_FASTCALL arm9_read32( void *data, u32 adr) { return _MMU_read32(adr); } -static void FASTCALL arm9_write8(void *data, u32 adr, u8 val) { +static void DESMUME_FASTCALL arm9_write8(void *data, u32 adr, u8 val) { _MMU_write08(adr, val); } -static void FASTCALL arm9_write16(void *data, u32 adr, u16 val) { +static void DESMUME_FASTCALL arm9_write16(void *data, u32 adr, u16 val) { _MMU_write16(adr, val); } -static void FASTCALL arm9_write32(void *data, u32 adr, u32 val) { +static void DESMUME_FASTCALL arm9_write32(void *data, u32 adr, u32 val) { _MMU_write32(adr, val); } -static u16 FASTCALL arm7_prefetch16( void *data, u32 adr) { +static u16 DESMUME_FASTCALL arm7_prefetch16( void *data, u32 adr) { return _MMU_read16(adr); } -static u32 FASTCALL arm7_prefetch32( void *data, u32 adr) { +static u32 DESMUME_FASTCALL arm7_prefetch32( void *data, u32 adr) { return _MMU_read32(adr); } -static u8 FASTCALL arm7_read8( void *data, u32 adr) { +static u8 DESMUME_FASTCALL arm7_read8( void *data, u32 adr) { return _MMU_read08(adr); } -static u16 FASTCALL arm7_read16( void *data, u32 adr) { +static u16 DESMUME_FASTCALL arm7_read16( void *data, u32 adr) { return _MMU_read16(adr); } -static u32 FASTCALL arm7_read32( void *data, u32 adr) { +static u32 DESMUME_FASTCALL arm7_read32( void *data, u32 adr) { return _MMU_read32(adr); } -static void FASTCALL arm7_write8(void *data, u32 adr, u8 val) { +static void DESMUME_FASTCALL arm7_write8(void *data, u32 adr, u8 val) { _MMU_write08(adr, val); } -static void FASTCALL arm7_write16(void *data, u32 adr, u16 val) { +static void DESMUME_FASTCALL arm7_write16(void *data, u32 adr, u16 val) { _MMU_write16(adr, val); } -static void FASTCALL arm7_write32(void *data, u32 adr, u32 val) { +static void DESMUME_FASTCALL arm7_write32(void *data, u32 adr, u32 val) { _MMU_write32(adr, val); } diff --git a/desmume/src/MMU.h b/desmume/src/MMU.h index 2fc5d0af9..eebcad627 100644 --- a/desmume/src/MMU.h +++ b/desmume/src/MMU.h @@ -514,24 +514,24 @@ extern MMU_struct_new MMU_new; struct armcpu_memory_iface { /** the 32 bit instruction prefetch */ - u32 FASTCALL (*prefetch32)( void *data, u32 adr); + u32 DESMUME_FASTCALL (*prefetch32)( void *data, u32 adr); /** the 16 bit instruction prefetch */ - u16 FASTCALL (*prefetch16)( void *data, u32 adr); + u16 DESMUME_FASTCALL (*prefetch16)( void *data, u32 adr); /** read 8 bit data value */ - u8 FASTCALL (*read8)( void *data, u32 adr); + u8 DESMUME_FASTCALL (*read8)( void *data, u32 adr); /** read 16 bit data value */ - u16 FASTCALL (*read16)( void *data, u32 adr); + u16 DESMUME_FASTCALL (*read16)( void *data, u32 adr); /** read 32 bit data value */ - u32 FASTCALL (*read32)( void *data, u32 adr); + u32 DESMUME_FASTCALL (*read32)( void *data, u32 adr); /** write 8 bit data value */ - void FASTCALL (*write8)( void *data, u32 adr, u8 val); + void DESMUME_FASTCALL (*write8)( void *data, u32 adr, u8 val); /** write 16 bit data value */ - void FASTCALL (*write16)( void *data, u32 adr, u16 val); + void DESMUME_FASTCALL (*write16)( void *data, u32 adr, u16 val); /** write 32 bit data value */ - void FASTCALL (*write32)( void *data, u32 adr, u32 val); + void DESMUME_FASTCALL (*write32)( void *data, u32 adr, u32 val); void *data; }; @@ -545,14 +545,14 @@ void MMU_Reset( void); void print_memory_profiling( void); // Memory reading/writing (old) -u8 FASTCALL MMU_read8(u32 proc, u32 adr); -u16 FASTCALL MMU_read16(u32 proc, u32 adr); -u32 FASTCALL MMU_read32(u32 proc, u32 adr); -void FASTCALL MMU_write8(u32 proc, u32 adr, u8 val); -void FASTCALL MMU_write16(u32 proc, u32 adr, u16 val); -void FASTCALL MMU_write32(u32 proc, u32 adr, u32 val); +u8 DESMUME_FASTCALL MMU_read8(u32 proc, u32 adr); +u16 DESMUME_FASTCALL MMU_read16(u32 proc, u32 adr); +u32 DESMUME_FASTCALL MMU_read32(u32 proc, u32 adr); +void DESMUME_FASTCALL MMU_write8(u32 proc, u32 adr, u8 val); +void DESMUME_FASTCALL MMU_write16(u32 proc, u32 adr, u16 val); +void DESMUME_FASTCALL MMU_write32(u32 proc, u32 adr, u32 val); -//template void FASTCALL MMU_doDMA(u32 num); +//template void DESMUME_FASTCALL MMU_doDMA(u32 num); //The base ARM memory interfaces extern const armcpu_memory_iface arm9_base_memory_iface; @@ -645,19 +645,19 @@ template FORCEINLINE void _MMU_write08(u32 addr, u8 val) { _MMU_wri template FORCEINLINE void _MMU_write16(u32 addr, u16 val) { _MMU_write16(addr,val); } template FORCEINLINE void _MMU_write32(u32 addr, u32 val) { _MMU_write32(addr,val); } -void FASTCALL _MMU_ARM9_write08(u32 adr, u8 val); -void FASTCALL _MMU_ARM9_write16(u32 adr, u16 val); -void FASTCALL _MMU_ARM9_write32(u32 adr, u32 val); -u8 FASTCALL _MMU_ARM9_read08(u32 adr); -u16 FASTCALL _MMU_ARM9_read16(u32 adr); -u32 FASTCALL _MMU_ARM9_read32(u32 adr); +void DESMUME_FASTCALL _MMU_ARM9_write08(u32 adr, u8 val); +void DESMUME_FASTCALL _MMU_ARM9_write16(u32 adr, u16 val); +void DESMUME_FASTCALL _MMU_ARM9_write32(u32 adr, u32 val); +u8 DESMUME_FASTCALL _MMU_ARM9_read08(u32 adr); +u16 DESMUME_FASTCALL _MMU_ARM9_read16(u32 adr); +u32 DESMUME_FASTCALL _MMU_ARM9_read32(u32 adr); -void FASTCALL _MMU_ARM7_write08(u32 adr, u8 val); -void FASTCALL _MMU_ARM7_write16(u32 adr, u16 val); -void FASTCALL _MMU_ARM7_write32(u32 adr, u32 val); -u8 FASTCALL _MMU_ARM7_read08(u32 adr); -u16 FASTCALL _MMU_ARM7_read16(u32 adr); -u32 FASTCALL _MMU_ARM7_read32(u32 adr); +void DESMUME_FASTCALL _MMU_ARM7_write08(u32 adr, u8 val); +void DESMUME_FASTCALL _MMU_ARM7_write16(u32 adr, u16 val); +void DESMUME_FASTCALL _MMU_ARM7_write32(u32 adr, u32 val); +u8 DESMUME_FASTCALL _MMU_ARM7_read08(u32 adr); +u16 DESMUME_FASTCALL _MMU_ARM7_read16(u32 adr); +u32 DESMUME_FASTCALL _MMU_ARM7_read32(u32 adr); extern u32 partie; @@ -1047,12 +1047,12 @@ FORCEINLINE void _MMU_write32(const int PROCNUM, const MMU_ACCESS_TYPE AT, const //#ifdef MMU_ENABLE_ACL -// void FASTCALL MMU_write8_acl(u32 proc, u32 adr, u8 val); -// void FASTCALL MMU_write16_acl(u32 proc, u32 adr, u16 val); -// void FASTCALL MMU_write32_acl(u32 proc, u32 adr, u32 val); -// u8 FASTCALL MMU_read8_acl(u32 proc, u32 adr, u32 access); -// u16 FASTCALL MMU_read16_acl(u32 proc, u32 adr, u32 access); -// u32 FASTCALL MMU_read32_acl(u32 proc, u32 adr, u32 access); +// void DESMUME_FASTCALL MMU_write8_acl(u32 proc, u32 adr, u8 val); +// void DESMUME_FASTCALL MMU_write16_acl(u32 proc, u32 adr, u16 val); +// void DESMUME_FASTCALL MMU_write32_acl(u32 proc, u32 adr, u32 val); +// u8 DESMUME_FASTCALL MMU_read8_acl(u32 proc, u32 adr, u32 access); +// u16 DESMUME_FASTCALL MMU_read16_acl(u32 proc, u32 adr, u32 access); +// u32 DESMUME_FASTCALL MMU_read32_acl(u32 proc, u32 adr, u32 access); //#else // #define MMU_write8_acl(proc, adr, val) _MMU_write08(adr, val) // #define MMU_write16_acl(proc, adr, val) _MMU_write16(adr, val) @@ -1097,6 +1097,6 @@ FORCEINLINE void _MMU_write16(u32 addr, u16 val) { _MMU_write16(PROCNUM, AT, add template FORCEINLINE void _MMU_write32(u32 addr, u32 val) { _MMU_write32(PROCNUM, AT, addr, val); } -void FASTCALL MMU_DumpMemBlock(u8 proc, u32 address, u32 size, u8 *buffer); +void DESMUME_FASTCALL MMU_DumpMemBlock(u8 proc, u32 address, u32 size, u8 *buffer); #endif diff --git a/desmume/src/arm_instructions.cpp b/desmume/src/arm_instructions.cpp index e413393d5..b1da7bd39 100644 --- a/desmume/src/arm_instructions.cpp +++ b/desmume/src/arm_instructions.cpp @@ -252,7 +252,7 @@ // Undefined instruction //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_UND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_UND(const u32 i) { TRAPUNDEF(cpu); return 1; @@ -289,110 +289,110 @@ TEMPLATE static u32 FASTCALL OP_UND(const u32 i) cpu->CPSR.bits.Z = (cpu->R[REG_POS(i,12)]==0); \ return a; -TEMPLATE static u32 FASTCALL OP_AND_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_LSL_IMM(const u32 i) { LSL_IMM; OP_AND(1, 3); } -TEMPLATE static u32 FASTCALL OP_AND_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_LSL_REG(const u32 i) { LSL_REG; OP_AND(2, 4); } -TEMPLATE static u32 FASTCALL OP_AND_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_LSR_IMM(const u32 i) { LSR_IMM; OP_AND(1, 3); } -TEMPLATE static u32 FASTCALL OP_AND_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_LSR_REG(const u32 i) { LSR_REG; OP_AND(2, 4); } -TEMPLATE static u32 FASTCALL OP_AND_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_ASR_IMM(const u32 i) { ASR_IMM; OP_AND(1, 3); } -TEMPLATE static u32 FASTCALL OP_AND_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_ASR_REG(const u32 i) { ASR_REG; OP_AND(2, 4); } -TEMPLATE static u32 FASTCALL OP_AND_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_ROR_IMM(const u32 i) { ROR_IMM; OP_AND(1, 3); } -TEMPLATE static u32 FASTCALL OP_AND_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_ROR_REG(const u32 i) { ROR_REG; OP_AND(2, 4); } -TEMPLATE static u32 FASTCALL OP_AND_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_IMM_VAL(const u32 i) { IMM_VALUE; OP_AND(1, 3); } -TEMPLATE static u32 FASTCALL OP_AND_S_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_S_LSL_IMM(const u32 i) { S_LSL_IMM; OP_ANDS(1, 3); } -TEMPLATE static u32 FASTCALL OP_AND_S_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_S_LSL_REG(const u32 i) { S_LSL_REG; OP_ANDS(2, 4); } -TEMPLATE static u32 FASTCALL OP_AND_S_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_S_LSR_IMM(const u32 i) { S_LSR_IMM; OP_ANDS(1, 3); } -TEMPLATE static u32 FASTCALL OP_AND_S_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_S_LSR_REG(const u32 i) { S_LSR_REG; OP_ANDS(2, 4); } -TEMPLATE static u32 FASTCALL OP_AND_S_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_S_ASR_IMM(const u32 i) { S_ASR_IMM; OP_ANDS(1, 3); } -TEMPLATE static u32 FASTCALL OP_AND_S_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_S_ASR_REG(const u32 i) { S_ASR_REG; OP_ANDS(2, 4); } -TEMPLATE static u32 FASTCALL OP_AND_S_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_S_ROR_IMM(const u32 i) { S_ROR_IMM; OP_ANDS(1, 3); } -TEMPLATE static u32 FASTCALL OP_AND_S_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_S_ROR_REG(const u32 i) { S_ROR_REG; OP_ANDS(2, 4); } -TEMPLATE static u32 FASTCALL OP_AND_S_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND_S_IMM_VAL(const u32 i) { S_IMM_VALUE; OP_ANDS(1, 3); @@ -428,110 +428,110 @@ TEMPLATE static u32 FASTCALL OP_AND_S_IMM_VAL(const u32 i) cpu->CPSR.bits.Z = (cpu->R[REG_POS(i,12)]==0); \ return a; -TEMPLATE static u32 FASTCALL OP_EOR_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_LSL_IMM(const u32 i) { LSL_IMM; OP_EOR(1, 3); } -TEMPLATE static u32 FASTCALL OP_EOR_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_LSL_REG(const u32 i) { LSL_REG; OP_EOR(2, 4); } -TEMPLATE static u32 FASTCALL OP_EOR_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_LSR_IMM(const u32 i) { LSR_IMM; OP_EOR(1, 3); } -TEMPLATE static u32 FASTCALL OP_EOR_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_LSR_REG(const u32 i) { LSR_REG; OP_EOR(2, 4); } -TEMPLATE static u32 FASTCALL OP_EOR_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_ASR_IMM(const u32 i) { ASR_IMM; OP_EOR(1, 3); } -TEMPLATE static u32 FASTCALL OP_EOR_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_ASR_REG(const u32 i) { ASR_REG; OP_EOR(2, 4); } -TEMPLATE static u32 FASTCALL OP_EOR_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_ROR_IMM(const u32 i) { ROR_IMM; OP_EOR(1, 3); } -TEMPLATE static u32 FASTCALL OP_EOR_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_ROR_REG(const u32 i) { ROR_REG; OP_EOR(2, 4); } -TEMPLATE static u32 FASTCALL OP_EOR_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_IMM_VAL(const u32 i) { IMM_VALUE; OP_EOR(1, 3); } -TEMPLATE static u32 FASTCALL OP_EOR_S_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_S_LSL_IMM(const u32 i) { S_LSL_IMM; OP_EORS(1, 3); } -TEMPLATE static u32 FASTCALL OP_EOR_S_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_S_LSL_REG(const u32 i) { S_LSL_REG; OP_EORS(2, 4); } -TEMPLATE static u32 FASTCALL OP_EOR_S_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_S_LSR_IMM(const u32 i) { S_LSR_IMM; OP_EORS(1, 3); } -TEMPLATE static u32 FASTCALL OP_EOR_S_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_S_LSR_REG(const u32 i) { S_LSR_REG; OP_EORS(2, 4); } -TEMPLATE static u32 FASTCALL OP_EOR_S_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_S_ASR_IMM(const u32 i) { S_ASR_IMM; OP_EORS(1, 3); } -TEMPLATE static u32 FASTCALL OP_EOR_S_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_S_ASR_REG(const u32 i) { S_ASR_REG; OP_EORS(2, 4); } -TEMPLATE static u32 FASTCALL OP_EOR_S_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_S_ROR_IMM(const u32 i) { S_ROR_IMM; OP_EORS(1, 3); } -TEMPLATE static u32 FASTCALL OP_EOR_S_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_S_ROR_REG(const u32 i) { S_ROR_REG; OP_EORS(2, 4); } -TEMPLATE static u32 FASTCALL OP_EOR_S_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR_S_IMM_VAL(const u32 i) { S_IMM_VALUE; OP_EORS(1, 3); @@ -568,118 +568,118 @@ TEMPLATE static u32 FASTCALL OP_EOR_S_IMM_VAL(const u32 i) cpu->CPSR.bits.V = OverflowFromSUB(cpu->R[REG_POS(i,12)], v, shift_op); \ return a; -TEMPLATE static u32 FASTCALL OP_SUB_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_LSL_IMM(const u32 i) { LSL_IMM; OP_SUB(1, 3); } -TEMPLATE static u32 FASTCALL OP_SUB_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_LSL_REG(const u32 i) { LSL_REG; OP_SUB(2, 4); } -TEMPLATE static u32 FASTCALL OP_SUB_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_LSR_IMM(const u32 i) { LSR_IMM; OP_SUB(1, 3); } -TEMPLATE static u32 FASTCALL OP_SUB_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_LSR_REG(const u32 i) { LSR_REG; OP_SUB(2, 4); } -TEMPLATE static u32 FASTCALL OP_SUB_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_ASR_IMM(const u32 i) { ASR_IMM; OP_SUB(1, 3); } -TEMPLATE static u32 FASTCALL OP_SUB_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_ASR_REG(const u32 i) { ASR_REG; OP_SUB(2, 4); } -TEMPLATE static u32 FASTCALL OP_SUB_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_ROR_IMM(const u32 i) { ROR_IMM; OP_SUB(1, 3); } -TEMPLATE static u32 FASTCALL OP_SUB_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_ROR_REG(const u32 i) { ROR_REG; OP_SUB(2, 4); } -TEMPLATE static u32 FASTCALL OP_SUB_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_IMM_VAL(const u32 i) { IMM_VALUE; OP_SUB(1, 3); } -TEMPLATE static u32 FASTCALL OP_SUB_S_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_S_LSL_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSL_IMM; OP_SUBS(1, 3); } -TEMPLATE static u32 FASTCALL OP_SUB_S_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_S_LSL_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSL_REG; OP_SUBS(2, 4); } -TEMPLATE static u32 FASTCALL OP_SUB_S_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_S_LSR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSR_IMM; OP_SUBS(1, 3); } -TEMPLATE static u32 FASTCALL OP_SUB_S_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_S_LSR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSR_REG; OP_SUBS(2, 4); } -TEMPLATE static u32 FASTCALL OP_SUB_S_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_S_ASR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ASR_IMM; OP_SUBS(1, 3); } -TEMPLATE static u32 FASTCALL OP_SUB_S_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_S_ASR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ASR_REG; OP_SUBS(2, 4); } -TEMPLATE static u32 FASTCALL OP_SUB_S_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_S_ROR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ROR_IMM; OP_SUBS(1, 3); } -TEMPLATE static u32 FASTCALL OP_SUB_S_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_S_ROR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ROR_REG; OP_SUBS(2, 4); } -TEMPLATE static u32 FASTCALL OP_SUB_S_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_S_IMM_VAL(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; IMM_VALUE; @@ -717,61 +717,61 @@ TEMPLATE static u32 FASTCALL OP_SUB_S_IMM_VAL(const u32 i) cpu->CPSR.bits.V = OverflowFromSUB(cpu->R[REG_POS(i,12)], shift_op, v); \ return a; -TEMPLATE static u32 FASTCALL OP_RSB_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_LSL_IMM(const u32 i) { LSL_IMM; OP_RSB(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSB_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_LSL_REG(const u32 i) { LSL_REG; OP_RSB(2, 4); } -TEMPLATE static u32 FASTCALL OP_RSB_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_LSR_IMM(const u32 i) { LSR_IMM; OP_RSB(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSB_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_LSR_REG(const u32 i) { LSR_REG; OP_RSB(2, 4); } -TEMPLATE static u32 FASTCALL OP_RSB_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_ASR_IMM(const u32 i) { ASR_IMM; OP_RSB(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSB_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_ASR_REG(const u32 i) { ASR_REG; OP_RSB(2, 4); } -TEMPLATE static u32 FASTCALL OP_RSB_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_ROR_IMM(const u32 i) { ROR_IMM; OP_RSB(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSB_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_ROR_REG(const u32 i) { ROR_REG; OP_RSB(2, 4); } -TEMPLATE static u32 FASTCALL OP_RSB_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_IMM_VAL(const u32 i) { IMM_VALUE; OP_RSB(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSB_S_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_S_LSL_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSL_IMM; @@ -779,56 +779,56 @@ TEMPLATE static u32 FASTCALL OP_RSB_S_LSL_IMM(const u32 i) } -TEMPLATE static u32 FASTCALL OP_RSB_S_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_S_LSL_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSL_REG; OP_RSBS(2, 4); } -TEMPLATE static u32 FASTCALL OP_RSB_S_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_S_LSR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSR_IMM; OP_RSBS(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSB_S_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_S_LSR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSR_REG; OP_RSBS(2, 4); } -TEMPLATE static u32 FASTCALL OP_RSB_S_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_S_ASR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ASR_IMM; OP_RSBS(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSB_S_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_S_ASR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ASR_REG; OP_RSBS(2, 4); } -TEMPLATE static u32 FASTCALL OP_RSB_S_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_S_ROR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ROR_IMM; OP_RSBS(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSB_S_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_S_ROR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ROR_REG; OP_RSBS(2, 4); } -TEMPLATE static u32 FASTCALL OP_RSB_S_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSB_S_IMM_VAL(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; IMM_VALUE; @@ -866,118 +866,118 @@ TEMPLATE static u32 FASTCALL OP_RSB_S_IMM_VAL(const u32 i) cpu->CPSR.bits.V = OverflowFromADD(cpu->R[REG_POS(i,12)], v, shift_op); \ return a; -TEMPLATE static u32 FASTCALL OP_ADD_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_LSL_IMM(const u32 i) { LSL_IMM; OP_ADD(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADD_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_LSL_REG(const u32 i) { LSL_REG; OP_ADD(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADD_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_LSR_IMM(const u32 i) { LSR_IMM; OP_ADD(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADD_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_LSR_REG(const u32 i) { LSR_REG; OP_ADD(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADD_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_ASR_IMM(const u32 i) { ASR_IMM; OP_ADD(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADD_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_ASR_REG(const u32 i) { ASR_REG; OP_ADD(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADD_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_ROR_IMM(const u32 i) { ROR_IMM; OP_ADD(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADD_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_ROR_REG(const u32 i) { ROR_REG; OP_ADD(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADD_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_IMM_VAL(const u32 i) { IMM_VALUE; OP_ADD(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADD_S_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_S_LSL_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSL_IMM; OP_ADDS(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADD_S_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_S_LSL_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSL_REG; OP_ADDS(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADD_S_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_S_LSR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSR_IMM; OP_ADDS(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADD_S_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_S_LSR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSR_REG; OP_ADDS(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADD_S_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_S_ASR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ASR_IMM; OP_ADDS(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADD_S_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_S_ASR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ASR_REG; OP_ADDS(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADD_S_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_S_ROR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ROR_IMM; OP_ADDS(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADD_S_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_S_ROR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ROR_REG; OP_ADDS(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADD_S_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_S_IMM_VAL(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; IMM_VALUE; @@ -1025,118 +1025,118 @@ TEMPLATE static u32 FASTCALL OP_ADD_S_IMM_VAL(const u32 i) return a; \ } -TEMPLATE static u32 FASTCALL OP_ADC_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_LSL_IMM(const u32 i) { LSL_IMM; OP_ADC(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADC_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_LSL_REG(const u32 i) { LSL_REG; OP_ADC(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADC_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_LSR_IMM(const u32 i) { LSR_IMM; OP_ADC(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADC_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_LSR_REG(const u32 i) { LSR_REG; OP_ADC(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADC_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_ASR_IMM(const u32 i) { ASR_IMM; OP_ADC(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADC_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_ASR_REG(const u32 i) { ASR_REG; OP_ADC(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADC_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_ROR_IMM(const u32 i) { ROR_IMM; OP_ADC(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADC_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_ROR_REG(const u32 i) { ROR_REG; OP_ADC(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADC_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_IMM_VAL(const u32 i) { IMM_VALUE; OP_ADC(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADC_S_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_S_LSL_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSL_IMM; OP_ADCS(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADC_S_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_S_LSL_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSL_REG; OP_ADCS(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADC_S_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_S_LSR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSR_IMM; OP_ADCS(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADC_S_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_S_LSR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSR_REG; OP_ADCS(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADC_S_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_S_ASR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ASR_IMM; OP_ADCS(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADC_S_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_S_ASR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ASR_REG; OP_ADCS(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADC_S_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_S_ROR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ROR_IMM; OP_ADCS(1, 3); } -TEMPLATE static u32 FASTCALL OP_ADC_S_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_S_ROR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ROR_REG; OP_ADCS(2, 4); } -TEMPLATE static u32 FASTCALL OP_ADC_S_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_S_IMM_VAL(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; IMM_VALUE; @@ -1185,118 +1185,118 @@ TEMPLATE static u32 FASTCALL OP_ADC_S_IMM_VAL(const u32 i) return a; \ } -TEMPLATE static u32 FASTCALL OP_SBC_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_LSL_IMM(const u32 i) { LSL_IMM; OP_SBC(1, 3); } -TEMPLATE static u32 FASTCALL OP_SBC_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_LSL_REG(const u32 i) { LSL_REG; OP_SBC(2, 4); } -TEMPLATE static u32 FASTCALL OP_SBC_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_LSR_IMM(const u32 i) { LSR_IMM; OP_SBC(1, 3); } -TEMPLATE static u32 FASTCALL OP_SBC_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_LSR_REG(const u32 i) { LSR_REG; OP_SBC(2, 4); } -TEMPLATE static u32 FASTCALL OP_SBC_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_ASR_IMM(const u32 i) { ASR_IMM; OP_SBC(1, 3); } -TEMPLATE static u32 FASTCALL OP_SBC_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_ASR_REG(const u32 i) { ASR_REG; OP_SBC(2, 4); } -TEMPLATE static u32 FASTCALL OP_SBC_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_ROR_IMM(const u32 i) { ROR_IMM; OP_SBC(1, 3); } -TEMPLATE static u32 FASTCALL OP_SBC_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_ROR_REG(const u32 i) { ROR_REG; OP_SBC(2, 4); } -TEMPLATE static u32 FASTCALL OP_SBC_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_IMM_VAL(const u32 i) { IMM_VALUE; OP_SBC(1, 3); } -TEMPLATE static u32 FASTCALL OP_SBC_S_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_S_LSL_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSL_IMM; OP_SBCS(1, 3); } -TEMPLATE static u32 FASTCALL OP_SBC_S_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_S_LSL_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSL_REG; OP_SBCS(2, 4); } -TEMPLATE static u32 FASTCALL OP_SBC_S_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_S_LSR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSR_IMM; OP_SBCS(1, 3); } -TEMPLATE static u32 FASTCALL OP_SBC_S_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_S_LSR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSR_REG; OP_SBCS(2, 4); } -TEMPLATE static u32 FASTCALL OP_SBC_S_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_S_ASR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ASR_IMM; OP_SBCS(1, 3); } -TEMPLATE static u32 FASTCALL OP_SBC_S_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_S_ASR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ASR_REG; OP_SBCS(2, 4); } -TEMPLATE static u32 FASTCALL OP_SBC_S_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_S_ROR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ROR_IMM; OP_SBCS(1, 3); } -TEMPLATE static u32 FASTCALL OP_SBC_S_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_S_ROR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ROR_REG; OP_SBCS(2, 4); } -TEMPLATE static u32 FASTCALL OP_SBC_S_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_S_IMM_VAL(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; IMM_VALUE; @@ -1345,118 +1345,118 @@ TEMPLATE static u32 FASTCALL OP_SBC_S_IMM_VAL(const u32 i) return a; \ } -TEMPLATE static u32 FASTCALL OP_RSC_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_LSL_IMM(const u32 i) { LSL_IMM; OP_RSC(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSC_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_LSL_REG(const u32 i) { LSL_REG; OP_RSC(2, 4); } -TEMPLATE static u32 FASTCALL OP_RSC_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_LSR_IMM(const u32 i) { LSR_IMM; OP_RSC(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSC_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_LSR_REG(const u32 i) { LSR_REG; OP_RSC(2, 4); } -TEMPLATE static u32 FASTCALL OP_RSC_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_ASR_IMM(const u32 i) { ASR_IMM; OP_RSC(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSC_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_ASR_REG(const u32 i) { ASR_REG; OP_RSC(2, 4); } -TEMPLATE static u32 FASTCALL OP_RSC_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_ROR_IMM(const u32 i) { ROR_IMM; OP_RSC(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSC_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_ROR_REG(const u32 i) { ROR_REG; OP_RSC(2, 4); } -TEMPLATE static u32 FASTCALL OP_RSC_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_IMM_VAL(const u32 i) { IMM_VALUE; OP_RSC(1, 3); } -TEMPLATE static u32 FASTCALL OP_RSC_S_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_S_LSL_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSL_IMM; OP_RSCS(1,3); } -TEMPLATE static u32 FASTCALL OP_RSC_S_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_S_LSL_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSL_REG; OP_RSCS(2,4); } -TEMPLATE static u32 FASTCALL OP_RSC_S_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_S_LSR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSR_IMM; OP_RSCS(1,3); } -TEMPLATE static u32 FASTCALL OP_RSC_S_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_S_LSR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; LSR_REG; OP_RSCS(2,4); } -TEMPLATE static u32 FASTCALL OP_RSC_S_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_S_ASR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ASR_IMM; OP_RSCS(1,3); } -TEMPLATE static u32 FASTCALL OP_RSC_S_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_S_ASR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ASR_REG; OP_RSCS(2,4); } -TEMPLATE static u32 FASTCALL OP_RSC_S_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_S_ROR_IMM(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ROR_IMM; OP_RSCS(1,3); } -TEMPLATE static u32 FASTCALL OP_RSC_S_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_S_ROR_REG(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; ROR_REG; OP_RSCS(2,4); } -TEMPLATE static u32 FASTCALL OP_RSC_S_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_RSC_S_IMM_VAL(const u32 i) { u32 v = cpu->R[REG_POS(i,16)]; IMM_VALUE; @@ -1476,55 +1476,55 @@ TEMPLATE static u32 FASTCALL OP_RSC_S_IMM_VAL(const u32 i) return a; \ } -TEMPLATE static u32 FASTCALL OP_TST_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TST_LSL_IMM(const u32 i) { S_LSL_IMM; OP_TST(1); } -TEMPLATE static u32 FASTCALL OP_TST_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TST_LSL_REG(const u32 i) { S_LSL_REG; OP_TST(2); } -TEMPLATE static u32 FASTCALL OP_TST_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TST_LSR_IMM(const u32 i) { S_LSR_IMM; OP_TST(1); } -TEMPLATE static u32 FASTCALL OP_TST_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TST_LSR_REG(const u32 i) { S_LSR_REG; OP_TST(2); } -TEMPLATE static u32 FASTCALL OP_TST_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TST_ASR_IMM(const u32 i) { S_ASR_IMM; OP_TST(1); } -TEMPLATE static u32 FASTCALL OP_TST_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TST_ASR_REG(const u32 i) { S_ASR_REG; OP_TST(2); } -TEMPLATE static u32 FASTCALL OP_TST_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TST_ROR_IMM(const u32 i) { S_ROR_IMM; OP_TST(1); } -TEMPLATE static u32 FASTCALL OP_TST_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TST_ROR_REG(const u32 i) { S_ROR_REG; OP_TST(2); } -TEMPLATE static u32 FASTCALL OP_TST_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TST_IMM_VAL(const u32 i) { S_IMM_VALUE; OP_TST(1); @@ -1543,55 +1543,55 @@ TEMPLATE static u32 FASTCALL OP_TST_IMM_VAL(const u32 i) return a; \ } -TEMPLATE static u32 FASTCALL OP_TEQ_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TEQ_LSL_IMM(const u32 i) { S_LSL_IMM; OP_TEQ(1); } -TEMPLATE static u32 FASTCALL OP_TEQ_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TEQ_LSL_REG(const u32 i) { S_LSL_REG; OP_TEQ(2); } -TEMPLATE static u32 FASTCALL OP_TEQ_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TEQ_LSR_IMM(const u32 i) { S_LSR_IMM; OP_TEQ(1); } -TEMPLATE static u32 FASTCALL OP_TEQ_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TEQ_LSR_REG(const u32 i) { S_LSR_REG; OP_TEQ(2); } -TEMPLATE static u32 FASTCALL OP_TEQ_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TEQ_ASR_IMM(const u32 i) { S_ASR_IMM; OP_TEQ(1); } -TEMPLATE static u32 FASTCALL OP_TEQ_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TEQ_ASR_REG(const u32 i) { S_ASR_REG; OP_TEQ(2); } -TEMPLATE static u32 FASTCALL OP_TEQ_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TEQ_ROR_IMM(const u32 i) { S_ROR_IMM; OP_TEQ(1); } -TEMPLATE static u32 FASTCALL OP_TEQ_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TEQ_ROR_REG(const u32 i) { S_ROR_REG; OP_TEQ(2); } -TEMPLATE static u32 FASTCALL OP_TEQ_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TEQ_IMM_VAL(const u32 i) { S_IMM_VALUE; OP_TEQ(1); @@ -1611,55 +1611,55 @@ TEMPLATE static u32 FASTCALL OP_TEQ_IMM_VAL(const u32 i) return a; \ } -TEMPLATE static u32 FASTCALL OP_CMP_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMP_LSL_IMM(const u32 i) { LSL_IMM; OP_CMP(1); } -TEMPLATE static u32 FASTCALL OP_CMP_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMP_LSL_REG(const u32 i) { LSL_REG; OP_CMP(2); } -TEMPLATE static u32 FASTCALL OP_CMP_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMP_LSR_IMM(const u32 i) { LSR_IMM; OP_CMP(1); } -TEMPLATE static u32 FASTCALL OP_CMP_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMP_LSR_REG(const u32 i) { LSR_REG; OP_CMP(2); } -TEMPLATE static u32 FASTCALL OP_CMP_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMP_ASR_IMM(const u32 i) { ASR_IMM; OP_CMP(1); } -TEMPLATE static u32 FASTCALL OP_CMP_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMP_ASR_REG(const u32 i) { ASR_REG; OP_CMP(2); } -TEMPLATE static u32 FASTCALL OP_CMP_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMP_ROR_IMM(const u32 i) { ROR_IMM; OP_CMP(1); } -TEMPLATE static u32 FASTCALL OP_CMP_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMP_ROR_REG(const u32 i) { ROR_REG; OP_CMP(2); } -TEMPLATE static u32 FASTCALL OP_CMP_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMP_IMM_VAL(const u32 i) { IMM_VALUE; OP_CMP(1); @@ -1679,55 +1679,55 @@ TEMPLATE static u32 FASTCALL OP_CMP_IMM_VAL(const u32 i) return a; \ } -TEMPLATE static u32 FASTCALL OP_CMN_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMN_LSL_IMM(const u32 i) { LSL_IMM; OP_CMN(1); } -TEMPLATE static u32 FASTCALL OP_CMN_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMN_LSL_REG(const u32 i) { LSL_REG; OP_CMN(2); } -TEMPLATE static u32 FASTCALL OP_CMN_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMN_LSR_IMM(const u32 i) { LSR_IMM; OP_CMN(1); } -TEMPLATE static u32 FASTCALL OP_CMN_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMN_LSR_REG(const u32 i) { LSR_REG; OP_CMN(2); } -TEMPLATE static u32 FASTCALL OP_CMN_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMN_ASR_IMM(const u32 i) { ASR_IMM; OP_CMN(1); } -TEMPLATE static u32 FASTCALL OP_CMN_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMN_ASR_REG(const u32 i) { ASR_REG; OP_CMN(2); } -TEMPLATE static u32 FASTCALL OP_CMN_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMN_ROR_IMM(const u32 i) { ROR_IMM; OP_CMN(1); } -TEMPLATE static u32 FASTCALL OP_CMN_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMN_ROR_REG(const u32 i) { ROR_REG; OP_CMN(2); } -TEMPLATE static u32 FASTCALL OP_CMN_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMN_IMM_VAL(const u32 i) { IMM_VALUE; OP_CMN(1); @@ -1765,110 +1765,110 @@ TEMPLATE static u32 FASTCALL OP_CMN_IMM_VAL(const u32 i) return a; \ } -TEMPLATE static u32 FASTCALL OP_ORR_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_LSL_IMM(const u32 i) { LSL_IMM; OP_ORR(1, 3); } -TEMPLATE static u32 FASTCALL OP_ORR_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_LSL_REG(const u32 i) { LSL_REG; OP_ORR(2, 4); } -TEMPLATE static u32 FASTCALL OP_ORR_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_LSR_IMM(const u32 i) { LSR_IMM; OP_ORR(1, 3); } -TEMPLATE static u32 FASTCALL OP_ORR_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_LSR_REG(const u32 i) { LSR_REG; OP_ORR(2, 4); } -TEMPLATE static u32 FASTCALL OP_ORR_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_ASR_IMM(const u32 i) { ASR_IMM; OP_ORR(1, 3); } -TEMPLATE static u32 FASTCALL OP_ORR_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_ASR_REG(const u32 i) { ASR_REG; OP_ORR(2, 4); } -TEMPLATE static u32 FASTCALL OP_ORR_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_ROR_IMM(const u32 i) { ROR_IMM; OP_ORR(1, 3); } -TEMPLATE static u32 FASTCALL OP_ORR_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_ROR_REG(const u32 i) { ROR_REG; OP_ORR(2, 4); } -TEMPLATE static u32 FASTCALL OP_ORR_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_IMM_VAL(const u32 i) { IMM_VALUE; OP_ORR(1, 3); } -TEMPLATE static u32 FASTCALL OP_ORR_S_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_S_LSL_IMM(const u32 i) { S_LSL_IMM; OP_ORRS(1,3); } -TEMPLATE static u32 FASTCALL OP_ORR_S_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_S_LSL_REG(const u32 i) { S_LSL_REG; OP_ORRS(2,4); } -TEMPLATE static u32 FASTCALL OP_ORR_S_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_S_LSR_IMM(const u32 i) { S_LSR_IMM; OP_ORRS(1,3); } -TEMPLATE static u32 FASTCALL OP_ORR_S_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_S_LSR_REG(const u32 i) { S_LSR_REG; OP_ORRS(2,4); } -TEMPLATE static u32 FASTCALL OP_ORR_S_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_S_ASR_IMM(const u32 i) { S_ASR_IMM; OP_ORRS(1,3); } -TEMPLATE static u32 FASTCALL OP_ORR_S_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_S_ASR_REG(const u32 i) { S_ASR_REG; OP_ORRS(2,4); } -TEMPLATE static u32 FASTCALL OP_ORR_S_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_S_ROR_IMM(const u32 i) { S_ROR_IMM; OP_ORRS(1,3); } -TEMPLATE static u32 FASTCALL OP_ORR_S_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_S_ROR_REG(const u32 i) { S_ROR_REG; OP_ORRS(2,4); } -TEMPLATE static u32 FASTCALL OP_ORR_S_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR_S_IMM_VAL(const u32 i) { S_IMM_VALUE; OP_ORRS(1,3); @@ -1904,7 +1904,7 @@ TEMPLATE static u32 FASTCALL OP_ORR_S_IMM_VAL(const u32 i) cpu->CPSR.bits.Z = (cpu->R[REG_POS(i,12)]==0); \ return a; -TEMPLATE static u32 FASTCALL OP_MOV_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_LSL_IMM(const u32 i) { if (i == 0xE1A00000) // nop: MOV R0, R0 return 1; @@ -1913,108 +1913,108 @@ TEMPLATE static u32 FASTCALL OP_MOV_LSL_IMM(const u32 i) OP_MOV(1,3); } -TEMPLATE static u32 FASTCALL OP_MOV_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_LSL_REG(const u32 i) { LSL_REG; if (REG_POS(i,0) == 15) shift_op += 4; OP_MOV(2,4); } -TEMPLATE static u32 FASTCALL OP_MOV_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_LSR_IMM(const u32 i) { LSR_IMM; OP_MOV(1,3); } -TEMPLATE static u32 FASTCALL OP_MOV_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_LSR_REG(const u32 i) { LSR_REG; if (REG_POS(i,0) == 15) shift_op += 4; OP_MOV(2,4); } -TEMPLATE static u32 FASTCALL OP_MOV_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_ASR_IMM(const u32 i) { ASR_IMM; OP_MOV(1,3); } -TEMPLATE static u32 FASTCALL OP_MOV_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_ASR_REG(const u32 i) { ASR_REG; OP_MOV(2,4); } -TEMPLATE static u32 FASTCALL OP_MOV_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_ROR_IMM(const u32 i) { ROR_IMM; OP_MOV(1,3); } -TEMPLATE static u32 FASTCALL OP_MOV_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_ROR_REG(const u32 i) { ROR_REG; OP_MOV(2,4); } -TEMPLATE static u32 FASTCALL OP_MOV_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_IMM_VAL(const u32 i) { IMM_VALUE; OP_MOV(1,3); } -TEMPLATE static u32 FASTCALL OP_MOV_S_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_S_LSL_IMM(const u32 i) { S_LSL_IMM; OP_MOVS(1,3); } -TEMPLATE static u32 FASTCALL OP_MOV_S_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_S_LSL_REG(const u32 i) { S_LSL_REG; if (REG_POS(i,0) == 15) shift_op += 4; OP_MOVS(2,4); } -TEMPLATE static u32 FASTCALL OP_MOV_S_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_S_LSR_IMM(const u32 i) { S_LSR_IMM; OP_MOVS(1,3); } -TEMPLATE static u32 FASTCALL OP_MOV_S_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_S_LSR_REG(const u32 i) { S_LSR_REG; if (REG_POS(i,0) == 15) shift_op += 4; OP_MOVS(2,4); } -TEMPLATE static u32 FASTCALL OP_MOV_S_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_S_ASR_IMM(const u32 i) { S_ASR_IMM; OP_MOVS(1,3); } -TEMPLATE static u32 FASTCALL OP_MOV_S_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_S_ASR_REG(const u32 i) { S_ASR_REG; OP_MOVS(2,4); } -TEMPLATE static u32 FASTCALL OP_MOV_S_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_S_ROR_IMM(const u32 i) { S_ROR_IMM; OP_MOVS(1,3); } -TEMPLATE static u32 FASTCALL OP_MOV_S_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_S_ROR_REG(const u32 i) { S_ROR_REG; OP_MOVS(2,4); } -TEMPLATE static u32 FASTCALL OP_MOV_S_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_S_IMM_VAL(const u32 i) { S_IMM_VALUE; OP_MOVS(1,3); @@ -2050,110 +2050,110 @@ TEMPLATE static u32 FASTCALL OP_MOV_S_IMM_VAL(const u32 i) cpu->CPSR.bits.Z = (cpu->R[REG_POS(i,12)]==0); \ return a; -TEMPLATE static u32 FASTCALL OP_BIC_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_LSL_IMM(const u32 i) { LSL_IMM; OP_BIC(1,3); } -TEMPLATE static u32 FASTCALL OP_BIC_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_LSL_REG(const u32 i) { LSL_REG; OP_BIC(2,4); } -TEMPLATE static u32 FASTCALL OP_BIC_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_LSR_IMM(const u32 i) { LSR_IMM; OP_BIC(1,3); } -TEMPLATE static u32 FASTCALL OP_BIC_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_LSR_REG(const u32 i) { LSR_REG; OP_BIC(2,4); } -TEMPLATE static u32 FASTCALL OP_BIC_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_ASR_IMM(const u32 i) { ASR_IMM; OP_BIC(1,3); } -TEMPLATE static u32 FASTCALL OP_BIC_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_ASR_REG(const u32 i) { ASR_REG; OP_BIC(2,4); } -TEMPLATE static u32 FASTCALL OP_BIC_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_ROR_IMM(const u32 i) { ROR_IMM; OP_BIC(1,3); } -TEMPLATE static u32 FASTCALL OP_BIC_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_ROR_REG(const u32 i) { ROR_REG; OP_BIC(2,4); } -TEMPLATE static u32 FASTCALL OP_BIC_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_IMM_VAL(const u32 i) { IMM_VALUE; OP_BIC(1,3); } -TEMPLATE static u32 FASTCALL OP_BIC_S_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_S_LSL_IMM(const u32 i) { S_LSL_IMM; OP_BICS(1,3); } -TEMPLATE static u32 FASTCALL OP_BIC_S_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_S_LSL_REG(const u32 i) { S_LSL_REG; OP_BICS(2,4); } -TEMPLATE static u32 FASTCALL OP_BIC_S_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_S_LSR_IMM(const u32 i) { S_LSR_IMM; OP_BICS(1,3); } -TEMPLATE static u32 FASTCALL OP_BIC_S_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_S_LSR_REG(const u32 i) { S_LSR_REG; OP_BICS(2,4); } -TEMPLATE static u32 FASTCALL OP_BIC_S_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_S_ASR_IMM(const u32 i) { S_ASR_IMM; OP_BICS(1,3); } -TEMPLATE static u32 FASTCALL OP_BIC_S_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_S_ASR_REG(const u32 i) { S_ASR_REG; OP_BICS(2,4); } -TEMPLATE static u32 FASTCALL OP_BIC_S_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_S_ROR_IMM(const u32 i) { S_ROR_IMM; OP_BICS(1,3); } -TEMPLATE static u32 FASTCALL OP_BIC_S_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_S_ROR_REG(const u32 i) { S_ROR_REG; OP_BICS(2,4); } -TEMPLATE static u32 FASTCALL OP_BIC_S_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC_S_IMM_VAL(const u32 i) { S_IMM_VALUE; OP_BICS(1,3); @@ -2189,109 +2189,109 @@ TEMPLATE static u32 FASTCALL OP_BIC_S_IMM_VAL(const u32 i) cpu->CPSR.bits.Z = (cpu->R[REG_POS(i,12)]==0); \ return a; -TEMPLATE static u32 FASTCALL OP_MVN_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_LSL_IMM(const u32 i) { LSL_IMM; OP_MVN(1,3); } -TEMPLATE static u32 FASTCALL OP_MVN_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_LSL_REG(const u32 i) { LSL_REG; OP_MVN(2,4); } -TEMPLATE static u32 FASTCALL OP_MVN_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_LSR_IMM(const u32 i) { LSR_IMM; OP_MVN(1,3); } -TEMPLATE static u32 FASTCALL OP_MVN_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_LSR_REG(const u32 i) { LSR_REG; OP_MVN(2,4); } -TEMPLATE static u32 FASTCALL OP_MVN_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_ASR_IMM(const u32 i) { ASR_IMM; OP_MVN(1,3); } -TEMPLATE static u32 FASTCALL OP_MVN_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_ASR_REG(const u32 i) { ASR_REG; OP_MVN(2,4); } -TEMPLATE static u32 FASTCALL OP_MVN_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_ROR_IMM(const u32 i) { ROR_IMM; OP_MVN(1,3); } -TEMPLATE static u32 FASTCALL OP_MVN_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_ROR_REG(const u32 i) { ROR_REG; OP_MVN(2,4); } -TEMPLATE static u32 FASTCALL OP_MVN_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_IMM_VAL(const u32 i) { IMM_VALUE; OP_MVN(1,3); } -TEMPLATE static u32 FASTCALL OP_MVN_S_LSL_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_S_LSL_IMM(const u32 i) { S_LSL_IMM; OP_MVNS(1,3); } -TEMPLATE static u32 FASTCALL OP_MVN_S_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_S_LSL_REG(const u32 i) { S_LSL_REG; OP_MVNS(2,4); } -TEMPLATE static u32 FASTCALL OP_MVN_S_LSR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_S_LSR_IMM(const u32 i) { S_LSR_IMM; OP_MVNS(1,3); } -TEMPLATE static u32 FASTCALL OP_MVN_S_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_S_LSR_REG(const u32 i) { S_LSR_REG; OP_MVNS(2,4); } -TEMPLATE static u32 FASTCALL OP_MVN_S_ASR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_S_ASR_IMM(const u32 i) { S_ASR_IMM; OP_MVNS(1,3); } -TEMPLATE static u32 FASTCALL OP_MVN_S_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_S_ASR_REG(const u32 i) { S_ASR_REG; OP_MVNS(2,4); } -TEMPLATE static u32 FASTCALL OP_MVN_S_ROR_IMM(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_S_ROR_IMM(const u32 i) { S_ROR_IMM; OP_MVNS(1,3); } -TEMPLATE static u32 FASTCALL OP_MVN_S_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_S_ROR_REG(const u32 i) { S_ROR_REG; OP_MVNS(2,4); } -TEMPLATE static u32 FASTCALL OP_MVN_S_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN_S_IMM_VAL(const u32 i) { S_IMM_VALUE; OP_MVNS(1,3); @@ -2314,7 +2314,7 @@ TEMPLATE static u32 FASTCALL OP_MVN_S_IMM_VAL(const u32 i) return c+4; \ -TEMPLATE static u32 FASTCALL OP_MUL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MUL(const u32 i) { u32 v = cpu->R[REG_POS(i,8)]; cpu->R[REG_POS(i,16)] = cpu->R[REG_POS(i,0)] * v; @@ -2322,7 +2322,7 @@ TEMPLATE static u32 FASTCALL OP_MUL(const u32 i) MUL_Mxx_END(1); } -TEMPLATE static u32 FASTCALL OP_MLA(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MLA(const u32 i) { u32 v = cpu->R[REG_POS(i,8)]; cpu->R[REG_POS(i,16)] = cpu->R[REG_POS(i,0)] * v + cpu->R[REG_POS(i,12)]; @@ -2330,7 +2330,7 @@ TEMPLATE static u32 FASTCALL OP_MLA(const u32 i) MUL_Mxx_END(2); } -TEMPLATE static u32 FASTCALL OP_MUL_S(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MUL_S(const u32 i) { u32 v = cpu->R[REG_POS(i,8)]; cpu->R[REG_POS(i,16)] = cpu->R[REG_POS(i,0)] * v; @@ -2341,7 +2341,7 @@ TEMPLATE static u32 FASTCALL OP_MUL_S(const u32 i) MUL_Mxx_END(1); } -TEMPLATE static u32 FASTCALL OP_MLA_S(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MLA_S(const u32 i) { u32 v = cpu->R[REG_POS(i,8)]; cpu->R[REG_POS(i,16)] = cpu->R[REG_POS(i,0)] * v + cpu->R[REG_POS(i,12)]; @@ -2368,7 +2368,7 @@ TEMPLATE static u32 FASTCALL OP_MLA_S(const u32 i) return c+4; \ -TEMPLATE static u32 FASTCALL OP_UMULL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_UMULL(const u32 i) { u32 v = cpu->R[REG_POS(i,8)]; u64 res = (u64)cpu->R[REG_POS(i,0)] * (u64)v; @@ -2379,7 +2379,7 @@ TEMPLATE static u32 FASTCALL OP_UMULL(const u32 i) MUL_UMxxL_END(2); } -TEMPLATE static u32 FASTCALL OP_UMLAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_UMLAL(const u32 i) { u32 v = cpu->R[REG_POS(i,8)]; u64 res = (u64)cpu->R[REG_POS(i,0)] * (u64)v; @@ -2393,7 +2393,7 @@ TEMPLATE static u32 FASTCALL OP_UMLAL(const u32 i) MUL_UMxxL_END(3); } -TEMPLATE static u32 FASTCALL OP_UMULL_S(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_UMULL_S(const u32 i) { u32 v = cpu->R[REG_POS(i,8)]; u64 res = ((u64)cpu->R[REG_POS(i,0)] * (u64)v); @@ -2407,7 +2407,7 @@ TEMPLATE static u32 FASTCALL OP_UMULL_S(const u32 i) MUL_UMxxL_END(2); } -TEMPLATE static u32 FASTCALL OP_UMLAL_S(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_UMLAL_S(const u32 i) { u32 v = cpu->R[REG_POS(i,8)]; u64 res = (u64)cpu->R[REG_POS(i,0)] * (u64)v; @@ -2442,7 +2442,7 @@ TEMPLATE static u32 FASTCALL OP_UMLAL_S(const u32 i) return c+4; \ -TEMPLATE static u32 FASTCALL OP_SMULL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMULL(const u32 i) { s64 v = (s32)cpu->R[REG_POS(i,8)]; s64 res = v * (s64)(s32)cpu->R[REG_POS(i,0)]; @@ -2453,7 +2453,7 @@ TEMPLATE static u32 FASTCALL OP_SMULL(const u32 i) MUL_SMxxL_END(2); } -TEMPLATE static u32 FASTCALL OP_SMLAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMLAL(const u32 i) { s64 v = (s32)cpu->R[REG_POS(i,8)]; @@ -2470,7 +2470,7 @@ TEMPLATE static u32 FASTCALL OP_SMLAL(const u32 i) MUL_SMxxL_END(3); } -TEMPLATE static u32 FASTCALL OP_SMULL_S(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMULL_S(const u32 i) { s64 v = (s32)cpu->R[REG_POS(i,8)]; s64 res = v * (s64)(s32)cpu->R[REG_POS(i,0)]; @@ -2484,7 +2484,7 @@ TEMPLATE static u32 FASTCALL OP_SMULL_S(const u32 i) MUL_SMxxL_END(2); } -TEMPLATE static u32 FASTCALL OP_SMLAL_S(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMLAL_S(const u32 i) { s64 v = (s32)cpu->R[REG_POS(i,8)]; s64 res = v * (s64)(s32)cpu->R[REG_POS(i,0)]; @@ -2503,7 +2503,7 @@ TEMPLATE static u32 FASTCALL OP_SMLAL_S(const u32 i) // SWP / SWPB //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_SWP(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SWP(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; u32 tmp = ROR(READ32(cpu->mem_if->data, adr), (adr & 3)<<3); @@ -2516,7 +2516,7 @@ TEMPLATE static u32 FASTCALL OP_SWP(const u32 i) return MMU_aluMemCycles(4, c); } -TEMPLATE static u32 FASTCALL OP_SWPB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SWPB(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; u8 tmp = READ8(cpu->mem_if->data, adr); @@ -2532,7 +2532,7 @@ TEMPLATE static u32 FASTCALL OP_SWPB(const u32 i) // LDRH //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_LDRH_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF; cpu->R[REG_POS(i,12)] = (u32)READ16(cpu->mem_if->data, adr); @@ -2540,7 +2540,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF; cpu->R[REG_POS(i,12)] = (u32)READ16(cpu->mem_if->data, adr); @@ -2548,7 +2548,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_P_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_P_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,12)] = (u32)READ16(cpu->mem_if->data, adr); @@ -2556,7 +2556,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_P_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_M_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_M_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,12)] = (u32)READ16(cpu->mem_if->data, adr); @@ -2564,7 +2564,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_M_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_PRE_INDE_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_PRE_INDE_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF; cpu->R[REG_POS(i,16)] = adr; @@ -2573,7 +2573,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_PRE_INDE_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_PRE_INDE_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_PRE_INDE_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF; cpu->R[REG_POS(i,16)] = adr; @@ -2583,7 +2583,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_PRE_INDE_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_PRE_INDE_P_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_PRE_INDE_P_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,16)] = adr; @@ -2592,7 +2592,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_PRE_INDE_P_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_PRE_INDE_M_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_PRE_INDE_M_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,16)] = adr; @@ -2601,7 +2601,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_PRE_INDE_M_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_POS_INDE_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_POS_INDE_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] += IMM_OFF; @@ -2610,7 +2610,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_POS_INDE_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_POS_INDE_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_POS_INDE_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] -= IMM_OFF; @@ -2619,7 +2619,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_POS_INDE_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_POS_INDE_P_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_POS_INDE_P_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] += cpu->R[REG_POS(i,0)]; @@ -2628,7 +2628,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_POS_INDE_P_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_POS_INDE_M_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_POS_INDE_M_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] -= cpu->R[REG_POS(i,0)]; @@ -2641,7 +2641,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_POS_INDE_M_REG_OFF(const u32 i) // STRH //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_STRH_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF; WRITE16(cpu->mem_if->data, adr, (u16)cpu->R[REG_POS(i,12)]); @@ -2649,7 +2649,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRH_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF; WRITE16(cpu->mem_if->data, adr, (u16)cpu->R[REG_POS(i,12)]); @@ -2657,7 +2657,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRH_P_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_P_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + cpu->R[REG_POS(i,0)]; WRITE16(cpu->mem_if->data, adr, (u16)cpu->R[REG_POS(i,12)]); @@ -2665,7 +2665,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_P_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRH_M_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_M_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - cpu->R[REG_POS(i,0)]; WRITE16(cpu->mem_if->data, adr, (u16)cpu->R[REG_POS(i,12)]); @@ -2673,7 +2673,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_M_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRH_PRE_INDE_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_PRE_INDE_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF; cpu->R[REG_POS(i,16)] = adr; @@ -2682,7 +2682,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_PRE_INDE_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRH_PRE_INDE_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_PRE_INDE_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF; cpu->R[REG_POS(i,16)] = adr; @@ -2691,7 +2691,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_PRE_INDE_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRH_PRE_INDE_P_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_PRE_INDE_P_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,16)] = adr; @@ -2700,7 +2700,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_PRE_INDE_P_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRH_PRE_INDE_M_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_PRE_INDE_M_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,16)] = adr; @@ -2709,7 +2709,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_PRE_INDE_M_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRH_POS_INDE_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_POS_INDE_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; WRITE16(cpu->mem_if->data, adr, (u16)cpu->R[REG_POS(i,12)]); @@ -2718,7 +2718,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_POS_INDE_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRH_POS_INDE_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_POS_INDE_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; WRITE16(cpu->mem_if->data, adr, (u16)cpu->R[REG_POS(i,12)]); @@ -2727,7 +2727,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_POS_INDE_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRH_POS_INDE_P_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_POS_INDE_P_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; WRITE16(cpu->mem_if->data, adr, (u16)cpu->R[REG_POS(i,12)]); @@ -2736,7 +2736,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_POS_INDE_P_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRH_POS_INDE_M_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_POS_INDE_M_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; WRITE16(cpu->mem_if->data, adr, (u16)cpu->R[REG_POS(i,12)]); @@ -2749,7 +2749,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_POS_INDE_M_REG_OFF(const u32 i) // LDRSH //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_LDRSH_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF; cpu->R[REG_POS(i,12)] = (s32)((s16)READ16(cpu->mem_if->data, adr)); @@ -2757,7 +2757,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSH_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF; cpu->R[REG_POS(i,12)] = (s32)((s16)READ16(cpu->mem_if->data, adr)); @@ -2765,7 +2765,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSH_P_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_P_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,12)] = (s32)((s16)READ16(cpu->mem_if->data, adr)); @@ -2773,7 +2773,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_P_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSH_M_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_M_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,12)] = (s32)((s16)READ16(cpu->mem_if->data, adr)); @@ -2781,7 +2781,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_M_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSH_PRE_INDE_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_PRE_INDE_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF; cpu->R[REG_POS(i,16)] = adr; @@ -2791,7 +2791,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_PRE_INDE_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSH_PRE_INDE_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_PRE_INDE_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF; cpu->R[REG_POS(i,16)] = adr; @@ -2800,7 +2800,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_PRE_INDE_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSH_PRE_INDE_P_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_PRE_INDE_P_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,16)] = adr; @@ -2809,7 +2809,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_PRE_INDE_P_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSH_PRE_INDE_M_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_PRE_INDE_M_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,16)] = adr; @@ -2818,7 +2818,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_PRE_INDE_M_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSH_POS_INDE_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_POS_INDE_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] += IMM_OFF; @@ -2827,7 +2827,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_POS_INDE_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSH_POS_INDE_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_POS_INDE_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] -= IMM_OFF; @@ -2836,7 +2836,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_POS_INDE_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSH_POS_INDE_P_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_POS_INDE_P_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] += cpu->R[REG_POS(i,0)]; @@ -2845,7 +2845,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_POS_INDE_P_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSH_POS_INDE_M_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_POS_INDE_M_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] -= cpu->R[REG_POS(i,0)]; @@ -2858,7 +2858,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_POS_INDE_M_REG_OFF(const u32 i) // LDRSB //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_LDRSB_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF; cpu->R[REG_POS(i,12)] = (s32)((s8)READ8(cpu->mem_if->data, adr)); @@ -2866,7 +2866,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSB_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF; cpu->R[REG_POS(i,12)] = (s32)((s8)READ8(cpu->mem_if->data, adr)); @@ -2874,7 +2874,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSB_P_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_P_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,12)] = (s32)((s8)READ8(cpu->mem_if->data, adr)); @@ -2882,7 +2882,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_P_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSB_M_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_M_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,12)] = (s32)((s8)READ8(cpu->mem_if->data, adr)); @@ -2890,7 +2890,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_M_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSB_PRE_INDE_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_PRE_INDE_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF; cpu->R[REG_POS(i,16)] = adr; @@ -2899,7 +2899,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_PRE_INDE_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSB_PRE_INDE_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_PRE_INDE_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF; cpu->R[REG_POS(i,16)] = adr; @@ -2908,7 +2908,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_PRE_INDE_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSB_PRE_INDE_P_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_PRE_INDE_P_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,16)] = adr; @@ -2918,7 +2918,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_PRE_INDE_P_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSB_PRE_INDE_M_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_PRE_INDE_M_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - cpu->R[REG_POS(i,0)]; cpu->R[REG_POS(i,16)] = adr; @@ -2927,7 +2927,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_PRE_INDE_M_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSB_POS_INDE_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_POS_INDE_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] += IMM_OFF; @@ -2936,7 +2936,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_POS_INDE_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSB_POS_INDE_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_POS_INDE_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] -= IMM_OFF; @@ -2945,7 +2945,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_POS_INDE_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSB_POS_INDE_P_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_POS_INDE_P_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] += cpu->R[REG_POS(i,0)]; @@ -2954,7 +2954,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_POS_INDE_P_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRSB_POS_INDE_M_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_POS_INDE_M_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] -= cpu->R[REG_POS(i,0)]; @@ -2967,14 +2967,14 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_POS_INDE_M_REG_OFF(const u32 i) // MRS / MSR //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_MRS_CPSR(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MRS_CPSR(const u32 i) { cpu->R[REG_POS(i,12)] = cpu->CPSR.val; return 1; } -TEMPLATE static u32 FASTCALL OP_MRS_SPSR(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MRS_SPSR(const u32 i) { cpu->R[REG_POS(i,12)] = cpu->SPSR.val; @@ -3014,7 +3014,7 @@ TEMPLATE static u32 FASTCALL OP_MRS_SPSR(const u32 i) #define v5TE_STATE_MASK 0x00000020 #endif -TEMPLATE static u32 FASTCALL OP_MSR_CPSR(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MSR_CPSR(const u32 i) { u32 operand = cpu->R[REG_POS(i,0)]; @@ -3051,7 +3051,7 @@ TEMPLATE static u32 FASTCALL OP_MSR_CPSR(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_MSR_SPSR(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MSR_SPSR(const u32 i) { //printf("OP_MSR_SPSR\n"); u32 operand = cpu->R[REG_POS(i,0)]; @@ -3060,7 +3060,7 @@ TEMPLATE static u32 FASTCALL OP_MSR_SPSR(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_MSR_CPSR_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MSR_CPSR_IMM_VAL(const u32 i) { //printf("OP_MSR_CPSR_IMM_VAL\n"); IMM_VALUE; @@ -3068,7 +3068,7 @@ TEMPLATE static u32 FASTCALL OP_MSR_CPSR_IMM_VAL(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_MSR_SPSR_IMM_VAL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MSR_SPSR_IMM_VAL(const u32 i) { //printf("OP_MSR_SPSR_IMM_VAL\n"); IMM_VALUE; @@ -3081,7 +3081,7 @@ TEMPLATE static u32 FASTCALL OP_MSR_SPSR_IMM_VAL(const u32 i) // Branch //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_BX(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BX(const u32 i) { u32 tmp = cpu->R[REG_POS(i, 0)]; @@ -3096,7 +3096,7 @@ TEMPLATE static u32 FASTCALL OP_BX(const u32 i) return 3; } -TEMPLATE static u32 FASTCALL OP_BLX_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BLX_REG(const u32 i) { u32 tmp = cpu->R[REG_POS(i, 0)]; @@ -3113,7 +3113,7 @@ TEMPLATE static u32 FASTCALL OP_BLX_REG(const u32 i) #define SIGNEXTEND_24(i) (((s32)i<<8)>>8) -TEMPLATE static u32 FASTCALL OP_B(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_B(const u32 i) { static const u32 mov_r12_r12 = 0xE1A0C00C; const u32 last = _MMU_read32(cpu->instruct_adr-4); @@ -3137,7 +3137,7 @@ TEMPLATE static u32 FASTCALL OP_B(const u32 i) return 3; } -TEMPLATE static u32 FASTCALL OP_BL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BL(const u32 i) { u32 off = SIGNEXTEND_24(i); if(CONDITION(i)==0xF) @@ -3170,7 +3170,7 @@ const u8 CLZ_TAB[16]= 4, 4, 4, 4, 4, 4, 4, 4 // 1XXX }; -TEMPLATE static u32 FASTCALL OP_CLZ(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CLZ(const u32 i) { u32 Rm = cpu->R[REG_POS(i,0)]; u32 pos; @@ -3206,7 +3206,7 @@ TEMPLATE static u32 FASTCALL OP_CLZ(const u32 i) // QADD / QDADD / QSUB / QDSUB //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_QADD(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_QADD(const u32 i) { u32 res = cpu->R[REG_POS(i,16)]+cpu->R[REG_POS(i,0)]; @@ -3227,7 +3227,7 @@ TEMPLATE static u32 FASTCALL OP_QADD(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_QSUB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_QSUB(const u32 i) { u32 res = cpu->R[REG_POS(i,0)]-cpu->R[REG_POS(i,16)]; @@ -3248,7 +3248,7 @@ TEMPLATE static u32 FASTCALL OP_QSUB(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_QDADD(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_QDADD(const u32 i) { u32 mul = cpu->R[REG_POS(i,16)]<<1; u32 res; @@ -3277,7 +3277,7 @@ TEMPLATE static u32 FASTCALL OP_QDADD(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_QDSUB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_QDSUB(const u32 i) { u32 mul = cpu->R[REG_POS(i,16)]<<1; u32 res; @@ -3313,7 +3313,7 @@ TEMPLATE static u32 FASTCALL OP_QDSUB(const u32 i) #define HWORD(i) ((s32)(((s32)(i))>>16)) #define LWORD(i) (s32)(((s32)((i)<<16))>>16) -TEMPLATE static u32 FASTCALL OP_SMUL_B_B(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMUL_B_B(const u32 i) { // checked //INFO("SMUL_B_B\n"); @@ -3322,7 +3322,7 @@ TEMPLATE static u32 FASTCALL OP_SMUL_B_B(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_SMUL_B_T(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMUL_B_T(const u32 i) { //INFO("SMUL_B_T\n"); cpu->R[REG_POS(i,16)] = (u32)(LWORD(cpu->R[REG_POS(i,0)])* HWORD(cpu->R[REG_POS(i,8)])); @@ -3330,7 +3330,7 @@ TEMPLATE static u32 FASTCALL OP_SMUL_B_T(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_SMUL_T_B(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMUL_T_B(const u32 i) { //INFO("SMUL_T_B\n"); cpu->R[REG_POS(i,16)] = (u32)(HWORD(cpu->R[REG_POS(i,0)])* LWORD(cpu->R[REG_POS(i,8)])); @@ -3338,7 +3338,7 @@ TEMPLATE static u32 FASTCALL OP_SMUL_T_B(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_SMUL_T_T(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMUL_T_T(const u32 i) { //INFO("SMUL_T_T\n"); cpu->R[REG_POS(i,16)] = (u32)(HWORD(cpu->R[REG_POS(i,0)])* HWORD(cpu->R[REG_POS(i,8)])); @@ -3350,7 +3350,7 @@ TEMPLATE static u32 FASTCALL OP_SMUL_T_T(const u32 i) // SMLA //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_SMLA_B_B(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMLA_B_B(const u32 i) { u32 tmp = (u32)((s16)cpu->R[REG_POS(i,0)]* (s16)cpu->R[REG_POS(i,8)]); @@ -3363,7 +3363,7 @@ TEMPLATE static u32 FASTCALL OP_SMLA_B_B(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_SMLA_B_T(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMLA_B_T(const u32 i) { u32 tmp = (u32)(LWORD(cpu->R[REG_POS(i,0)])* HWORD(cpu->R[REG_POS(i,8)])); u32 a = cpu->R[REG_POS(i,12)]; @@ -3377,7 +3377,7 @@ TEMPLATE static u32 FASTCALL OP_SMLA_B_T(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_SMLA_T_B(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMLA_T_B(const u32 i) { u32 tmp = (u32)(HWORD(cpu->R[REG_POS(i,0)])* LWORD(cpu->R[REG_POS(i,8)])); u32 a = cpu->R[REG_POS(i,12)]; @@ -3391,7 +3391,7 @@ TEMPLATE static u32 FASTCALL OP_SMLA_T_B(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_SMLA_T_T(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMLA_T_T(const u32 i) { u32 tmp = (u32)(HWORD(cpu->R[REG_POS(i,0)])* HWORD(cpu->R[REG_POS(i,8)])); u32 a = cpu->R[REG_POS(i,12)]; @@ -3409,7 +3409,7 @@ TEMPLATE static u32 FASTCALL OP_SMLA_T_T(const u32 i) // SMLAL //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_SMLAL_B_B(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMLAL_B_B(const u32 i) { s32 a = LWORD(cpu->R[REG_POS(i,0)]); s32 b = LWORD(cpu->R[REG_POS(i,8)]); @@ -3422,7 +3422,7 @@ TEMPLATE static u32 FASTCALL OP_SMLAL_B_B(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_SMLAL_B_T(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMLAL_B_T(const u32 i) { s32 a = LWORD(cpu->R[REG_POS(i,0)]); s32 b = HWORD(cpu->R[REG_POS(i,8)]); @@ -3435,7 +3435,7 @@ TEMPLATE static u32 FASTCALL OP_SMLAL_B_T(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_SMLAL_T_B(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMLAL_T_B(const u32 i) { s32 a = HWORD(cpu->R[REG_POS(i,0)]); s32 b = LWORD(cpu->R[REG_POS(i,8)]); @@ -3448,7 +3448,7 @@ TEMPLATE static u32 FASTCALL OP_SMLAL_T_B(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_SMLAL_T_T(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMLAL_T_T(const u32 i) { s32 a = HWORD(cpu->R[REG_POS(i,0)]); s32 b = HWORD(cpu->R[REG_POS(i,8)]); @@ -3465,7 +3465,7 @@ TEMPLATE static u32 FASTCALL OP_SMLAL_T_T(const u32 i) // SMULW //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_SMULW_B(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMULW_B(const u32 i) { s64 tmp = (s64)LWORD(cpu->R[REG_POS(i,8)]) * (s64)((s32)cpu->R[REG_POS(i,0)]); @@ -3476,7 +3476,7 @@ TEMPLATE static u32 FASTCALL OP_SMULW_B(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_SMULW_T(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMULW_T(const u32 i) { s64 tmp = (s64)HWORD(cpu->R[REG_POS(i,8)]) * (s64)((s32)cpu->R[REG_POS(i,0)]); @@ -3491,7 +3491,7 @@ TEMPLATE static u32 FASTCALL OP_SMULW_T(const u32 i) // SMLAW //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_SMLAW_B(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMLAW_B(const u32 i) { s64 tmp = (s64)LWORD(cpu->R[REG_POS(i,8)]) * (s64)((s32)cpu->R[REG_POS(i,0)]); u32 a = cpu->R[REG_POS(i,12)]; @@ -3508,7 +3508,7 @@ TEMPLATE static u32 FASTCALL OP_SMLAW_B(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_SMLAW_T(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SMLAW_T(const u32 i) { s64 tmp = (s64)HWORD(cpu->R[REG_POS(i,8)]) * (s64)((s32)cpu->R[REG_POS(i,0)]); u32 a = cpu->R[REG_POS(i,12)]; @@ -3593,195 +3593,195 @@ TEMPLATE static u32 FASTCALL OP_SMLAW_T(const u32 i) return MMU_aluMemAccessCycles(a,adr); -TEMPLATE static u32 FASTCALL OP_LDR_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF_12; OP_LDR(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF_12; OP_LDR(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_P_LSL_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_LSL_IMM_OFF(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; OP_LDR(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_M_LSL_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_LSL_IMM_OFF(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; OP_LDR(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_P_LSR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_LSR_IMM_OFF(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; OP_LDR(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_M_LSR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_LSR_IMM_OFF(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; OP_LDR(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_P_ASR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_ASR_IMM_OFF(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; OP_LDR(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_M_ASR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_ASR_IMM_OFF(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; OP_LDR(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_P_ROR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_ROR_IMM_OFF(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; OP_LDR(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_M_ROR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_ROR_IMM_OFF(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; OP_LDR(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_P_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_IMM_OFF_PREIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF_12; OP_LDR_W(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_M_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_IMM_OFF_PREIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF_12; OP_LDR_W(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_P_LSL_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_LSL_IMM_OFF_PREIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; OP_LDR_W(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_M_LSL_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_LSL_IMM_OFF_PREIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; OP_LDR_W(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_P_LSR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_LSR_IMM_OFF_PREIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; OP_LDR_W(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_M_LSR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_LSR_IMM_OFF_PREIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; OP_LDR_W(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_P_ASR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_ASR_IMM_OFF_PREIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; OP_LDR_W(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_M_ASR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_ASR_IMM_OFF_PREIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; OP_LDR_W(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_P_ROR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_ROR_IMM_OFF_PREIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; OP_LDR_W(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_M_ROR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_ROR_IMM_OFF_PREIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; OP_LDR_W(3, 5); } -TEMPLATE static u32 FASTCALL OP_LDR_P_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_IMM_OFF_POSTIND(const u32 i) { OP_LDR_W2(3, 5, IMM_OFF_12); } -TEMPLATE static u32 FASTCALL OP_LDR_M_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_IMM_OFF_POSTIND(const u32 i) { OP_LDR_W2(3, 5, -IMM_OFF_12); } -TEMPLATE static u32 FASTCALL OP_LDR_P_LSL_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_LSL_IMM_OFF_POSTIND(const u32 i) { LSL_IMM; OP_LDR_W2(3, 5, shift_op); } -TEMPLATE static u32 FASTCALL OP_LDR_M_LSL_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_LSL_IMM_OFF_POSTIND(const u32 i) { LSL_IMM; OP_LDR_W2(3, 5, -shift_op); } -TEMPLATE static u32 FASTCALL OP_LDR_P_LSR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_LSR_IMM_OFF_POSTIND(const u32 i) { LSR_IMM; OP_LDR_W2(3, 5, shift_op); } -TEMPLATE static u32 FASTCALL OP_LDR_M_LSR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_LSR_IMM_OFF_POSTIND(const u32 i) { LSR_IMM; OP_LDR_W2(3, 5, -shift_op); } -TEMPLATE static u32 FASTCALL OP_LDR_P_ASR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_ASR_IMM_OFF_POSTIND(const u32 i) { ASR_IMM; OP_LDR_W2(3, 5, shift_op); } -TEMPLATE static u32 FASTCALL OP_LDR_M_ASR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_ASR_IMM_OFF_POSTIND(const u32 i) { ASR_IMM; OP_LDR_W2(3, 5, -shift_op); } -TEMPLATE static u32 FASTCALL OP_LDR_P_ROR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_P_ROR_IMM_OFF_POSTIND(const u32 i) { ROR_IMM; OP_LDR_W2(3, 5, shift_op); } -TEMPLATE static u32 FASTCALL OP_LDR_M_ROR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_M_ROR_IMM_OFF_POSTIND(const u32 i) { ROR_IMM; OP_LDR_W2(3, 5, -shift_op); @@ -3790,7 +3790,7 @@ TEMPLATE static u32 FASTCALL OP_LDR_M_ROR_IMM_OFF_POSTIND(const u32 i) //----------------------------------------------------------------------------- // LDREX //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_LDREX(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDREX(const u32 i) { printf("LDREX\n"); u32 adr = cpu->R[REG_POS(i,16)]; @@ -3802,7 +3802,7 @@ TEMPLATE static u32 FASTCALL OP_LDREX(const u32 i) // LDRB //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_LDRB_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF_12; cpu->R[REG_POS(i,12)] = (u32)READ8(cpu->mem_if->data, adr); @@ -3810,7 +3810,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF_12; cpu->R[REG_POS(i,12)] = (u32)READ8(cpu->mem_if->data, adr); @@ -3818,7 +3818,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_LSL_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_LSL_IMM_OFF(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -3827,7 +3827,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_LSL_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_LSL_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_LSL_IMM_OFF(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -3836,7 +3836,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_LSL_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_LSR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_LSR_IMM_OFF(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -3845,7 +3845,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_LSR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_LSR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_LSR_IMM_OFF(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -3854,7 +3854,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_LSR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_ASR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_ASR_IMM_OFF(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -3863,7 +3863,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_ASR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_ASR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_ASR_IMM_OFF(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -3872,7 +3872,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_ASR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_ROR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_ROR_IMM_OFF(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -3881,7 +3881,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_ROR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_ROR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_ROR_IMM_OFF(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -3890,7 +3890,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_ROR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_IMM_OFF_PREIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF_12; cpu->R[REG_POS(i,16)] = adr; @@ -3899,7 +3899,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_IMM_OFF_PREIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF_12; cpu->R[REG_POS(i,16)] = adr; @@ -3908,7 +3908,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_LSL_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_LSL_IMM_OFF_PREIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -3918,7 +3918,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_LSL_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_LSL_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_LSL_IMM_OFF_PREIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -3928,7 +3928,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_LSL_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_LSR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_LSR_IMM_OFF_PREIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -3938,7 +3938,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_LSR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_LSR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_LSR_IMM_OFF_PREIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -3948,7 +3948,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_LSR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_ASR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_ASR_IMM_OFF_PREIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -3958,7 +3958,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_ASR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_ASR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_ASR_IMM_OFF_PREIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -3968,7 +3968,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_ASR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_ROR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_ROR_IMM_OFF_PREIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -3978,7 +3978,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_ROR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_ROR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_ROR_IMM_OFF_PREIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -3988,7 +3988,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_ROR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_IMM_OFF_POSTIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] = adr + IMM_OFF_12; @@ -3997,7 +3997,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_IMM_OFF_POSTIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; cpu->R[REG_POS(i,16)] = adr - IMM_OFF_12; @@ -4006,7 +4006,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_LSL_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_LSL_IMM_OFF_POSTIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4016,7 +4016,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_LSL_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_LSL_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_LSL_IMM_OFF_POSTIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4026,7 +4026,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_LSL_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_LSR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_LSR_IMM_OFF_POSTIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4036,7 +4036,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_LSR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_LSR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_LSR_IMM_OFF_POSTIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4046,7 +4046,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_LSR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_ASR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_ASR_IMM_OFF_POSTIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4056,7 +4056,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_ASR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_ASR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_ASR_IMM_OFF_POSTIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4066,7 +4066,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_ASR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_P_ROR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_P_ROR_IMM_OFF_POSTIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4076,7 +4076,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_P_ROR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(3,adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_M_ROR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_M_ROR_IMM_OFF_POSTIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4090,7 +4090,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_M_ROR_IMM_OFF_POSTIND(const u32 i) // STR //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_STR_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF_12; WRITE32(cpu->mem_if->data, adr, cpu->R[REG_POS(i,12)]); @@ -4098,7 +4098,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF_12; WRITE32(cpu->mem_if->data, adr, cpu->R[REG_POS(i,12)]); @@ -4106,7 +4106,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_LSL_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_LSL_IMM_OFF(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4115,7 +4115,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_LSL_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_LSL_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_LSL_IMM_OFF(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4124,7 +4124,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_LSL_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_LSR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_LSR_IMM_OFF(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4133,7 +4133,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_LSR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_LSR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_LSR_IMM_OFF(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4142,7 +4142,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_LSR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_ASR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_ASR_IMM_OFF(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4151,7 +4151,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_ASR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_ASR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_ASR_IMM_OFF(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4160,7 +4160,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_ASR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_ROR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_ROR_IMM_OFF(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4169,7 +4169,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_ROR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_ROR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_ROR_IMM_OFF(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4178,7 +4178,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_ROR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_IMM_OFF_PREIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF_12; cpu->R[REG_POS(i,16)] = adr; @@ -4187,7 +4187,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_IMM_OFF_PREIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF_12; cpu->R[REG_POS(i,16)] = adr; @@ -4196,7 +4196,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_LSL_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_LSL_IMM_OFF_PREIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4206,7 +4206,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_LSL_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_LSL_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_LSL_IMM_OFF_PREIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4216,7 +4216,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_LSL_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_LSR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_LSR_IMM_OFF_PREIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4226,7 +4226,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_LSR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_LSR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_LSR_IMM_OFF_PREIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4236,7 +4236,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_LSR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_ASR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_ASR_IMM_OFF_PREIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4246,7 +4246,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_ASR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_ASR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_ASR_IMM_OFF_PREIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4256,7 +4256,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_ASR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_ROR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_ROR_IMM_OFF_PREIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4266,7 +4266,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_ROR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_ROR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_ROR_IMM_OFF_PREIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4276,7 +4276,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_ROR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_IMM_OFF_POSTIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; WRITE32(cpu->mem_if->data, adr, cpu->R[REG_POS(i,12)]); @@ -4285,7 +4285,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_IMM_OFF_POSTIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; WRITE32(cpu->mem_if->data, adr, cpu->R[REG_POS(i,12)]); @@ -4294,7 +4294,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_LSL_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_LSL_IMM_OFF_POSTIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4304,7 +4304,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_LSL_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_LSL_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_LSL_IMM_OFF_POSTIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4314,7 +4314,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_LSL_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_LSR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_LSR_IMM_OFF_POSTIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4324,7 +4324,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_LSR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_LSR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_LSR_IMM_OFF_POSTIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4334,7 +4334,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_LSR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_ASR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_ASR_IMM_OFF_POSTIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4344,7 +4344,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_ASR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_ASR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_ASR_IMM_OFF_POSTIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4354,7 +4354,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_ASR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_P_ROR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_P_ROR_IMM_OFF_POSTIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4364,7 +4364,7 @@ TEMPLATE static u32 FASTCALL OP_STR_P_ROR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STR_M_ROR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_M_ROR_IMM_OFF_POSTIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4377,7 +4377,7 @@ TEMPLATE static u32 FASTCALL OP_STR_M_ROR_IMM_OFF_POSTIND(const u32 i) //----------------------------------------------------------------------------- // STREX //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_STREX(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STREX(const u32 i) { printf("STREX\n"); u32 adr = cpu->R[REG_POS(i,16)]; @@ -4391,7 +4391,7 @@ TEMPLATE static u32 FASTCALL OP_STREX(const u32 i) // STRB //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_STRB_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF_12; WRITE8(cpu->mem_if->data, adr, (u8)cpu->R[REG_POS(i,12)]); @@ -4399,7 +4399,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF_12; WRITE8(cpu->mem_if->data, adr, (u8)cpu->R[REG_POS(i,12)]); @@ -4407,7 +4407,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_LSL_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_LSL_IMM_OFF(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4416,7 +4416,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_LSL_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_LSL_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_LSL_IMM_OFF(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4425,7 +4425,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_LSL_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_LSR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_LSR_IMM_OFF(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4434,7 +4434,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_LSR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_LSR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_LSR_IMM_OFF(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4443,7 +4443,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_LSR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_ASR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_ASR_IMM_OFF(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4452,7 +4452,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_ASR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_ASR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_ASR_IMM_OFF(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4461,7 +4461,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_ASR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_ROR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_ROR_IMM_OFF(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4470,7 +4470,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_ROR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_ROR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_ROR_IMM_OFF(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4479,7 +4479,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_ROR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_IMM_OFF_PREIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] + IMM_OFF_12; cpu->R[REG_POS(i,16)] = adr; @@ -4488,7 +4488,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_IMM_OFF_PREIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)] - IMM_OFF_12; cpu->R[REG_POS(i,16)] = adr; @@ -4497,7 +4497,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_LSL_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_LSL_IMM_OFF_PREIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4507,7 +4507,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_LSL_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_LSL_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_LSL_IMM_OFF_PREIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4517,7 +4517,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_LSL_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_LSR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_LSR_IMM_OFF_PREIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4527,7 +4527,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_LSR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_LSR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_LSR_IMM_OFF_PREIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4537,7 +4537,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_LSR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_ASR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_ASR_IMM_OFF_PREIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4547,7 +4547,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_ASR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_ASR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_ASR_IMM_OFF_PREIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4557,7 +4557,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_ASR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_ROR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_ROR_IMM_OFF_PREIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] + shift_op; @@ -4567,7 +4567,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_ROR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_ROR_IMM_OFF_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_ROR_IMM_OFF_PREIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)] - shift_op; @@ -4577,7 +4577,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_ROR_IMM_OFF_PREIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_IMM_OFF_POSTIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; WRITE8(cpu->mem_if->data, adr, (u8)cpu->R[REG_POS(i,12)]); @@ -4586,7 +4586,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_IMM_OFF_POSTIND(const u32 i) { u32 adr = cpu->R[REG_POS(i,16)]; WRITE8(cpu->mem_if->data, adr, (u8)cpu->R[REG_POS(i,12)]); @@ -4595,7 +4595,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_LSL_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_LSL_IMM_OFF_POSTIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4605,7 +4605,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_LSL_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_LSL_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_LSL_IMM_OFF_POSTIND(const u32 i) { LSL_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4615,7 +4615,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_LSL_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_LSR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_LSR_IMM_OFF_POSTIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4625,7 +4625,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_LSR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_LSR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_LSR_IMM_OFF_POSTIND(const u32 i) { LSR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4635,7 +4635,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_LSR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_ASR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_ASR_IMM_OFF_POSTIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4645,7 +4645,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_ASR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_ASR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_ASR_IMM_OFF_POSTIND(const u32 i) { ASR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4655,7 +4655,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_ASR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_P_ROR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_P_ROR_IMM_OFF_POSTIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4665,7 +4665,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_P_ROR_IMM_OFF_POSTIND(const u32 i) return MMU_aluMemAccessCycles(2,adr); } -TEMPLATE static u32 FASTCALL OP_STRB_M_ROR_IMM_OFF_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_M_ROR_IMM_OFF_POSTIND(const u32 i) { ROR_IMM; u32 adr = cpu->R[REG_POS(i,16)]; @@ -4707,7 +4707,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_M_ROR_IMM_OFF_POSTIND(const u32 i) c += MMU_memAccessCycles(start); \ } -TEMPLATE static u32 FASTCALL OP_LDMIA(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMIA(const u32 i) { u32 c = 0; u32 start = cpu->R[REG_POS(i,16)]; @@ -4769,7 +4769,7 @@ TEMPLATE static u32 FASTCALL OP_LDMIA(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMIB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMIB(const u32 i) { u32 c = 0; u32 start = cpu->R[REG_POS(i,16)]; @@ -4817,7 +4817,7 @@ TEMPLATE static u32 FASTCALL OP_LDMIB(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMDA(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMDA(const u32 i) { u32 c = 0; u32 start = cpu->R[REG_POS(i,16)]; @@ -4864,7 +4864,7 @@ TEMPLATE static u32 FASTCALL OP_LDMDA(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMDB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMDB(const u32 i) { u32 c = 0; u32 start = cpu->R[REG_POS(i,16)]; @@ -4911,7 +4911,7 @@ TEMPLATE static u32 FASTCALL OP_LDMDB(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMIA_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMIA_W(const u32 i) { u32 c = 0; u32 start = cpu->R[REG_POS(i,16)]; @@ -4965,7 +4965,7 @@ TEMPLATE static u32 FASTCALL OP_LDMIA_W(const u32 i) return MMU_aluMemCycles(BIT15(i)?4:2, c); } -TEMPLATE static u32 FASTCALL OP_LDMIB_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMIB_W(const u32 i) { u32 c = 0; u32 start = cpu->R[REG_POS(i,16)]; @@ -5021,7 +5021,7 @@ TEMPLATE static u32 FASTCALL OP_LDMIB_W(const u32 i) return MMU_aluMemCycles(BIT15(i)?4:2, c); } -TEMPLATE static u32 FASTCALL OP_LDMDA_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMDA_W(const u32 i) { u32 c = 0; u32 start = cpu->R[REG_POS(i,16)]; @@ -5076,7 +5076,7 @@ TEMPLATE static u32 FASTCALL OP_LDMDA_W(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMDB_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMDB_W(const u32 i) { u32 c = 0; u32 start = cpu->R[REG_POS(i,16)]; @@ -5131,7 +5131,7 @@ TEMPLATE static u32 FASTCALL OP_LDMDB_W(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMIA2(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMIA2(const u32 i) { u32 oldmode = 0; @@ -5191,7 +5191,7 @@ TEMPLATE static u32 FASTCALL OP_LDMIA2(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMIB2(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMIB2(const u32 i) { u32 oldmode = 0; u32 c = 0; @@ -5252,7 +5252,7 @@ TEMPLATE static u32 FASTCALL OP_LDMIB2(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMDA2(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMDA2(const u32 i) { u32 oldmode = 0; @@ -5319,7 +5319,7 @@ TEMPLATE static u32 FASTCALL OP_LDMDA2(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMDB2(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMDB2(const u32 i) { u32 oldmode = 0; u32 c = 0; @@ -5383,7 +5383,7 @@ TEMPLATE static u32 FASTCALL OP_LDMDB2(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMIA2_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMIA2_W(const u32 i) { u32 c = 0; @@ -5439,7 +5439,7 @@ TEMPLATE static u32 FASTCALL OP_LDMIA2_W(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMIB2_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMIB2_W(const u32 i) { u32 c = 0; @@ -5498,7 +5498,7 @@ TEMPLATE static u32 FASTCALL OP_LDMIB2_W(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMDA2_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMDA2_W(const u32 i) { u32 c = 0; @@ -5557,7 +5557,7 @@ TEMPLATE static u32 FASTCALL OP_LDMDA2_W(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMDB2_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMDB2_W(const u32 i) { u32 c = 0; @@ -5623,7 +5623,7 @@ TEMPLATE static u32 FASTCALL OP_LDMDB2_W(const u32 i) // STMIA / STMIB / STMDA / STMDB //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_STMIA(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMIA(const u32 i) { u32 c = 0, b; u32 start = cpu->R[REG_POS(i,16)]; @@ -5640,7 +5640,7 @@ TEMPLATE static u32 FASTCALL OP_STMIA(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMIB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMIB(const u32 i) { u32 c = 0, b; u32 start = cpu->R[REG_POS(i,16)]; @@ -5657,7 +5657,7 @@ TEMPLATE static u32 FASTCALL OP_STMIB(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMDA(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMDA(const u32 i) { u32 c = 0, b; u32 start = cpu->R[REG_POS(i,16)]; @@ -5674,7 +5674,7 @@ TEMPLATE static u32 FASTCALL OP_STMDA(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMDB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMDB(const u32 i) { u32 c = 0, b; u32 start = cpu->R[REG_POS(i,16)]; @@ -5691,7 +5691,7 @@ TEMPLATE static u32 FASTCALL OP_STMDB(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMIA_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMIA_W(const u32 i) { u32 c = 0, b; u32 start = cpu->R[REG_POS(i,16)]; @@ -5710,7 +5710,7 @@ TEMPLATE static u32 FASTCALL OP_STMIA_W(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMIB_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMIB_W(const u32 i) { u32 c = 0, b; u32 start = cpu->R[REG_POS(i,16)]; @@ -5728,7 +5728,7 @@ TEMPLATE static u32 FASTCALL OP_STMIB_W(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMDA_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMDA_W(const u32 i) { u32 c = 0, b; u32 start = cpu->R[REG_POS(i,16)]; @@ -5747,7 +5747,7 @@ TEMPLATE static u32 FASTCALL OP_STMDA_W(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMDB_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMDB_W(const u32 i) { u32 c = 0, b; u32 start = cpu->R[REG_POS(i,16)]; @@ -5766,7 +5766,7 @@ TEMPLATE static u32 FASTCALL OP_STMDB_W(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMIA2(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMIA2(const u32 i) { u32 c, b; u32 start; @@ -5795,7 +5795,7 @@ TEMPLATE static u32 FASTCALL OP_STMIA2(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMIB2(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMIB2(const u32 i) { u32 c, b; u32 start; @@ -5824,7 +5824,7 @@ TEMPLATE static u32 FASTCALL OP_STMIB2(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMDA2(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMDA2(const u32 i) { u32 c, b; u32 start; @@ -5853,7 +5853,7 @@ TEMPLATE static u32 FASTCALL OP_STMDA2(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMDB2(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMDB2(const u32 i) { u32 c, b; u32 start; @@ -5880,7 +5880,7 @@ TEMPLATE static u32 FASTCALL OP_STMDB2(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMIA2_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMIA2_W(const u32 i) { u32 c, b; u32 start; @@ -5911,7 +5911,7 @@ TEMPLATE static u32 FASTCALL OP_STMIA2_W(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMIB2_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMIB2_W(const u32 i) { u32 c, b; u32 start; @@ -5938,7 +5938,7 @@ TEMPLATE static u32 FASTCALL OP_STMIB2_W(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMDA2_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMDA2_W(const u32 i) { u32 c, b; u32 start; @@ -5969,7 +5969,7 @@ TEMPLATE static u32 FASTCALL OP_STMDA2_W(const u32 i) return MMU_aluMemCycles(1, c); } -TEMPLATE static u32 FASTCALL OP_STMDB2_W(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMDB2_W(const u32 i) { u32 c, b; u32 start; @@ -6005,7 +6005,7 @@ TEMPLATE static u32 FASTCALL OP_STMDB2_W(const u32 i) // LDRD / STRD //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_LDRD_STRD_POST_INDEX(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRD_STRD_POST_INDEX(const u32 i) { u32 Rd_num = REG_POS( i, 12); u32 addr = cpu->R[REG_POS(i,16)]; @@ -6046,7 +6046,7 @@ TEMPLATE static u32 FASTCALL OP_LDRD_STRD_POST_INDEX(const u32 i) return MMU_aluMemCycles(3, c); } -TEMPLATE static u32 FASTCALL OP_LDRD_STRD_OFFSET_PRE_INDEX(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRD_STRD_OFFSET_PRE_INDEX(const u32 i) { u32 Rd_num = REG_POS( i, 12); u32 addr = cpu->R[REG_POS(i,16)]; @@ -6099,31 +6099,31 @@ TEMPLATE static u32 FASTCALL OP_LDRD_STRD_OFFSET_PRE_INDEX(const u32 i) // the NDS has no coproc that responses to a STC, no feedback is given to the arm //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_STC_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STC_P_IMM_OFF(const u32 i) { //INFO("OP_STC_P_IMM_OFF\n"); return TRAPUNDEF(cpu); } -TEMPLATE static u32 FASTCALL OP_STC_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STC_M_IMM_OFF(const u32 i) { //INFO("OP_STC_M_IMM_OFF\n"); return TRAPUNDEF(cpu); } -TEMPLATE static u32 FASTCALL OP_STC_P_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STC_P_PREIND(const u32 i) { //INFO("OP_STC_P_PREIND\n"); return TRAPUNDEF(cpu); } -TEMPLATE static u32 FASTCALL OP_STC_M_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STC_M_PREIND(const u32 i) { //INFO("OP_STC_M_PREIND\n"); return TRAPUNDEF(cpu); } -TEMPLATE static u32 FASTCALL OP_STC_P_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STC_P_POSTIND(const u32 i) { //INFO("OP_STC_P_POSTIND: cp_num %i\n", (i>>8)&0x0F); return TRAPUNDEF(cpu); @@ -6131,13 +6131,13 @@ TEMPLATE static u32 FASTCALL OP_STC_P_POSTIND(const u32 i) } -TEMPLATE static u32 FASTCALL OP_STC_M_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STC_M_POSTIND(const u32 i) { //INFO("OP_STC_M_POSTIND\n"); return TRAPUNDEF(cpu); } -TEMPLATE static u32 FASTCALL OP_STC_OPTION(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STC_OPTION(const u32 i) { //INFO("OP_STC_OPTION\n"); return TRAPUNDEF(cpu); @@ -6148,43 +6148,43 @@ TEMPLATE static u32 FASTCALL OP_STC_OPTION(const u32 i) // the NDS has no coproc that responses to a LDC, no feedback is given to the arm //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_LDC_P_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDC_P_IMM_OFF(const u32 i) { //INFO("OP_LDC_P_IMM_OFF\n"); return TRAPUNDEF(cpu); } -TEMPLATE static u32 FASTCALL OP_LDC_M_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDC_M_IMM_OFF(const u32 i) { //INFO("OP_LDC_M_IMM_OFF\n"); return TRAPUNDEF(cpu); } -TEMPLATE static u32 FASTCALL OP_LDC_P_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDC_P_PREIND(const u32 i) { //INFO("OP_LDC_P_PREIND\n"); return TRAPUNDEF(cpu); } -TEMPLATE static u32 FASTCALL OP_LDC_M_PREIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDC_M_PREIND(const u32 i) { //INFO("OP_LDC_M_PREIND\n"); return TRAPUNDEF(cpu); } -TEMPLATE static u32 FASTCALL OP_LDC_P_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDC_P_POSTIND(const u32 i) { //INFO("OP_LDC_P_POSTIND\n"); return TRAPUNDEF(cpu); } -TEMPLATE static u32 FASTCALL OP_LDC_M_POSTIND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDC_M_POSTIND(const u32 i) { //INFO("OP_LDC_M_POSTIND\n"); return TRAPUNDEF(cpu); } -TEMPLATE static u32 FASTCALL OP_LDC_OPTION(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDC_OPTION(const u32 i) { //INFO("OP_LDC_OPTION\n"); return TRAPUNDEF(cpu); @@ -6194,7 +6194,7 @@ TEMPLATE static u32 FASTCALL OP_LDC_OPTION(const u32 i) // MCR / MRC //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_MCR(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MCR(const u32 i) { u32 cpnum = REG_POS(i, 8); @@ -6212,7 +6212,7 @@ TEMPLATE static u32 FASTCALL OP_MCR(const u32 i) return 2; } -TEMPLATE static u32 FASTCALL OP_MRC(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MRC(const u32 i) { //if (PROCNUM != 0) return 1; @@ -6256,7 +6256,7 @@ TEMPLATE static u32 FASTCALL OP_MRC(const u32 i) // SWI //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_SWI(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SWI(const u32 i) { u32 swinum = (i>>16)&0xFF; @@ -6303,7 +6303,7 @@ TEMPLATE static u32 FASTCALL OP_SWI(const u32 i) // BKPT //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_BKPT(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BKPT(const u32 i) { /* ARM-ref if (not overridden by debug hardware) @@ -6349,7 +6349,7 @@ TEMPLATE static u32 FASTCALL OP_BKPT(const u32 i) // CDP //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_CDP(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CDP(const u32 i) { //INFO("Stopped (OP_CDP) \n"); return TRAPUNDEF(cpu); diff --git a/desmume/src/arm_jit.cpp b/desmume/src/arm_jit.cpp index f7c10d01c..928166980 100644 --- a/desmume/src/arm_jit.cpp +++ b/desmume/src/arm_jit.cpp @@ -1530,7 +1530,7 @@ static int OP_MSR_SPSR_IMM_VAL(const u32 i) { OP_MSR_(SPSR, IMM_VAL, 0); } //----------------------------------------------------------------------------- // LDR //----------------------------------------------------------------------------- -typedef u32 (FASTCALL* OpLDR)(u32, u32*); +typedef u32 (DESMUME_FASTCALL* OpLDR)(u32, u32*); // 98% of all memory accesses land in the same region as the first execution of // that instruction, so keep multiple copies with different fastpaths. @@ -1561,7 +1561,7 @@ static u32 classify_adr(u32 adr, bool store) } template -static u32 FASTCALL OP_LDR(u32 adr, u32 *dstreg) +static u32 DESMUME_FASTCALL OP_LDR(u32 adr, u32 *dstreg) { u32 data = READ32(cpu->mem_if->data, adr); if(adr&3) @@ -1571,28 +1571,28 @@ static u32 FASTCALL OP_LDR(u32 adr, u32 *dstreg) } template -static u32 FASTCALL OP_LDRH(u32 adr, u32 *dstreg) +static u32 DESMUME_FASTCALL OP_LDRH(u32 adr, u32 *dstreg) { *dstreg = READ16(cpu->mem_if->data, adr); return MMU_aluMemAccessCycles(3,adr); } template -static u32 FASTCALL OP_LDRSH(u32 adr, u32 *dstreg) +static u32 DESMUME_FASTCALL OP_LDRSH(u32 adr, u32 *dstreg) { *dstreg = (s16)READ16(cpu->mem_if->data, adr); return MMU_aluMemAccessCycles(3,adr); } template -static u32 FASTCALL OP_LDRB(u32 adr, u32 *dstreg) +static u32 DESMUME_FASTCALL OP_LDRB(u32 adr, u32 *dstreg) { *dstreg = READ8(cpu->mem_if->data, adr); return MMU_aluMemAccessCycles(3,adr); } template -static u32 FASTCALL OP_LDRSB(u32 adr, u32 *dstreg) +static u32 DESMUME_FASTCALL OP_LDRSB(u32 adr, u32 *dstreg) { *dstreg = (s8)READ8(cpu->mem_if->data, adr); return MMU_aluMemAccessCycles(3,adr); @@ -1774,27 +1774,27 @@ static int OP_LDRSB_POS_INDE_M_REG_OFF(const u32 i) { OP_LDR_(LDRSB, REG_OFF, su // STR //----------------------------------------------------------------------------- template -static u32 FASTCALL OP_STR(u32 adr, u32 data) +static u32 DESMUME_FASTCALL OP_STR(u32 adr, u32 data) { WRITE32(cpu->mem_if->data, adr, data); return MMU_aluMemAccessCycles(2,adr); } template -static u32 FASTCALL OP_STRH(u32 adr, u32 data) +static u32 DESMUME_FASTCALL OP_STRH(u32 adr, u32 data) { WRITE16(cpu->mem_if->data, adr, data); return MMU_aluMemAccessCycles(2,adr); } template -static u32 FASTCALL OP_STRB(u32 adr, u32 data) +static u32 DESMUME_FASTCALL OP_STRB(u32 adr, u32 data) { WRITE8(cpu->mem_if->data, adr, data); return MMU_aluMemAccessCycles(2,adr); } -typedef u32 (FASTCALL* OpSTR)(u32, u32); +typedef u32 (DESMUME_FASTCALL* OpSTR)(u32, u32); #define T(op) op<0,0>, op<0,1>, op<0,2>, op<1,0>, op<1,1>, NULL static const OpSTR STR_tab[2][3] = { T(OP_STR) }; static const OpSTR STRH_tab[2][3] = { T(OP_STRH) }; @@ -1913,9 +1913,9 @@ static int OP_STRB_M_ROR_IMM_OFF_POSTIND(const u32 i) { OP_STR_(STRB, ROR_IMM, s //----------------------------------------------------------------------------- // LDRD / STRD //----------------------------------------------------------------------------- -typedef u32 FASTCALL (*LDRD_STRD_REG)(u32); +typedef u32 DESMUME_FASTCALL (*LDRD_STRD_REG)(u32); template -static u32 FASTCALL OP_LDRD_REG(u32 adr) +static u32 DESMUME_FASTCALL OP_LDRD_REG(u32 adr) { cpu->R[Rnum] = READ32(cpu->mem_if->data, adr); @@ -1929,7 +1929,7 @@ static u32 FASTCALL OP_LDRD_REG(u32 adr) return MMU_memAccessCycles(adr); } template -static u32 FASTCALL OP_STRD_REG(u32 adr) +static u32 DESMUME_FASTCALL OP_STRD_REG(u32 adr) { WRITE32(cpu->mem_if->data, adr, cpu->R[Rnum]); @@ -2044,7 +2044,7 @@ static int OP_LDRD_STRD_OFFSET_PRE_INDEX(const u32 i) // SWP/SWPB //----------------------------------------------------------------------------- template -static u32 FASTCALL op_swp(u32 adr, u32 *Rd, u32 Rs) +static u32 DESMUME_FASTCALL op_swp(u32 adr, u32 *Rd, u32 Rs) { u32 tmp = ROR(READ32(cpu->mem_if->data, adr), (adr & 3)<<3); WRITE32(cpu->mem_if->data, adr, Rs); @@ -2052,7 +2052,7 @@ static u32 FASTCALL op_swp(u32 adr, u32 *Rd, u32 Rs) return (MMU_memAccessCycles(adr) + MMU_memAccessCycles(adr)); } template -static u32 FASTCALL op_swpb(u32 adr, u32 *Rd, u32 Rs) +static u32 DESMUME_FASTCALL op_swpb(u32 adr, u32 *Rd, u32 Rs) { u32 tmp = READ8(cpu->mem_if->data, adr); WRITE8(cpu->mem_if->data, adr, Rs); @@ -2060,7 +2060,7 @@ static u32 FASTCALL op_swpb(u32 adr, u32 *Rd, u32 Rs) return (MMU_memAccessCycles(adr) + MMU_memAccessCycles(adr)); } -typedef u32 FASTCALL (*OP_SWP_SWPB)(u32, u32*, u32); +typedef u32 DESMUME_FASTCALL (*OP_SWP_SWPB)(u32, u32*, u32); static const OP_SWP_SWPB op_swp_tab[2][2] = {{ op_swp<0>, op_swp<1> }, { op_swpb<0>, op_swpb<1> }}; static int op_swp_(const u32 i, int b) @@ -2119,7 +2119,7 @@ static u64 get_reg_list(u32 reg_mask, int dir) #endif template -static LDM_INLINE FASTCALL u32 OP_LDM_STM_generic(u32 adr, u64 regs, int n) +static LDM_INLINE DESMUME_FASTCALL u32 OP_LDM_STM_generic(u32 adr, u64 regs, int n) { u32 cycles = 0; adr &= ~3; @@ -2140,7 +2140,7 @@ static LDM_INLINE FASTCALL u32 OP_LDM_STM_generic(u32 adr, u64 regs, int n) #endif template -static LDM_INLINE FASTCALL u32 OP_LDM_STM_other(u32 adr, u64 regs, int n) +static LDM_INLINE DESMUME_FASTCALL u32 OP_LDM_STM_other(u32 adr, u64 regs, int n) { u32 cycles = 0; adr &= ~3; @@ -2162,7 +2162,7 @@ static LDM_INLINE FASTCALL u32 OP_LDM_STM_other(u32 adr, u64 regs, int n) } template -static FORCEINLINE FASTCALL u32 OP_LDM_STM_main(u32 adr, u64 regs, int n, u8 *ptr, u32 cycles) +static FORCEINLINE DESMUME_FASTCALL u32 OP_LDM_STM_main(u32 adr, u64 regs, int n, u8 *ptr, u32 cycles) { #ifdef ENABLE_ADVANCED_TIMING cycles = 0; @@ -2201,7 +2201,7 @@ static FORCEINLINE FASTCALL u32 OP_LDM_STM_main(u32 adr, u64 regs, int n, u8 *pt } template -static u32 FASTCALL OP_LDM_STM(u32 adr, u64 regs, int n) +static u32 DESMUME_FASTCALL OP_LDM_STM(u32 adr, u64 regs, int n) { // TODO use classify_adr? u32 cycles; @@ -2242,7 +2242,7 @@ static u32 FASTCALL OP_LDM_STM(u32 adr, u64 regs, int n) return OP_LDM_STM_main(adr, regs, n, ptr, cycles); } -typedef u32 FASTCALL (*LDMOpFunc)(u32,u64,int); +typedef u32 DESMUME_FASTCALL (*LDMOpFunc)(u32,u64,int); static const LDMOpFunc op_ldm_stm_tab[2][2][2] = {{ { OP_LDM_STM<0,0,-1>, OP_LDM_STM<0,0,+1> }, { OP_LDM_STM<0,1,-1>, OP_LDM_STM<0,1,+1> }, @@ -3849,7 +3849,7 @@ static const ArmOpCompiler thumb_instruction_compilers[1024] = { //----------------------------------------------------------------------------- template -static u32 FASTCALL OP_DECODE() +static u32 DESMUME_FASTCALL OP_DECODE() { u32 cycles; u32 adr = cpu->instruct_adr; diff --git a/desmume/src/arm_jit.h b/desmume/src/arm_jit.h index 60f07adb6..bc346733e 100644 --- a/desmume/src/arm_jit.h +++ b/desmume/src/arm_jit.h @@ -24,7 +24,7 @@ #include #endif -typedef u32 (FASTCALL* ArmOpCompiled)(); +typedef u32 (DESMUME_FASTCALL* ArmOpCompiled)(); void arm_jit_reset(bool enable, bool suppress_msg = false); void arm_jit_close(); diff --git a/desmume/src/armcpu.cpp b/desmume/src/armcpu.cpp index 68bf57cad..114b19330 100644 --- a/desmume/src/armcpu.cpp +++ b/desmume/src/armcpu.cpp @@ -460,23 +460,23 @@ FORCEINLINE static u32 armcpu_prefetch() } #if 0 /* not used */ -static BOOL FASTCALL test_EQ(Status_Reg CPSR) { return ( CPSR.bits.Z); } -static BOOL FASTCALL test_NE(Status_Reg CPSR) { return (!CPSR.bits.Z); } -static BOOL FASTCALL test_CS(Status_Reg CPSR) { return ( CPSR.bits.C); } -static BOOL FASTCALL test_CC(Status_Reg CPSR) { return (!CPSR.bits.C); } -static BOOL FASTCALL test_MI(Status_Reg CPSR) { return ( CPSR.bits.N); } -static BOOL FASTCALL test_PL(Status_Reg CPSR) { return (!CPSR.bits.N); } -static BOOL FASTCALL test_VS(Status_Reg CPSR) { return ( CPSR.bits.V); } -static BOOL FASTCALL test_VC(Status_Reg CPSR) { return (!CPSR.bits.V); } -static BOOL FASTCALL test_HI(Status_Reg CPSR) { return (CPSR.bits.C) && (!CPSR.bits.Z); } -static BOOL FASTCALL test_LS(Status_Reg CPSR) { return (CPSR.bits.Z) || (!CPSR.bits.C); } -static BOOL FASTCALL test_GE(Status_Reg CPSR) { return (CPSR.bits.N==CPSR.bits.V); } -static BOOL FASTCALL test_LT(Status_Reg CPSR) { return (CPSR.bits.N!=CPSR.bits.V); } -static BOOL FASTCALL test_GT(Status_Reg CPSR) { return (!CPSR.bits.Z) && (CPSR.bits.N==CPSR.bits.V); } -static BOOL FASTCALL test_LE(Status_Reg CPSR) { return ( CPSR.bits.Z) || (CPSR.bits.N!=CPSR.bits.V); } -static BOOL FASTCALL test_AL(Status_Reg CPSR) { return 1; } +static BOOL DESMUME_FASTCALL test_EQ(Status_Reg CPSR) { return ( CPSR.bits.Z); } +static BOOL DESMUME_FASTCALL test_NE(Status_Reg CPSR) { return (!CPSR.bits.Z); } +static BOOL DESMUME_FASTCALL test_CS(Status_Reg CPSR) { return ( CPSR.bits.C); } +static BOOL DESMUME_FASTCALL test_CC(Status_Reg CPSR) { return (!CPSR.bits.C); } +static BOOL DESMUME_FASTCALL test_MI(Status_Reg CPSR) { return ( CPSR.bits.N); } +static BOOL DESMUME_FASTCALL test_PL(Status_Reg CPSR) { return (!CPSR.bits.N); } +static BOOL DESMUME_FASTCALL test_VS(Status_Reg CPSR) { return ( CPSR.bits.V); } +static BOOL DESMUME_FASTCALL test_VC(Status_Reg CPSR) { return (!CPSR.bits.V); } +static BOOL DESMUME_FASTCALL test_HI(Status_Reg CPSR) { return (CPSR.bits.C) && (!CPSR.bits.Z); } +static BOOL DESMUME_FASTCALL test_LS(Status_Reg CPSR) { return (CPSR.bits.Z) || (!CPSR.bits.C); } +static BOOL DESMUME_FASTCALL test_GE(Status_Reg CPSR) { return (CPSR.bits.N==CPSR.bits.V); } +static BOOL DESMUME_FASTCALL test_LT(Status_Reg CPSR) { return (CPSR.bits.N!=CPSR.bits.V); } +static BOOL DESMUME_FASTCALL test_GT(Status_Reg CPSR) { return (!CPSR.bits.Z) && (CPSR.bits.N==CPSR.bits.V); } +static BOOL DESMUME_FASTCALL test_LE(Status_Reg CPSR) { return ( CPSR.bits.Z) || (CPSR.bits.N!=CPSR.bits.V); } +static BOOL DESMUME_FASTCALL test_AL(Status_Reg CPSR) { return 1; } -static BOOL (FASTCALL* test_conditions[])(Status_Reg CPSR)= { +static BOOL (DESMUME_FASTCALL* test_conditions[])(Status_Reg CPSR)= { test_EQ , test_NE , test_CS , test_CC , test_MI , test_PL , diff --git a/desmume/src/gdbstub/gdbstub.cpp b/desmume/src/gdbstub/gdbstub.cpp index 48367bc4c..9a896714a 100644 --- a/desmume/src/gdbstub/gdbstub.cpp +++ b/desmume/src/gdbstub/gdbstub.cpp @@ -1386,7 +1386,7 @@ WINAPI listenerThread_gdb( void *data) { * The memory interface * */ -static uint32_t FASTCALL gdb_prefetch32( void *data, uint32_t adr) { +static uint32_t DESMUME_FASTCALL gdb_prefetch32( void *data, uint32_t adr) { struct gdb_stub_state *stub = (struct gdb_stub_state *)data; int breakpoint; @@ -1397,7 +1397,7 @@ static uint32_t FASTCALL gdb_prefetch32( void *data, uint32_t adr) { return 0; } -static uint16_t FASTCALL gdb_prefetch16( void *data, uint32_t adr) { +static uint16_t DESMUME_FASTCALL gdb_prefetch16( void *data, uint32_t adr) { struct gdb_stub_state *stub = (struct gdb_stub_state *)data; int breakpoint; @@ -1409,7 +1409,7 @@ static uint16_t FASTCALL gdb_prefetch16( void *data, uint32_t adr) { } /** read 8 bit data value */ -static uint8_t FASTCALL +static uint8_t DESMUME_FASTCALL gdb_read8( void *data, uint32_t adr) { struct gdb_stub_state *stub = (struct gdb_stub_state *)data; uint8_t value = 0; @@ -1428,7 +1428,7 @@ gdb_read8( void *data, uint32_t adr) { } /** read 16 bit data value */ -static uint16_t FASTCALL +static uint16_t DESMUME_FASTCALL gdb_read16( void *data, uint32_t adr) { struct gdb_stub_state *stub = (struct gdb_stub_state *)data; uint16_t value; @@ -1446,7 +1446,7 @@ gdb_read16( void *data, uint32_t adr) { return value; } /** read 32 bit data value */ -static uint32_t FASTCALL +static uint32_t DESMUME_FASTCALL gdb_read32( void *data, uint32_t adr) { struct gdb_stub_state *stub = (struct gdb_stub_state *)data; uint32_t value; @@ -1465,7 +1465,7 @@ gdb_read32( void *data, uint32_t adr) { } /** write 8 bit data value */ -static void FASTCALL +static void DESMUME_FASTCALL gdb_write8( void *data, uint32_t adr, uint8_t val) { struct gdb_stub_state *stub = (struct gdb_stub_state *)data; int breakpoint; @@ -1481,7 +1481,7 @@ gdb_write8( void *data, uint32_t adr, uint8_t val) { } /** write 16 bit data value */ -static void FASTCALL +static void DESMUME_FASTCALL gdb_write16( void *data, uint32_t adr, uint16_t val) { struct gdb_stub_state *stub = (struct gdb_stub_state *)data; int breakpoint; @@ -1497,7 +1497,7 @@ gdb_write16( void *data, uint32_t adr, uint16_t val) { } /** write 32 bit data value */ -static void FASTCALL +static void DESMUME_FASTCALL gdb_write32( void *data, uint32_t adr, uint32_t val) { struct gdb_stub_state *stub = (struct gdb_stub_state *)data; int breakpoint; diff --git a/desmume/src/instructions.h b/desmume/src/instructions.h index 3a4dc750a..9b85c25af 100644 --- a/desmume/src/instructions.h +++ b/desmume/src/instructions.h @@ -20,7 +20,7 @@ #include "types.h" -typedef u32 (FASTCALL* OpFunc)(const u32 i); +typedef u32 (DESMUME_FASTCALL* OpFunc)(const u32 i); extern const OpFunc arm_instructions_set[2][4096]; extern const char* arm_instruction_names[4096]; extern const OpFunc thumb_instructions_set[2][1024]; diff --git a/desmume/src/thumb_instructions.cpp b/desmume/src/thumb_instructions.cpp index 6077ba416..2d9a2362a 100644 --- a/desmume/src/thumb_instructions.cpp +++ b/desmume/src/thumb_instructions.cpp @@ -37,7 +37,7 @@ //----------------------------------------------------------------------------- // Undefined instruction //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_UND_THUMB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_UND_THUMB(const u32 i) { INFO("THUMB%c: Undefined instruction: 0x%08X PC=0x%08X\n", cpu->proc_ID?'7':'9', cpu->instruction, cpu->instruct_adr); TRAPUNDEF(cpu); @@ -48,7 +48,7 @@ TEMPLATE static u32 FASTCALL OP_UND_THUMB(const u32 i) // LSL //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_LSL_0(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LSL_0(const u32 i) { cpu->R[REG_NUM(i, 0)] = cpu->R[REG_NUM(i, 3)]; cpu->CPSR.bits.N = BIT31(cpu->R[REG_NUM(i, 0)]); @@ -57,7 +57,7 @@ TEMPLATE static u32 FASTCALL OP_LSL_0(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_LSL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LSL(const u32 i) { u32 v = (i>>6) & 0x1F; cpu->CPSR.bits.C = BIT_N(cpu->R[REG_NUM(i, 3)], 32-v); @@ -68,7 +68,7 @@ TEMPLATE static u32 FASTCALL OP_LSL(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_LSL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LSL_REG(const u32 i) { u32 v = cpu->R[REG_NUM(i, 3)] & 0xFF; @@ -102,7 +102,7 @@ TEMPLATE static u32 FASTCALL OP_LSL_REG(const u32 i) // LSR //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_LSR_0(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LSR_0(const u32 i) { cpu->CPSR.bits.C = BIT31(cpu->R[REG_NUM(i, 3)]); cpu->R[REG_NUM(i, 0)] = 0; @@ -112,7 +112,7 @@ TEMPLATE static u32 FASTCALL OP_LSR_0(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_LSR(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LSR(const u32 i) { u32 v = (i>>6) & 0x1F; cpu->CPSR.bits.C = BIT_N(cpu->R[REG_NUM(i, 3)], v-1); @@ -123,7 +123,7 @@ TEMPLATE static u32 FASTCALL OP_LSR(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_LSR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LSR_REG(const u32 i) { u32 v = cpu->R[REG_NUM(i, 3)] & 0xFF; @@ -156,7 +156,7 @@ TEMPLATE static u32 FASTCALL OP_LSR_REG(const u32 i) // ASR //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_ASR_0(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ASR_0(const u32 i) { cpu->CPSR.bits.C = BIT31(cpu->R[REG_NUM(i, 3)]); cpu->R[REG_NUM(i, 0)] = BIT31(cpu->R[REG_NUM(i, 3)])*0xFFFFFFFF; @@ -166,7 +166,7 @@ TEMPLATE static u32 FASTCALL OP_ASR_0(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_ASR(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ASR(const u32 i) { u32 v = (i>>6) & 0x1F; cpu->CPSR.bits.C = BIT_N(cpu->R[REG_NUM(i, 3)], v-1); @@ -177,7 +177,7 @@ TEMPLATE static u32 FASTCALL OP_ASR(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_ASR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ASR_REG(const u32 i) { u32 v = cpu->R[REG_NUM(i, 3)] & 0xFF; @@ -208,7 +208,7 @@ TEMPLATE static u32 FASTCALL OP_ASR_REG(const u32 i) // ADD //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_ADD_IMM3(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_IMM3(const u32 i) { u32 imm3 = (i >> 6) & 0x07; u32 Rn = cpu->R[REG_NUM(i, 3)]; @@ -233,7 +233,7 @@ TEMPLATE static u32 FASTCALL OP_ADD_IMM3(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_ADD_IMM8(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_IMM8(const u32 i) { u32 imm8 = (i & 0xFF); u32 Rd = cpu->R[REG_NUM(i, 8)]; @@ -247,7 +247,7 @@ TEMPLATE static u32 FASTCALL OP_ADD_IMM8(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_ADD_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_REG(const u32 i) { u32 Rn = cpu->R[REG_NUM(i, 3)]; u32 Rm = cpu->R[REG_NUM(i, 6)]; @@ -261,7 +261,7 @@ TEMPLATE static u32 FASTCALL OP_ADD_REG(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_ADD_SPE(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_SPE(const u32 i) { u32 Rd = REG_NUM(i, 0) | ((i>>4)&8); @@ -276,14 +276,14 @@ TEMPLATE static u32 FASTCALL OP_ADD_SPE(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_ADD_2PC(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_2PC(const u32 i) { cpu->R[REG_NUM(i, 8)] = (cpu->R[15]&0xFFFFFFFC) + ((i&0xFF)<<2); return 1; } -TEMPLATE static u32 FASTCALL OP_ADD_2SP(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADD_2SP(const u32 i) { cpu->R[REG_NUM(i, 8)] = cpu->R[13] + ((i&0xFF)<<2); @@ -294,7 +294,7 @@ TEMPLATE static u32 FASTCALL OP_ADD_2SP(const u32 i) // SUB //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_SUB_IMM3(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_IMM3(const u32 i) { u32 imm3 = (i>>6) & 0x07; u32 Rn = cpu->R[REG_NUM(i, 3)]; @@ -309,7 +309,7 @@ TEMPLATE static u32 FASTCALL OP_SUB_IMM3(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_SUB_IMM8(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_IMM8(const u32 i) { u32 imm8 = (i & 0xFF); u32 Rd = cpu->R[REG_NUM(i, 8)]; @@ -324,7 +324,7 @@ TEMPLATE static u32 FASTCALL OP_SUB_IMM8(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_SUB_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SUB_REG(const u32 i) { u32 Rn = cpu->R[REG_NUM(i, 3)]; u32 Rm = cpu->R[REG_NUM(i, 6)]; @@ -343,7 +343,7 @@ TEMPLATE static u32 FASTCALL OP_SUB_REG(const u32 i) // MOV //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_MOV_IMM8(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_IMM8(const u32 i) { cpu->R[REG_NUM(i, 8)] = (i & 0xFF); cpu->CPSR.bits.N = BIT31(cpu->R[REG_NUM(i, 8)]); @@ -352,7 +352,7 @@ TEMPLATE static u32 FASTCALL OP_MOV_IMM8(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_MOV_SPE(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MOV_SPE(const u32 i) { u32 Rd = REG_NUM(i, 0) | ((i>>4)&8); @@ -370,7 +370,7 @@ TEMPLATE static u32 FASTCALL OP_MOV_SPE(const u32 i) //----------------------------------------------------------------------------- // CMP //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_CMP_IMM8(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMP_IMM8(const u32 i) { u32 tmp = cpu->R[REG_NUM(i, 8)] - (i & 0xFF); @@ -382,7 +382,7 @@ TEMPLATE static u32 FASTCALL OP_CMP_IMM8(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_CMP(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMP(const u32 i) { u32 tmp = cpu->R[REG_NUM(i, 0)] - cpu->R[REG_NUM(i, 3)]; @@ -394,7 +394,7 @@ TEMPLATE static u32 FASTCALL OP_CMP(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_CMP_SPE(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMP_SPE(const u32 i) { u32 Rn = (i&7) | ((i>>4)&8); @@ -412,7 +412,7 @@ TEMPLATE static u32 FASTCALL OP_CMP_SPE(const u32 i) // AND //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_AND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_AND(const u32 i) { cpu->R[REG_NUM(i, 0)] &= cpu->R[REG_NUM(i, 3)]; cpu->CPSR.bits.N = BIT31(cpu->R[REG_NUM(i, 0)]); @@ -424,7 +424,7 @@ TEMPLATE static u32 FASTCALL OP_AND(const u32 i) // EOR //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_EOR(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_EOR(const u32 i) { cpu->R[REG_NUM(i, 0)] ^= cpu->R[REG_NUM(i, 3)]; cpu->CPSR.bits.N = BIT31(cpu->R[REG_NUM(i, 0)]); @@ -437,7 +437,7 @@ TEMPLATE static u32 FASTCALL OP_EOR(const u32 i) // ADC //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_ADC_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADC_REG(const u32 i) { u32 Rd = cpu->R[REG_NUM(i, 0)]; u32 Rm = cpu->R[REG_NUM(i, 3)]; @@ -462,7 +462,7 @@ TEMPLATE static u32 FASTCALL OP_ADC_REG(const u32 i) //----------------------------------------------------------------------------- // SBC //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_SBC_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SBC_REG(const u32 i) { u32 Rd = cpu->R[REG_NUM(i, 0)]; u32 Rm = cpu->R[REG_NUM(i, 3)]; @@ -489,7 +489,7 @@ TEMPLATE static u32 FASTCALL OP_SBC_REG(const u32 i) // ROR //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_ROR_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ROR_REG(const u32 i) { u32 v = cpu->R[REG_NUM(i, 3)] & 0xFF; @@ -520,7 +520,7 @@ TEMPLATE static u32 FASTCALL OP_ROR_REG(const u32 i) // TST //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_TST(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_TST(const u32 i) { u32 tmp = cpu->R[REG_NUM(i, 0)] & cpu->R[REG_NUM(i, 3)]; cpu->CPSR.bits.N = BIT31(tmp); @@ -533,7 +533,7 @@ TEMPLATE static u32 FASTCALL OP_TST(const u32 i) // NEG //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_NEG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_NEG(const u32 i) { u32 Rm = cpu->R[REG_NUM(i, 3)]; @@ -551,7 +551,7 @@ TEMPLATE static u32 FASTCALL OP_NEG(const u32 i) // CMN //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_CMN(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_CMN(const u32 i) { u32 tmp = cpu->R[REG_NUM(i, 0)] + cpu->R[REG_NUM(i, 3)]; @@ -567,7 +567,7 @@ TEMPLATE static u32 FASTCALL OP_CMN(const u32 i) // ORR //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_ORR(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ORR(const u32 i) { cpu->R[REG_NUM(i, 0)] |= cpu->R[REG_NUM(i, 3)]; @@ -581,7 +581,7 @@ TEMPLATE static u32 FASTCALL OP_ORR(const u32 i) // BIC //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_BIC(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BIC(const u32 i) { cpu->R[REG_NUM(i, 0)] &= (~cpu->R[REG_NUM(i, 3)]); @@ -595,7 +595,7 @@ TEMPLATE static u32 FASTCALL OP_BIC(const u32 i) // MVN //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_MVN(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MVN(const u32 i) { cpu->R[REG_NUM(i, 0)] = (~cpu->R[REG_NUM(i, 3)]); @@ -621,7 +621,7 @@ TEMPLATE static u32 FASTCALL OP_MVN(const u32 i) return c+3; \ return c+4; \ -TEMPLATE static u32 FASTCALL OP_MUL_REG(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_MUL_REG(const u32 i) { u32 v = cpu->R[REG_NUM(i, 3)]; @@ -648,7 +648,7 @@ TEMPLATE static u32 FASTCALL OP_MUL_REG(const u32 i) // STRB / LDRB //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_STRB_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 3)] + ((i>>6)&0x1F); WRITE8(cpu->mem_if->data, adr, (u8)cpu->R[REG_NUM(i, 0)]); @@ -656,7 +656,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2, adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 3)] + ((i>>6)&0x1F); cpu->R[REG_NUM(i, 0)] = (u32)READ8(cpu->mem_if->data, adr); @@ -665,7 +665,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_IMM_OFF(const u32 i) } -TEMPLATE static u32 FASTCALL OP_STRB_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRB_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 3)] + cpu->R[REG_NUM(i, 6)]; WRITE8(cpu->mem_if->data, adr, (u8)cpu->R[REG_NUM(i, 0)]); @@ -673,7 +673,7 @@ TEMPLATE static u32 FASTCALL OP_STRB_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(2, adr); } -TEMPLATE static u32 FASTCALL OP_LDRB_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRB_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 3)] + cpu->R[REG_NUM(i, 6)]; cpu->R[REG_NUM(i, 0)] = (u32)READ8(cpu->mem_if->data, adr); @@ -685,7 +685,7 @@ TEMPLATE static u32 FASTCALL OP_LDRB_REG_OFF(const u32 i) // LDRSB //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_LDRSB_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSB_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 3)] + cpu->R[REG_NUM(i, 6)]; cpu->R[REG_NUM(i, 0)] = (u32)((s8)READ8(cpu->mem_if->data, adr)); @@ -697,7 +697,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSB_REG_OFF(const u32 i) // STRH / LDRH //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_STRH_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 3)] + ((i>>5)&0x3E); WRITE16(cpu->mem_if->data, adr, (u16)cpu->R[REG_NUM(i, 0)]); @@ -705,7 +705,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2, adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 3)] + ((i>>5)&0x3E); cpu->R[REG_NUM(i, 0)] = (u32)READ16(cpu->mem_if->data, adr); @@ -714,7 +714,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_IMM_OFF(const u32 i) } -TEMPLATE static u32 FASTCALL OP_STRH_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STRH_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 3)] + cpu->R[REG_NUM(i, 6)]; WRITE16(cpu->mem_if->data, adr, ((u16)cpu->R[REG_NUM(i, 0)])); @@ -722,7 +722,7 @@ TEMPLATE static u32 FASTCALL OP_STRH_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(2, adr); } -TEMPLATE static u32 FASTCALL OP_LDRH_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRH_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 3)] + cpu->R[REG_NUM(i, 6)]; cpu->R[REG_NUM(i, 0)] = (u32)READ16(cpu->mem_if->data, adr); @@ -734,7 +734,7 @@ TEMPLATE static u32 FASTCALL OP_LDRH_REG_OFF(const u32 i) // LDRSH //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_LDRSH_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDRSH_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 3)] + cpu->R[REG_NUM(i, 6)]; cpu->R[REG_NUM(i, 0)] = (u32)((s16)READ16(cpu->mem_if->data, adr)); @@ -746,7 +746,7 @@ TEMPLATE static u32 FASTCALL OP_LDRSH_REG_OFF(const u32 i) // STR / LDR //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_STR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 3)] + ((i>>4)&0x7C); WRITE32(cpu->mem_if->data, adr, cpu->R[REG_NUM(i, 0)]); @@ -754,7 +754,7 @@ TEMPLATE static u32 FASTCALL OP_STR_IMM_OFF(const u32 i) return MMU_aluMemAccessCycles(2, adr); } -TEMPLATE static u32 FASTCALL OP_LDR_IMM_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_IMM_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 3)] + ((i>>4)&0x7C); u32 tempValue = READ32(cpu->mem_if->data, adr); @@ -766,7 +766,7 @@ TEMPLATE static u32 FASTCALL OP_LDR_IMM_OFF(const u32 i) } -TEMPLATE static u32 FASTCALL OP_STR_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_REG_OFF(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 6)] + cpu->R[REG_NUM(i, 3)]; WRITE32(cpu->mem_if->data, adr, cpu->R[REG_NUM(i, 0)]); @@ -774,7 +774,7 @@ TEMPLATE static u32 FASTCALL OP_STR_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(2, adr); } -TEMPLATE static u32 FASTCALL OP_LDR_REG_OFF(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_REG_OFF(const u32 i) { u32 adr = (cpu->R[REG_NUM(i, 3)] + cpu->R[REG_NUM(i, 6)]); u32 tempValue = READ32(cpu->mem_if->data, adr); @@ -785,7 +785,7 @@ TEMPLATE static u32 FASTCALL OP_LDR_REG_OFF(const u32 i) return MMU_aluMemAccessCycles(3, adr); } -TEMPLATE static u32 FASTCALL OP_STR_SPREL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STR_SPREL(const u32 i) { u32 adr = cpu->R[13] + ((i&0xFF)<<2); WRITE32(cpu->mem_if->data, adr, cpu->R[REG_NUM(i, 8)]); @@ -793,7 +793,7 @@ TEMPLATE static u32 FASTCALL OP_STR_SPREL(const u32 i) return MMU_aluMemAccessCycles(2, adr); } -TEMPLATE static u32 FASTCALL OP_LDR_SPREL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_SPREL(const u32 i) { u32 adr = cpu->R[13] + ((i&0xFF)<<2); cpu->R[REG_NUM(i, 8)] = READ32(cpu->mem_if->data, adr); @@ -801,7 +801,7 @@ TEMPLATE static u32 FASTCALL OP_LDR_SPREL(const u32 i) return MMU_aluMemAccessCycles(3, adr); } -TEMPLATE static u32 FASTCALL OP_LDR_PCREL(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDR_PCREL(const u32 i) { u32 adr = (cpu->R[15]&0xFFFFFFFC) + ((i&0xFF)<<2); @@ -814,14 +814,14 @@ TEMPLATE static u32 FASTCALL OP_LDR_PCREL(const u32 i) // Adjust SP //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_ADJUST_P_SP(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADJUST_P_SP(const u32 i) { cpu->R[13] += ((i&0x7F)<<2); return 1; } -TEMPLATE static u32 FASTCALL OP_ADJUST_M_SP(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_ADJUST_M_SP(const u32 i) { cpu->R[13] -= ((i&0x7F)<<2); @@ -832,7 +832,7 @@ TEMPLATE static u32 FASTCALL OP_ADJUST_M_SP(const u32 i) // PUSH / POP //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_PUSH(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_PUSH(const u32 i) { u32 adr = cpu->R[13] - 4; u32 c = 0, j; @@ -849,7 +849,7 @@ TEMPLATE static u32 FASTCALL OP_PUSH(const u32 i) return MMU_aluMemCycles(3, c); } -TEMPLATE static u32 FASTCALL OP_PUSH_LR(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_PUSH_LR(const u32 i) { u32 adr = cpu->R[13] - 4; u32 c = 0, j; @@ -870,7 +870,7 @@ TEMPLATE static u32 FASTCALL OP_PUSH_LR(const u32 i) return MMU_aluMemCycles(4, c); } -TEMPLATE static u32 FASTCALL OP_POP(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_POP(const u32 i) { u32 adr = cpu->R[13]; u32 c = 0, j; @@ -894,7 +894,7 @@ TEMPLATE static u32 FASTCALL OP_POP(const u32 i) // In T variants of ARMv4, bit[0] of the loaded value is ignored and execution continues in Thumb state, as // though the following instruction had been executed: // MOV PC,(loaded_value) -TEMPLATE static u32 FASTCALL OP_POP_PC(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_POP_PC(const u32 i) { u32 adr = cpu->R[13]; u32 c = 0, j; @@ -924,7 +924,7 @@ TEMPLATE static u32 FASTCALL OP_POP_PC(const u32 i) // STMIA / LDMIA //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_STMIA_THUMB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_STMIA_THUMB(const u32 i) { u32 adr = cpu->R[REG_NUM(i, 8)]; u32 c = 0, j; @@ -955,7 +955,7 @@ TEMPLATE static u32 FASTCALL OP_STMIA_THUMB(const u32 i) return MMU_aluMemCycles(2, c); } -TEMPLATE static u32 FASTCALL OP_LDMIA_THUMB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_LDMIA_THUMB(const u32 i) { u32 regIndex = REG_NUM(i, 8); u32 adr = cpu->R[regIndex]; @@ -992,7 +992,7 @@ TEMPLATE static u32 FASTCALL OP_LDMIA_THUMB(const u32 i) // BKPT //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_BKPT_THUMB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BKPT_THUMB(const u32 i) { printf("THUMB%c: OP_BKPT triggered\n", PROCNUM?'7':'9'); Status_Reg tmp = cpu->CPSR; @@ -1011,7 +1011,7 @@ TEMPLATE static u32 FASTCALL OP_BKPT_THUMB(const u32 i) // SWI //----------------------------------------------------------------------------- -TEMPLATE static u32 FASTCALL OP_SWI_THUMB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_SWI_THUMB(const u32 i) { u32 swinum = i & 0xFF; @@ -1060,7 +1060,7 @@ TEMPLATE static u32 FASTCALL OP_SWI_THUMB(const u32 i) #define SIGNEEXT_IMM11(i) (((i)&0x7FF) | (BIT10(i) * 0xFFFFF800)) #define SIGNEXTEND_11(i) (((s32)i<<21)>>21) -TEMPLATE static u32 FASTCALL OP_B_COND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_B_COND(const u32 i) { if(!TEST_COND((i>>8)&0xF, 0, cpu->CPSR)) return 1; @@ -1070,7 +1070,7 @@ TEMPLATE static u32 FASTCALL OP_B_COND(const u32 i) return 3; } -TEMPLATE static u32 FASTCALL OP_B_UNCOND(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_B_UNCOND(const u32 i) { //nocash message detection const u16 last = _MMU_read16(cpu->instruct_adr-2); @@ -1086,7 +1086,7 @@ TEMPLATE static u32 FASTCALL OP_B_UNCOND(const u32 i) return 1; } -TEMPLATE static u32 FASTCALL OP_BLX(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BLX(const u32 i) { cpu->R[15] = (cpu->R[14] + ((i&0x7FF)<<1))&0xFFFFFFFC; cpu->R[14] = cpu->next_instruction | 1; @@ -1095,13 +1095,13 @@ TEMPLATE static u32 FASTCALL OP_BLX(const u32 i) return 3; } -TEMPLATE static u32 FASTCALL OP_BL_10(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BL_10(const u32 i) { cpu->R[14] = cpu->R[15] + (SIGNEXTEND_11(i)<<12); return 1; } -TEMPLATE static u32 FASTCALL OP_BL_11(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BL_11(const u32 i) { cpu->R[15] = (cpu->R[14] + ((i&0x7FF)<<1)); cpu->R[14] = cpu->next_instruction | 1; @@ -1109,7 +1109,7 @@ TEMPLATE static u32 FASTCALL OP_BL_11(const u32 i) return 4; } -TEMPLATE static u32 FASTCALL OP_BX_THUMB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BX_THUMB(const u32 i) { // When using PC as operand with BX opcode, switch to ARM state and jump to (instruct_adr+4) // Reference: http://nocash.emubase.de/gbatek.htm#thumb5hiregisteroperationsbranchexchange @@ -1149,7 +1149,7 @@ TEMPLATE static u32 FASTCALL OP_BX_THUMB(const u32 i) return 3; } -TEMPLATE static u32 FASTCALL OP_BLX_THUMB(const u32 i) +TEMPLATE static u32 DESMUME_FASTCALL OP_BLX_THUMB(const u32 i) { u32 Rm = cpu->R[REG_POS(i, 3)]; cpu->CPSR.bits.T = BIT0(Rm); diff --git a/desmume/src/types.h b/desmume/src/types.h index cddf2fc45..0a253ef43 100644 --- a/desmume/src/types.h +++ b/desmume/src/types.h @@ -178,16 +178,16 @@ //--------------------------------------------- #ifdef __MINGW32__ - #define FASTCALL __attribute__((fastcall)) + #define DESMUME_FASTCALL __attribute__((fastcall)) #define ASMJIT_CALL_CONV kX86FuncConvGccFastCall #elif defined (__i386__) && !defined(__clang__) - #define FASTCALL __attribute__((regparm(3))) + #define DESMUME_FASTCALL __attribute__((regparm(3))) #define ASMJIT_CALL_CONV kX86FuncConvGccRegParm3 #elif defined(_MSC_VER) || defined(__INTEL_COMPILER) - #define FASTCALL + #define DESMUME_FASTCALL #define ASMJIT_CALL_CONV kX86FuncConvDefault #else - #define FASTCALL + #define DESMUME_FASTCALL #define ASMJIT_CALL_CONV kX86FuncConvDefault #endif diff --git a/desmume/src/utils/arm_jit/arm_jit_arm.cpp b/desmume/src/utils/arm_jit/arm_jit_arm.cpp index c62241e42..24cf5fb25 100755 --- a/desmume/src/utils/arm_jit/arm_jit_arm.cpp +++ b/desmume/src/utils/arm_jit/arm_jit_arm.cpp @@ -388,7 +388,7 @@ static void _armlog(u8 proc, u32 addr, u32 opcode); //----------------------------------------------------------------------------- template -static u32 FASTCALL OP_DECODE() +static u32 DESMUME_FASTCALL OP_DECODE() { u32 cycles; u32 adr = cpu->instruct_adr; @@ -1442,7 +1442,7 @@ static int OP_MSR_SPSR_IMM_VAL(const u32 i) { OP_MSR_(SPSR, IMM_VAL, 0); } //----------------------------------------------------------------------------- // LDR //----------------------------------------------------------------------------- -typedef u32 (FASTCALL* OpLDR)(u32, u32*); +typedef u32 (DESMUME_FASTCALL* OpLDR)(u32, u32*); // 98% of all memory accesses land in the same region as the first execution of // that instruction, so keep multiple copies with different fastpaths. @@ -1473,7 +1473,7 @@ static u32 classify_adr(u32 adr, bool store) } template -static u32 FASTCALL OP_LDR(u32 adr, u32 *dstreg) +static u32 DESMUME_FASTCALL OP_LDR(u32 adr, u32 *dstreg) { u32 data = READ32(cpu->mem_if->data, adr); if(adr&3) @@ -1483,21 +1483,21 @@ static u32 FASTCALL OP_LDR(u32 adr, u32 *dstreg) } template -static u32 FASTCALL OP_LDRH(u32 adr, u32 *dstreg) +static u32 DESMUME_FASTCALL OP_LDRH(u32 adr, u32 *dstreg) { *dstreg = READ16(cpu->mem_if->data, adr); return MMU_aluMemAccessCycles(3,adr); } template -static u32 FASTCALL OP_LDRSH(u32 adr, u32 *dstreg) +static u32 DESMUME_FASTCALL OP_LDRSH(u32 adr, u32 *dstreg) { *dstreg = (s16)READ16(cpu->mem_if->data, adr); return MMU_aluMemAccessCycles(3,adr); } template -static u32 FASTCALL OP_LDRB(u32 adr, u32 *dstreg) +static u32 DESMUME_FASTCALL OP_LDRB(u32 adr, u32 *dstreg) { *dstreg = READ8(cpu->mem_if->data, adr); u32 ret = MMU_aluMemAccessCycles(3,adr); @@ -1505,7 +1505,7 @@ static u32 FASTCALL OP_LDRB(u32 adr, u32 *dstreg) } template -static u32 FASTCALL OP_LDRSB(u32 adr, u32 *dstreg) +static u32 DESMUME_FASTCALL OP_LDRSB(u32 adr, u32 *dstreg) { *dstreg = (s8)READ8(cpu->mem_if->data, adr); return MMU_aluMemAccessCycles(3,adr); @@ -1688,27 +1688,27 @@ static int OP_LDRSB_POS_INDE_M_REG_OFF(const u32 i) { OP_LDR_(LDRSB, REG_OFF, su // STR //----------------------------------------------------------------------------- template -static u32 FASTCALL OP_STR(u32 adr, u32 data) +static u32 DESMUME_FASTCALL OP_STR(u32 adr, u32 data) { WRITE32(cpu->mem_if->data, adr, data); return MMU_aluMemAccessCycles(2,adr); } template -static u32 FASTCALL OP_STRH(u32 adr, u32 data) +static u32 DESMUME_FASTCALL OP_STRH(u32 adr, u32 data) { WRITE16(cpu->mem_if->data, adr, data); return MMU_aluMemAccessCycles(2,adr); } template -static u32 FASTCALL OP_STRB(u32 adr, u32 data) +static u32 DESMUME_FASTCALL OP_STRB(u32 adr, u32 data) { WRITE8(cpu->mem_if->data, adr, data); return MMU_aluMemAccessCycles(2,adr); } -typedef u32 (FASTCALL* OpSTR)(u32, u32); +typedef u32 (DESMUME_FASTCALL* OpSTR)(u32, u32); #define T(op) op<0,0>, op<0,1>, op<0,2>, op<1,0>, op<1,1>, NULL static const OpSTR STR_tab[2][3] = { T(OP_STR) }; static const OpSTR STRH_tab[2][3] = { T(OP_STRH) }; @@ -1829,9 +1829,9 @@ static int OP_STRB_M_ROR_IMM_OFF_POSTIND(const u32 i) { OP_STR_(STRB, ROR_IMM, s //----------------------------------------------------------------------------- // LDRD / STRD //----------------------------------------------------------------------------- -typedef u32 FASTCALL (*LDRD_STRD_REG)(u32); +typedef u32 DESMUME_FASTCALL (*LDRD_STRD_REG)(u32); template -static u32 FASTCALL OP_LDRD_REG(u32 adr) +static u32 DESMUME_FASTCALL OP_LDRD_REG(u32 adr) { cpu->R[Rnum] = READ32(cpu->mem_if->data, adr); @@ -1845,7 +1845,7 @@ static u32 FASTCALL OP_LDRD_REG(u32 adr) return MMU_memAccessCycles(adr); } template -static u32 FASTCALL OP_STRD_REG(u32 adr) +static u32 DESMUME_FASTCALL OP_STRD_REG(u32 adr) { WRITE32(cpu->mem_if->data, adr, cpu->R[Rnum]); @@ -1992,7 +1992,7 @@ static int OP_LDRD_STRD_OFFSET_PRE_INDEX(const u32 i) // SWP/SWPB //----------------------------------------------------------------------------- template -static u32 FASTCALL op_swp(u32 adr, u32 *Rd, u32 Rs) +static u32 DESMUME_FASTCALL op_swp(u32 adr, u32 *Rd, u32 Rs) { u32 tmpt = ROR(READ32(cpu->mem_if->data, adr), (adr & 3)<<3); WRITE32(cpu->mem_if->data, adr, Rs); @@ -2000,7 +2000,7 @@ static u32 FASTCALL op_swp(u32 adr, u32 *Rd, u32 Rs) return (MMU_memAccessCycles(adr) + MMU_memAccessCycles(adr)); } template -static u32 FASTCALL op_swpb(u32 adr, u32 *Rd, u32 Rs) +static u32 DESMUME_FASTCALL op_swpb(u32 adr, u32 *Rd, u32 Rs) { u32 tmpt = READ8(cpu->mem_if->data, adr); WRITE8(cpu->mem_if->data, adr, Rs); @@ -2008,7 +2008,7 @@ static u32 FASTCALL op_swpb(u32 adr, u32 *Rd, u32 Rs) return (MMU_memAccessCycles(adr) + MMU_memAccessCycles(adr)); } -typedef u32 FASTCALL (*OP_SWP_SWPB)(u32, u32*, u32); +typedef u32 DESMUME_FASTCALL (*OP_SWP_SWPB)(u32, u32*, u32); static const OP_SWP_SWPB op_swp_tab[2][2] = {{ op_swp<0>, op_swp<1> }, { op_swpb<0>, op_swpb<1> }}; static int op_swp_(const u32 i, int b) @@ -2083,7 +2083,7 @@ static u64 get_reg_list(u32 reg_mask, int dir) #endif template -static LDM_INLINE FASTCALL u32 OP_LDM_STM_generic(u32 adr, u64 regs, int n) +static LDM_INLINE DESMUME_FASTCALL u32 OP_LDM_STM_generic(u32 adr, u64 regs, int n) { u32 cycles = 0; adr &= ~3; @@ -2104,7 +2104,7 @@ static LDM_INLINE FASTCALL u32 OP_LDM_STM_generic(u32 adr, u64 regs, int n) #endif template -static LDM_INLINE FASTCALL u32 OP_LDM_STM_other(u32 adr, u64 regs, int n) +static LDM_INLINE DESMUME_FASTCALL u32 OP_LDM_STM_other(u32 adr, u64 regs, int n) { u32 cycles = 0; adr &= ~3; @@ -2126,7 +2126,7 @@ static LDM_INLINE FASTCALL u32 OP_LDM_STM_other(u32 adr, u64 regs, int n) } template -static FORCEINLINE FASTCALL u32 OP_LDM_STM_main(u32 adr, u64 regs, int n, u8 *ptr, u32 cycles) +static FORCEINLINE DESMUME_FASTCALL u32 OP_LDM_STM_main(u32 adr, u64 regs, int n, u8 *ptr, u32 cycles) { #ifdef ENABLE_ADVANCED_TIMING cycles = 0; @@ -2165,7 +2165,7 @@ static FORCEINLINE FASTCALL u32 OP_LDM_STM_main(u32 adr, u64 regs, int n, u8 *pt } template -static u32 FASTCALL OP_LDM_STM(u32 adr, u32 regslo, u32 regshi, int n) +static u32 DESMUME_FASTCALL OP_LDM_STM(u32 adr, u32 regslo, u32 regshi, int n) { // TODO use classify_adr? u32 cycles; @@ -2207,7 +2207,7 @@ static u32 FASTCALL OP_LDM_STM(u32 adr, u32 regslo, u32 regshi, int n) return OP_LDM_STM_main(adr, regs, n, ptr, cycles); } -typedef u32 FASTCALL (*LDMOpFunc)(u32,u32,u32,int); +typedef u32 DESMUME_FASTCALL (*LDMOpFunc)(u32,u32,u32,int); static const LDMOpFunc op_ldm_stm_tab[2][2][2] = {{ { OP_LDM_STM<0,0,-1>, OP_LDM_STM<0,0,+1> }, { OP_LDM_STM<0,1,-1>, OP_LDM_STM<0,1,+1> },