Emulation/daedalus
1
0
Fork 0
mirror of https://github.com/DaedalusX64/daedalus.git synced 2024-06-01 18:58:00 -04:00
Code Issues Packages Projects Releases Wiki Activity

Fix warnings, still left some

Browse source
This commit is contained in:
Howard Su 2023-12-06 08:52:37 +08:00
parent 4a5abc3662
commit fcc875fb46
24 changed files with 443 additions and 452 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Source/CMakeLists.txt
View file

@ -20,6 +20,7 @@ if(DEBUG)
option(DAEDALUS_DEBUG_DISPLAYLIST "Options for debugging the display list, useful for determining texture issues" OFF)
option(DAEDALUS_LOG "Enable various logging" ON)
add_compile_options("-Wall")
add_compile_options("-Wextra")
else()
set(CMAKE_BUILD_TYPE RelWithDebInfo)
set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)

4
Source/Core/CPU.cpp
View file

@ -100,7 +100,7 @@ SCPUState *gPtrCPUState = (SCPUState*)0x10000;
alignas(CACHE_ALIGN) SCPUState gCPUState;
#endif
const static bool CPU_IsStateSimple();
static bool CPU_IsStateSimple();
void (* g_pCPUCore)();
using VblCallbackFn = void (*)(void * arg);
@ -395,7 +395,7 @@ bool CPU_RomOpen()
}
static const bool CPU_IsStateSimple()
static bool CPU_IsStateSimple()
{
bool rsp_halted = !RSP_IsRunning();

4
Source/Core/Cheats.cpp
View file

@ -290,7 +290,7 @@ bool CheatCodes_Read(const char *rom_name, const char *file, u8 countryID)
// Always clear when parsing a new ROM
CheatCodes_Clear();
std::filesystem::path p("cheat_file");
std::filesystem::path p(file);
const char *cheat_file = p.c_str();
stream = fopen(cheat_file, "rt");
@ -312,7 +312,7 @@ bool CheatCodes_Read(const char *rom_name, const char *file, u8 countryID)
// Locate the entry for current rom by searching for g_ROM.rh.Name
//
snprintf(romname,sizeof(current_rom_name), "[%s]", current_rom_name);
snprintf(romname,sizeof(romname), "[%s]", current_rom_name);
bfound = false;

15
Source/Core/Memory.cpp
View file

@ -681,29 +681,20 @@ void MemoryUpdateSPStatus( u32 flags )
if (flags & SP_CLR_SIG7) clr_bits |= SP_STATUS_SIG7;
if (flags & SP_SET_SIG7) set_bits |= SP_STATUS_SIG7;
#ifdef DAEDALUS_ENABLE_ASSERTS
u32 new_status = Memory_SP_SetRegisterBits( SP_STATUS_REG, ~clr_bits, set_bits );
#else
Memory_SP_SetRegisterBits( SP_STATUS_REG, ~clr_bits, set_bits );
#endif
//
// We execute the task here, after we've written to the SP status register.
//
if( start_rsp )
{
#ifdef DAEDALUS_ENABLE_ASSERTS
//DAEDALUS_ASSERT( !gRSPHLEActive, "RSP HLE already active. Status was %08x, now %08x", status, new_status );
#endif
// Check for tasks whenever the RSP is started
RSP_HLE_ProcessTask();
}
#ifdef DAEDALUS_ENABLE_ASSERTS
else if ( stop_rsp )
else if (stop_rsp)
{
//DAEDALUS_ASSERT( !RSP_IsRunningHLE(), "Stopping RSP while HLE task still running. Not good!" );
RSP_HLE_Reset();
}
#endif
}
#undef DISPLAY_DPC_WRITES

4
Source/Core/Memory.h
View file

@ -58,7 +58,7 @@ enum MEMBANKTYPE
static const u32 MEMORY_4_MEG( 4*1024*1024 );
static const u32 MEMORY_8_MEG( 8*1024*1024 );
#define MAX_RAM_ADDRESS MEMORY_8_MEG
using mReadFunction = void * (*)(u32 address);
using mReadFunction = const void * (*)(u32 address);
using mWriteFunction = void(*)(u32 address, u32 value);
struct MemFuncWrite
@ -99,7 +99,7 @@ extern MemFuncRead g_MemoryLookupTableRead[0x4000];
extern MemFuncWrite g_MemoryLookupTableWrite[0x4000];
// Fast memory access
inline void* const ReadAddress( u32 address )
inline const void* ReadAddress( u32 address )
{
const MemFuncRead & m( g_MemoryLookupTableRead[ address >> 18 ] );

36
Source/Core/Memory_Read.inl
View file

@ -17,7 +17,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
static void * ReadInvalid( u32 address )
static const void * ReadInvalid( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY, "Illegal Memory Access - Tried to Read From 0x%08x (PC: 0x%08x)", address, gCPUState.CurrentPC );
@ -31,7 +31,7 @@ static void * ReadInvalid( u32 address )
return temp;
}
static void * ReadMapped( u32 address )
static const void * ReadMapped( u32 address )
{
bool missing;
@ -51,14 +51,14 @@ static void * ReadMapped( u32 address )
}
}
static void * Read_8000_807F( u32 address )
static const void * Read_8000_807F( u32 address )
{
// Note: Mask is slighty different when EPAK isn't used 0x003FFFFF
return (u8 *)g_pMemoryBuffers[MEM_RD_RAM] + (address & 0x007FFFFF);
}
// 0x83F0 0000 to 0x83FF FFFF RDRAM registers
static void * Read_83F0_83F0( u32 address )
static const void * Read_83F0_83F0( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY_RDRAM_REG, "Reading from MEM_RD_REG: 0x%08x", address );
@ -67,7 +67,7 @@ static void * Read_83F0_83F0( u32 address )
}
// 0x0400 0000 to 0x0400 FFFF SP registers
static void * Read_8400_8400( u32 address )
static const void * Read_8400_8400( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY_SP_IMEM, "Reading from SP_MEM: 0x%08x", address );
@ -75,7 +75,7 @@ static void * Read_8400_8400( u32 address )
return (u8 *)g_pMemoryBuffers[MEM_SP_MEM] + (address & 0x1FFF);
}
static void * Read_8404_8404( u32 address )
static const void * Read_8404_8404( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY_SP_REG, "Reading from SP_REG: 0x%08x", address );
@ -83,7 +83,7 @@ static void * Read_8404_8404( u32 address )
return (u8 *)g_pMemoryBuffers[MEM_SP_REG] + (address & 0xFF);
}
static void * Read_8408_8408( u32 address )
static const void * Read_8408_8408( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY_SP_REG, "Reading from SP_PC_REG: 0x%08x", address );
@ -92,7 +92,7 @@ static void * Read_8408_8408( u32 address )
}
// 0x0410 0000 to 0x041F FFFF DP Command Registers
static void * Read_8410_841F( u32 address )
static const void * Read_8410_841F( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY_DP, "Reading from DP_COMMAND_REG: 0x%08x", address );
@ -101,7 +101,7 @@ static void * Read_8410_841F( u32 address )
}
// 0x0420 0000 to 0x042F FFFF DP Span Registers
static void * Read_8420_842F( u32 address )
static const void * Read_8420_842F( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DBGConsole_Msg( 0, "Read from DP Span Registers is unhandled (0x%08x, PC: 0x%08x)", address, gCPUState.CurrentPC );
@ -110,7 +110,7 @@ static void * Read_8420_842F( u32 address )
}
// 0x0430 0000 to 0x043F FFFF MIPS Interface (MI) Registers
static void * Read_8430_843F( u32 address )
static const void * Read_8430_843F( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY_MI, "Reading from MI Registers: 0x%08x", address );
@ -119,7 +119,7 @@ static void * Read_8430_843F( u32 address )
}
// 0x0440 0000 to 0x044F FFFF Video Interface (VI) Registers
static void * Read_8440_844F( u32 address )
static const void * Read_8440_844F( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY_VI, "Reading from MEM_VI_REG: 0x%08x", address );
@ -141,7 +141,7 @@ static void * Read_8440_844F( u32 address )
}
// 0x0450 0000 to 0x045F FFFF Audio Interface (AI) Registers
static void * Read_8450_845F( u32 address )
static const void * Read_8450_845F( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY_AI, "Reading from AI Registers: 0x%08x", address );
@ -150,7 +150,7 @@ static void * Read_8450_845F( u32 address )
}
// 0x0460 0000 to 0x046F FFFF Peripheral Interface (PI) Registers
static void * Read_8460_846F( u32 address )
static const void * Read_8460_846F( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY_PI, "Reading from MEM_PI_REG: 0x%08x", address );
@ -160,7 +160,7 @@ static void * Read_8460_846F( u32 address )
// 0x0470 0000 to 0x047F FFFF RDRAM Interface (RI) Registers
static void * Read_8470_847F( u32 address )
static const void * Read_8470_847F( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY_RI, "Reading from MEM_RI_REG: 0x%08x", address );
@ -169,7 +169,7 @@ static void * Read_8470_847F( u32 address )
}
// 0x0480 0000 to 0x048F FFFF Serial Interface (SI) Registers
static void * Read_8480_848F( u32 address )
static const void * Read_8480_848F( u32 address )
{
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY_SI, "Reading from MEM_SI_REG: 0x%08x", address );
@ -177,7 +177,7 @@ static void * Read_8480_848F( u32 address )
return (u8 *)g_pMemoryBuffers[MEM_SI_REG] + (address & 0xFF);
}
static void * ReadFlashRam( u32 address )
static const void * ReadFlashRam( u32 address )
{
if (g_ROM.settings.SaveType == SAVE_TYPE_FLASH)
{
@ -195,7 +195,7 @@ static void * ReadFlashRam( u32 address )
return g_pMemoryBuffers[MEM_UNUSED];
}
static void * ReadROM( u32 address )
static const void * ReadROM( u32 address )
{
void * p_mem = RomBuffer::GetAddressRaw( address & 0x03FFFFFF );
if (p_mem != nullptr)
@ -209,7 +209,7 @@ static void * ReadROM( u32 address )
// 0x1FC0 0000 to 0x1FC0 07BF PIF Boot ROM (Ignored)
// 0x1FC0 07C0 to 0x1FC0 07FF PIF RAM
static void * Read_9FC0_9FCF( u32 address )
static const void * Read_9FC0_9FCF( u32 address )
{
u32 offset = address & 0x0FFF;
u32 pif_ram_offset = address & 0x3F;

2
Source/Core/Memory_ReadInternal.inl
View file

@ -28,6 +28,8 @@ bool Memory_GetInternalReadAddress(u32 address, void ** translated)
static bool InternalReadInvalid( u32 address, void ** translated )
{
DAEDALUS_USE(address);
*translated = g_pMemoryBuffers[MEM_UNUSED];
return false;
}

8
Source/Core/Memory_WriteValue.inl
View file

@ -19,6 +19,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
static void WriteValueInvalid( u32 address, u32 value )
{
DAEDALUS_USE(value);
#ifdef DAEDALUS_DEBUG_CONSOLE
DPF( DEBUG_MEMORY, "Illegal Memory Access Tried to Write To 0x%08x PC: 0x%08x", address, gCPUState.CurrentPC );
DBGConsole_Msg(0, "Illegal Memory Access: Tried to Write To 0x%08x (PC: 0x%08x)", address, gCPUState.CurrentPC);
@ -28,6 +29,7 @@ static void WriteValueInvalid( u32 address, u32 value )
static void WriteValueMapped( u32 address, u32 value )
{
bool missing;
DAEDALUS_USE(value);
#ifdef DAEDALUS_PROFILE_EXECUTION
gTLBWriteHit++;
@ -165,10 +167,12 @@ static void WriteValue_8410_841F( u32 address, u32 value )
// 0x0420 0000 to 0x042F FFFF DP Span Registers
static void WriteValue_8420_842F( u32 address, u32 value )
{
DAEDALUS_USE(address);
DAEDALUS_USE(value);
#ifdef DAEDALUS_DEBUG_CONSOLE
DBGConsole_Msg(0, "Write to DP Span Registers is unhandled (0x%08x, PC: 0x%08x)",
address, gCPUState.CurrentPC);
#endif
#endif
}
@ -441,6 +445,8 @@ static void WriteValue_ROM( u32 address, u32 value )
{
// Write to ROM support
// A Bug's Life and Toy Story 2 write to ROM, add support by storing written value which is used when reading from Rom.
DAEDALUS_USE(address);
DBGConsole_Msg(0, "[YWarning : Wrote to ROM ->] 0x%08x", value);
RomBuffer::SaveRomValue( value );
}

14
Source/Core/PIF.cpp
View file

@ -159,7 +159,7 @@ class IController : public CController
void CommandWriteRumblePack(u32 channel, u8 *cmd);
void CommandReadRTC(u8 *cmd);
const u8 CalculateDataCrc(const u8 * pBuf);
u8 CalculateDataCrc(const u8 * pBuf) const;
bool IsEepromPresent() const { return mpEepromData != nullptr; }
void n64_cic_nus_6105();
@ -554,9 +554,6 @@ bool IController::ProcessController(u8 *cmd, u32 channel)
bool IController::ProcessEeprom(u8 *cmd)
{
#ifdef DAEDALUS_ENABLE_ASSERTS
DAEDALUS_ASSERT( IsEepromPresent(), "ROM is accessing the EEPROM, but none is present");
#endif
switch(cmd[2])
{
case CONT_RESET:
@ -567,10 +564,12 @@ bool IController::ProcessEeprom(u8 *cmd)
break;
case CONT_READ_EEPROM:
DAEDALUS_ASSERT( IsEepromPresent(), "ROM is accessing the EEPROM, but none is present");
CommandReadEeprom( cmd );
break;
case CONT_WRITE_EEPROM:
DAEDALUS_ASSERT( IsEepromPresent(), "ROM is accessing the EEPROM, but none is present");
CommandWriteEeprom( cmd );
break;
@ -587,15 +586,11 @@ bool IController::ProcessEeprom(u8 *cmd)
break;
case CONT_RTC_WRITE: // write RTC block
#ifdef DAEDALUS_DEBUG_CONSOLE
DAEDALUS_ERROR("RTC Write : %02x Not Implemented", cmd[2]);
#endif
break;
default:
#ifdef DAEDALUS_DEBUG_CONSOLE
DAEDALUS_ERROR( "Unknown Eeprom command: %02x", cmd[2] );
#endif
break;
}
@ -614,7 +609,7 @@ void IController::CommandWriteEeprom(u8* cmd)
}
const u8 IController::CalculateDataCrc(const u8 * data)
u8 IController::CalculateDataCrc(const u8 * data) const
{
size_t i;
uint8_t crc = 0;
@ -694,6 +689,7 @@ void IController::CommandReadRumblePack(u8 *cmd)
void IController::CommandWriteRumblePack(u32 channel, u8 *cmd)
{
DAEDALUS_USE(channel);
u16 addr = (cmd[3] << 8) | (cmd[4] & 0xE0);
if ( addr == 0xC000 ) {

702
Source/Core/PrintOpCode.cpp
View file

@ -554,11 +554,11 @@ void SprintOp_Opt( char * str, u32 address, OpCode op ) { strcpy(str, "SRHack
void SprintOp_NoOpt( char * str, u32 address, OpCode op ) { if( op.spec_op == 0 )
{
snprintf(str, sizeof(str),"EXT %s = %s [%d] [%d]", RegNames[op.rt], RegNames[op.rs], op.rd, op.sa);
snprintf(str, 128,"EXT %s = %s [%d] [%d]", RegNames[op.rt], RegNames[op.rs], op.rd, op.sa);
}
else if( op.spec_op == 4 )
{
snprintf(str, sizeof(str),"INS %s = %s [%d] [%d]", RegNames[op.rt], RegNames[op.rs], op.rd, op.sa);
snprintf(str, 128,"INS %s = %s [%d] [%d]", RegNames[op.rt], RegNames[op.rs], op.rd, op.sa);
}
else
{
@ -579,7 +579,7 @@ void SprintOp_J( char * str, u32 address, OpCode op )
#ifdef DAEDALUS_ENABLE_OS_HOOKS
p_name = Patch_GetJumpAddressName(JumpTarget(op, address));
#endif
snprintf(str, sizeof(str),"J 0x%08x %s", JumpTarget(op, address), p_name );
snprintf(str, 128,"J 0x%08x %s", JumpTarget(op, address), p_name );
}
void SprintOp_JAL( char * str, u32 address, OpCode op )
{
@ -587,252 +587,252 @@ void SprintOp_JAL( char * str, u32 address, OpCode op )
#ifdef DAEDALUS_ENABLE_OS_HOOKS
p_name = Patch_GetJumpAddressName(JumpTarget(op, address));
#endif
snprintf(str, sizeof(str),"JAL 0x%08x %s", JumpTarget(op, address), p_name );
snprintf(str, 128,"JAL 0x%08x %s", JumpTarget(op, address), p_name );
}
void SprintOp_BEQ( char * str, u32 address, OpCode op ) {
if (op.rs == 0 && op.rt == 0) snprintf(str, sizeof(str),"B --> 0x%08x", address+4 + (s16)op.immediate*4);
else snprintf(str, sizeof(str),"BEQ %s == %s --> 0x%08x", RegNames[op.rs], RegNames[op.rt], BranchAddress(op, address)); }
void SprintOp_BNE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BNE %s != %s --> 0x%08x", RegNames[op.rs], RegNames[op.rt], BranchAddress(op, address)); }
void SprintOp_BLEZ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BLEZ %s <= 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_BGTZ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BGTZ %s > 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_ADDI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ADDI %s = %s + 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_ADDIU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ADDIU %s = %s + 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_SLTI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SLTI %s = (%s < 0x%04x)", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_SLTIU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SLTIU %s = (%s < 0x%04x)", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_ANDI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ANDI %s = %s & 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_ORI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ORI %s = %s | 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_XORI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"XORI %s = %s ^ 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_LUI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LUI %s = 0x%08x", RegNames[op.rt], op.immediate<<16); }
void SprintOp_BEQL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BEQL %s == %s --> 0x%08x", RegNames[op.rs], RegNames[op.rt], BranchAddress(op, address)); }
void SprintOp_BNEL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BNEL %s != %s --> 0x%08x", RegNames[op.rs], RegNames[op.rt], BranchAddress(op, address)); }
void SprintOp_BLEZL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BLEZL %s <= 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_BGTZL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BGTZL %s > 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_DADDI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DADDI %s = %s + 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_DADDIU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DADDIU %s = %s + 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_LDL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LDL %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LDR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LDR %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LB %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LH( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LH %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LWL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LWL %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LW( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LW %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LBU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LBU %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LHU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LHU %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LWR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LWR %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LWU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LWU %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SB %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SH( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SH %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SWL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SWL %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SW( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SW %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SDL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SDL %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SDR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SDR %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SWR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SWR %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_CACHE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CACHE 0x%02x,0x%04x(%s)", op.rt, op.immediate, RegNames[op.rs]); }
void SprintOp_LL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LL %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LWC1( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LWC1 FP%02d <- 0x%04x(%s)", op.ft, op.immediate, RegNames[op.rs]); }
void SprintOp_LLD( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LLD %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LDC1( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LDC1 FP%02d <- 0x%04x(%s)", op.ft, op.immediate, RegNames[op.rs]); }
void SprintOp_LDC2( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LDC2 GR%02d <- 0x%04x(%s)", op.ft, op.immediate, RegNames[op.rs]); }
void SprintOp_LD( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LD %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SC( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SC %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SWC1( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SWC1 FP%02d -> 0x%04x(%s)", op.ft, op.immediate, RegNames[op.rs]); }
void SprintOp_SCD( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SCD %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SDC1( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SDC1 FP%02d -> 0x%04x(%s)", op.ft, op.immediate, RegNames[op.rs]); }
void SprintOp_SDC2( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SDC2 GR%02d -> 0x%04x(%s)", op.ft, op.immediate, RegNames[op.rs]); }
void SprintOp_SD( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SD %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
if (op.rs == 0 && op.rt == 0) snprintf(str, 128,"B --> 0x%08x", address+4 + (s16)op.immediate*4);
else snprintf(str, 128,"BEQ %s == %s --> 0x%08x", RegNames[op.rs], RegNames[op.rt], BranchAddress(op, address)); }
void SprintOp_BNE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BNE %s != %s --> 0x%08x", RegNames[op.rs], RegNames[op.rt], BranchAddress(op, address)); }
void SprintOp_BLEZ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BLEZ %s <= 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_BGTZ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BGTZ %s > 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_ADDI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ADDI %s = %s + 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_ADDIU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ADDIU %s = %s + 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_SLTI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SLTI %s = (%s < 0x%04x)", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_SLTIU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SLTIU %s = (%s < 0x%04x)", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_ANDI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ANDI %s = %s & 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_ORI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ORI %s = %s | 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_XORI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"XORI %s = %s ^ 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_LUI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LUI %s = 0x%08x", RegNames[op.rt], op.immediate<<16); }
void SprintOp_BEQL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BEQL %s == %s --> 0x%08x", RegNames[op.rs], RegNames[op.rt], BranchAddress(op, address)); }
void SprintOp_BNEL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BNEL %s != %s --> 0x%08x", RegNames[op.rs], RegNames[op.rt], BranchAddress(op, address)); }
void SprintOp_BLEZL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BLEZL %s <= 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_BGTZL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BGTZL %s > 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_DADDI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DADDI %s = %s + 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_DADDIU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DADDIU %s = %s + 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintOp_LDL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LDL %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LDR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LDR %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LB %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LH( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LH %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LWL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LWL %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LW( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LW %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LBU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LBU %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LHU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LHU %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LWR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LWR %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LWU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LWU %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SB %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SH( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SH %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SWL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SWL %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SW( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SW %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SDL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SDL %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SDR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SDR %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SWR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SWR %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_CACHE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CACHE 0x%02x,0x%04x(%s)", op.rt, op.immediate, RegNames[op.rs]); }
void SprintOp_LL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LL %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LWC1( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LWC1 FP%02d <- 0x%04x(%s)", op.ft, op.immediate, RegNames[op.rs]); }
void SprintOp_LLD( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LLD %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_LDC1( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LDC1 FP%02d <- 0x%04x(%s)", op.ft, op.immediate, RegNames[op.rs]); }
void SprintOp_LDC2( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LDC2 GR%02d <- 0x%04x(%s)", op.ft, op.immediate, RegNames[op.rs]); }
void SprintOp_LD( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LD %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SC( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SC %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SWC1( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SWC1 FP%02d -> 0x%04x(%s)", op.ft, op.immediate, RegNames[op.rs]); }
void SprintOp_SCD( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SCD %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_SDC1( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SDC1 FP%02d -> 0x%04x(%s)", op.ft, op.immediate, RegNames[op.rs]); }
void SprintOp_SDC2( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SDC2 GR%02d -> 0x%04x(%s)", op.ft, op.immediate, RegNames[op.rs]); }
void SprintOp_SD( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SD %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintOp_Special_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"Special_Unk?"); }
void SprintOp_Special_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"Special_Unk?"); }
void SprintOp_Special_SLL( char * str, u32 address, OpCode op ) {
if (op._u32 == 0) snprintf(str, sizeof(str),"NOP");
else snprintf(str, sizeof(str),"SLL %s = %s << 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintOp_Special_SRL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SRL %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintOp_Special_SRA( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SRA %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintOp_Special_SLLV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SLLV %s = %s << %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintOp_Special_SRLV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SRLV %s = %s >> %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintOp_Special_SRAV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SRAV %s = %s >> %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintOp_Special_JR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"JR %s", RegNames[op.rs]); }
void SprintOp_Special_JALR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"JALR %s, %s", RegNames[op.rd], RegNames[op.rs]); }
void SprintOp_Special_SYSCALL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SYSCALL"); }
void SprintOp_Special_BREAK( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BREAK 0x%08x", (op._u32>>6)&0xFFFFF); }
void SprintOp_Special_SYNC( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SYNC"); }
void SprintOp_Special_MFHI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MFHI %s", RegNames[op.rd]); }
void SprintOp_Special_MTHI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MTHI %s", RegNames[op.rs]); }
void SprintOp_Special_MFLO( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MFLO %s", RegNames[op.rd]); }
void SprintOp_Special_MTLO( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MTLO %s", RegNames[op.rs]); }
void SprintOp_Special_DSLLV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DSLLV %s = %s << %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintOp_Special_DSRLV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DSRLV %s = %s >> %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintOp_Special_DSRAV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DSRAV %s = %s >> %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintOp_Special_MULT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MULT %s * %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_MULTU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MULTU %s * %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DIV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DIV %s / %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DIVU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DIVU %s / %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DMULT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DMULT %s * %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DMULTU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DMULTU %s * %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DDIV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DDIV %s / %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DDIVU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DDIVU %s / %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_ADD( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ADD %s = %s + %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_ADDU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ADDU %s = %s + %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_SUB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SUB %s = %s - %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_SUBU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SUBU %s = %s - %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_AND( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"AND %s = %s & %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
if (op._u32 == 0) snprintf(str, 128,"NOP");
else snprintf(str, 128,"SLL %s = %s << 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintOp_Special_SRL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SRL %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintOp_Special_SRA( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SRA %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintOp_Special_SLLV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SLLV %s = %s << %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintOp_Special_SRLV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SRLV %s = %s >> %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintOp_Special_SRAV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SRAV %s = %s >> %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintOp_Special_JR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"JR %s", RegNames[op.rs]); }
void SprintOp_Special_JALR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"JALR %s, %s", RegNames[op.rd], RegNames[op.rs]); }
void SprintOp_Special_SYSCALL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SYSCALL"); }
void SprintOp_Special_BREAK( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BREAK 0x%08x", (op._u32>>6)&0xFFFFF); }
void SprintOp_Special_SYNC( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SYNC"); }
void SprintOp_Special_MFHI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MFHI %s", RegNames[op.rd]); }
void SprintOp_Special_MTHI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MTHI %s", RegNames[op.rs]); }
void SprintOp_Special_MFLO( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MFLO %s", RegNames[op.rd]); }
void SprintOp_Special_MTLO( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MTLO %s", RegNames[op.rs]); }
void SprintOp_Special_DSLLV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DSLLV %s = %s << %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintOp_Special_DSRLV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DSRLV %s = %s >> %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintOp_Special_DSRAV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DSRAV %s = %s >> %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintOp_Special_MULT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MULT %s * %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_MULTU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MULTU %s * %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DIV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DIV %s / %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DIVU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DIVU %s / %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DMULT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DMULT %s * %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DMULTU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DMULTU %s * %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DDIV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DDIV %s / %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DDIVU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DDIVU %s / %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_ADD( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ADD %s = %s + %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_ADDU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ADDU %s = %s + %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_SUB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SUB %s = %s - %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_SUBU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SUBU %s = %s - %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_AND( char * str, u32 address, OpCode op ) { snprintf(str, 128,"AND %s = %s & %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_OR( char * str, u32 address, OpCode op ) {
if (op.rs == 0 && op.rt == 0) snprintf(str, sizeof(str),"CLEAR %s = 0", RegNames[op.rd]);
else if (op.rt == 0) snprintf(str, sizeof(str),"MOV %s = %s", RegNames[op.rd], RegNames[op.rs]);
else snprintf(str, sizeof(str),"OR %s = %s | %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_XOR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"XOR %s = %s ^ %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_NOR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"NOR %s = ~(%s | %s)", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_SLT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SLT %s = (%s<%s)", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_SLTU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SLTU %s = (%s<%s)", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DADD( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DADD %s = %s + %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DADDU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DADDU %s = %s + %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DSUB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DSUB %s = %s - %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DSUBU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DSUBU %s = %s - %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DSLL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DSLL %s = %s << 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintOp_Special_DSRL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DSRL %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintOp_Special_DSRA( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DSRA %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintOp_Special_DSLL32( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DSLL32 %s = %s << 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa+32); }
void SprintOp_Special_DSRL32( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DSRL32 %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa+32); }
void SprintOp_Special_DSRA32( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DSRA32 %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa+32); }
if (op.rs == 0 && op.rt == 0) snprintf(str, 128,"CLEAR %s = 0", RegNames[op.rd]);
else if (op.rt == 0) snprintf(str, 128,"MOV %s = %s", RegNames[op.rd], RegNames[op.rs]);
else snprintf(str, 128,"OR %s = %s | %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_XOR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"XOR %s = %s ^ %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_NOR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"NOR %s = ~(%s | %s)", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_SLT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SLT %s = (%s<%s)", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_SLTU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SLTU %s = (%s<%s)", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DADD( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DADD %s = %s + %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DADDU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DADDU %s = %s + %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DSUB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DSUB %s = %s - %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DSUBU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DSUBU %s = %s - %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_DSLL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DSLL %s = %s << 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintOp_Special_DSRL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DSRL %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintOp_Special_DSRA( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DSRA %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintOp_Special_DSLL32( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DSLL32 %s = %s << 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa+32); }
void SprintOp_Special_DSRL32( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DSRL32 %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa+32); }
void SprintOp_Special_DSRA32( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DSRA32 %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa+32); }
void SprintOp_Special_TGE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TGE %s >= %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_TGEU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TGEU %s >= %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_TLT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TLT %s < %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_TLTU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TLTU %s < %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_TEQ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TEQ %s == %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_TNE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TNE %s != %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_TGE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TGE %s >= %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_TGEU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TGEU %s >= %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_TLT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TLT %s < %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_TLTU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TLTU %s < %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_TEQ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TEQ %s == %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_Special_TNE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TNE %s != %s", RegNames[op.rs], RegNames[op.rt]); }
void SprintOp_RegImm_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"RegImm_Unk?"); }
void SprintOp_RegImm_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"RegImm_Unk?"); }
void SprintOp_RegImm_BLTZ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BLTZ %s < 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BGEZ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BGEZ %s >= 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BLTZL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BLTZL %s < 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BGEZL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BGEZL %s >= 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BLTZAL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BLTZAL %s < 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BGEZAL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BGEZAL %s >= 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BLTZALL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BLTZALL %s < 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BGEZALL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BGEZALL %s >= 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BLTZ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BLTZ %s < 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BGEZ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BGEZ %s >= 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BLTZL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BLTZL %s < 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BGEZL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BGEZL %s >= 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BLTZAL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BLTZAL %s < 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BGEZAL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BGEZAL %s >= 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BLTZALL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BLTZALL %s < 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_BGEZALL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BGEZALL %s >= 0 --> 0x%08x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintOp_RegImm_TGEI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TGEI %s >= 0x%04x", RegNames[op.rs], op.immediate); }
void SprintOp_RegImm_TGEIU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TGEIU %s >= 0x%04x", RegNames[op.rs], op.immediate); }
void SprintOp_RegImm_TLTI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TLTI %s < 0x%04x", RegNames[op.rs], op.immediate); }
void SprintOp_RegImm_TLTIU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TLTIU %s < 0x%04x", RegNames[op.rs], op.immediate); }
void SprintOp_RegImm_TEQI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TEQI %s == 0x%04x", RegNames[op.rs], op.immediate); }
void SprintOp_RegImm_TNEI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TNEI %s != 0x%04x", RegNames[op.rs], op.immediate); }
void SprintOp_RegImm_TGEI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TGEI %s >= 0x%04x", RegNames[op.rs], op.immediate); }
void SprintOp_RegImm_TGEIU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TGEIU %s >= 0x%04x", RegNames[op.rs], op.immediate); }
void SprintOp_RegImm_TLTI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TLTI %s < 0x%04x", RegNames[op.rs], op.immediate); }
void SprintOp_RegImm_TLTIU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TLTIU %s < 0x%04x", RegNames[op.rs], op.immediate); }
void SprintOp_RegImm_TEQI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TEQI %s == 0x%04x", RegNames[op.rs], op.immediate); }
void SprintOp_RegImm_TNEI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TNEI %s != 0x%04x", RegNames[op.rs], op.immediate); }
void SprintOp_Cop0_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"Cop0_Unk?"); }
void SprintOp_Cop0_MFC0( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MFC0 %s <- %s", RegNames[op.rt], Cop0RegNames[op.fs]); }
void SprintOp_Cop0_MTC0( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MTC0 %s -> %s", RegNames[op.rt], Cop0RegNames[op.fs]); }
void SprintOp_Cop0_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"Cop0_Unk?"); }
void SprintOp_Cop0_MFC0( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MFC0 %s <- %s", RegNames[op.rt], Cop0RegNames[op.fs]); }
void SprintOp_Cop0_MTC0( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MTC0 %s -> %s", RegNames[op.rt], Cop0RegNames[op.fs]); }
void SprintOp_Cop0_TLB( char * str, u32 address, OpCode op ) { SprintOp_TLBInstructions[op.cop0tlb_funct](str, address, op); }
void SprintOp_TLB_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TLB_Unk?"); }
void SprintOp_TLB_TLBR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TLBR"); }
void SprintOp_TLB_TLBWI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TLBWI"); }
void SprintOp_TLB_TLBWR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TLBWR"); }
void SprintOp_TLB_TLBP( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TLBP"); }
void SprintOp_TLB_ERET( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ERET"); }
void SprintOp_TLB_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TLB_Unk?"); }
void SprintOp_TLB_TLBR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TLBR"); }
void SprintOp_TLB_TLBWI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TLBWI"); }
void SprintOp_TLB_TLBWR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TLBWR"); }
void SprintOp_TLB_TLBP( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TLBP"); }
void SprintOp_TLB_ERET( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ERET"); }
void SprintOp_Cop1_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"Cop1_Unk?"); }
void SprintOp_Cop1_MFC1( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MFC1 %s <- FP%02d", RegNames[op.rt], op.fs); }
void SprintOp_Cop1_DMFC1( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DMFC1 %s <- FP%02d", RegNames[op.rt], op.fs); }
void SprintOp_Cop1_CFC1( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CFC1 %s <- CCR%02d", RegNames[op.rt], op.rd); }
void SprintOp_Cop1_MTC1( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MTC1 %s -> FP%02d", RegNames[op.rt], op.fs); }
void SprintOp_Cop1_DMTC1( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DMTC1 %s -> FP%02d", RegNames[op.rt], op.fs); }
void SprintOp_Cop1_CTC1( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CTC1 %s -> CCR%02d", RegNames[op.rt], op.rd); }
void SprintOp_Cop1_BCInstr( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"%-10.10s%08x", Cop1BC1OpCodeNames[op.cop1_bc], BranchAddress(op, address)); }
void SprintOp_Cop1_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"Cop1_Unk?"); }
void SprintOp_Cop1_MFC1( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MFC1 %s <- FP%02d", RegNames[op.rt], op.fs); }
void SprintOp_Cop1_DMFC1( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DMFC1 %s <- FP%02d", RegNames[op.rt], op.fs); }
void SprintOp_Cop1_CFC1( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CFC1 %s <- CCR%02d", RegNames[op.rt], op.rd); }
void SprintOp_Cop1_MTC1( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MTC1 %s -> FP%02d", RegNames[op.rt], op.fs); }
void SprintOp_Cop1_DMTC1( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DMTC1 %s -> FP%02d", RegNames[op.rt], op.fs); }
void SprintOp_Cop1_CTC1( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CTC1 %s -> CCR%02d", RegNames[op.rt], op.rd); }
void SprintOp_Cop1_BCInstr( char * str, u32 address, OpCode op ) { snprintf(str, 128,"%-10.10s%08x", Cop1BC1OpCodeNames[op.cop1_bc], BranchAddress(op, address)); }
void SprintOp_Cop1_SInstr( char * str, u32 address, OpCode op ) { SprintOp_Cop1SInstruction[op.cop1_funct](str, address, op); }
void SprintOp_Cop1_S_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"Cop1_S_Unk?"); }
void SprintOp_Cop1_S_ADD( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ADD.S FP%02d = FP%02d + FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_S_SUB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SUB.S FP%02d = FP%02d - FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_S_MUL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MUL.S FP%02d = FP%02d * FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_S_DIV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DIV.S FP%02d = FP%02d / FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_S_SQRT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SQRT.S FP%02d = sqrt(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_ABS( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ABS.S FP%02d = fabs(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_MOV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MOV.S FP%02d = FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_S_NEG( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"NEG.S FP%02d = -FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_S_ROUND_L( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"RND.L.S FP%02d = round(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_TRUNC_L( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TRUN.L.S FP%02d = trunc(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_CEIL_L( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CEIL.L.S FP%02d = ceil(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_FLOOR_L( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"FLR.L.S FP%02d = floor(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_ROUND_W( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"RND.W.S FP%02d = round(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_TRUNC_W( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TRUN.W.S FP%02d = trunc(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_CEIL_W( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CEIL.W.S FP%02d = ceil(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_FLOOR_W( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"FLR.W.S FP%02d = floor(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_CVT_D( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CVT.D.S FP%02d = (d)FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_S_CVT_W( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CVT.W.S FP%02d = (w)FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_S_CVT_L( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CVT.L.S FP%02d = (l)FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_S_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"Cop1_S_Unk?"); }
void SprintOp_Cop1_S_ADD( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ADD.S FP%02d = FP%02d + FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_S_SUB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SUB.S FP%02d = FP%02d - FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_S_MUL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MUL.S FP%02d = FP%02d * FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_S_DIV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DIV.S FP%02d = FP%02d / FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_S_SQRT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SQRT.S FP%02d = sqrt(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_ABS( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ABS.S FP%02d = fabs(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_MOV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MOV.S FP%02d = FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_S_NEG( char * str, u32 address, OpCode op ) { snprintf(str, 128,"NEG.S FP%02d = -FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_S_ROUND_L( char * str, u32 address, OpCode op ) { snprintf(str, 128,"RND.L.S FP%02d = round(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_TRUNC_L( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TRUN.L.S FP%02d = trunc(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_CEIL_L( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CEIL.L.S FP%02d = ceil(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_FLOOR_L( char * str, u32 address, OpCode op ) { snprintf(str, 128,"FLR.L.S FP%02d = floor(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_ROUND_W( char * str, u32 address, OpCode op ) { snprintf(str, 128,"RND.W.S FP%02d = round(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_TRUNC_W( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TRUN.W.S FP%02d = trunc(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_CEIL_W( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CEIL.W.S FP%02d = ceil(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_FLOOR_W( char * str, u32 address, OpCode op ) { snprintf(str, 128,"FLR.W.S FP%02d = floor(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_S_CVT_D( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CVT.D.S FP%02d = (d)FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_S_CVT_W( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CVT.W.S FP%02d = (w)FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_S_CVT_L( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CVT.L.S FP%02d = (l)FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_S_F( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.F.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_UN( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.UN.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_EQ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.EQ.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_UEQ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.UEQ.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_OLT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.OLT.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_ULT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.ULT.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_OLE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.OLE.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_ULE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.ULE.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_SF( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.SF.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_NGLE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.NGLE.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_SEQ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.SEQ.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_NGL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.NGL.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_LT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.LT.S FP%02d < FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_NGE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.NGE.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_LE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.LE.S FP%02d <= FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_NGT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.NGT.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_F( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.F.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_UN( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.UN.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_EQ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.EQ.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_UEQ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.UEQ.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_OLT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.OLT.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_ULT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.ULT.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_OLE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.OLE.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_ULE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.ULE.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_SF( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.SF.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_NGLE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.NGLE.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_SEQ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.SEQ.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_NGL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.NGL.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_LT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.LT.S FP%02d < FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_NGE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.NGE.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_LE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.LE.S FP%02d <= FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_S_NGT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.NGT.S FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_DInstr( char * str, u32 address, OpCode op ) { SprintOp_Cop1DInstruction[op.cop1_funct](str, address, op); }
void SprintOp_Cop1_D_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"Cop1_D_Unk?"); }
void SprintOp_Cop1_D_ADD( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ADD.D FP%02d = FP%02d + FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_D_SUB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SUB.D FP%02d = FP%02d - FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_D_MUL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MUL.D FP%02d = FP%02d * FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_D_DIV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"DIV.D FP%02d = FP%02d / FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_D_SQRT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SQRT.D FP%02d = sqrt(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_ABS( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ABS.D FP%02d = fabs(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_MOV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MOV.D FP%02d = FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_D_NEG( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"NEG.D FP%02d = -FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_D_ROUND_L( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"RND.L.D FP%02d = round(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_TRUNC_L( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TRUN.L.D FP%02d = trunc(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_CEIL_L( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CEIL.L.D FP%02d = ceil(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_FLOOR_L( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"FLR.L.D FP%02d = floor(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_ROUND_W( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"RND.W.D FP%02d = round(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_TRUNC_W( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"TRUN.W.D FP%02d = trunc(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_CEIL_W( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CEIL.W.D FP%02d = ceil(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_FLOOR_W( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"FLR.W.D FP%02d = floor(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_CVT_S( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CVT.S.D FP%02d = (s)FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_D_CVT_W( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CVT.W.D FP%02d = (w)FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_D_CVT_L( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"CVT.L.D FP%02d = (l)FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_D_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"Cop1_D_Unk?"); }
void SprintOp_Cop1_D_ADD( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ADD.D FP%02d = FP%02d + FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_D_SUB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SUB.D FP%02d = FP%02d - FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_D_MUL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MUL.D FP%02d = FP%02d * FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_D_DIV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"DIV.D FP%02d = FP%02d / FP%02d", op.fd, op.fs, op.ft); }
void SprintOp_Cop1_D_SQRT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SQRT.D FP%02d = sqrt(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_ABS( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ABS.D FP%02d = fabs(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_MOV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MOV.D FP%02d = FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_D_NEG( char * str, u32 address, OpCode op ) { snprintf(str, 128,"NEG.D FP%02d = -FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_D_ROUND_L( char * str, u32 address, OpCode op ) { snprintf(str, 128,"RND.L.D FP%02d = round(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_TRUNC_L( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TRUN.L.D FP%02d = trunc(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_CEIL_L( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CEIL.L.D FP%02d = ceil(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_FLOOR_L( char * str, u32 address, OpCode op ) { snprintf(str, 128,"FLR.L.D FP%02d = floor(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_ROUND_W( char * str, u32 address, OpCode op ) { snprintf(str, 128,"RND.W.D FP%02d = round(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_TRUNC_W( char * str, u32 address, OpCode op ) { snprintf(str, 128,"TRUN.W.D FP%02d = trunc(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_CEIL_W( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CEIL.W.D FP%02d = ceil(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_FLOOR_W( char * str, u32 address, OpCode op ) { snprintf(str, 128,"FLR.W.D FP%02d = floor(FP%02d)", op.fd, op.fs); }
void SprintOp_Cop1_D_CVT_S( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CVT.S.D FP%02d = (s)FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_D_CVT_W( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CVT.W.D FP%02d = (w)FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_D_CVT_L( char * str, u32 address, OpCode op ) { snprintf(str, 128,"CVT.L.D FP%02d = (l)FP%02d", op.fd, op.fs); }
void SprintOp_Cop1_D_F( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.F.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_UN( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.UN.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_EQ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.EQ.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_UEQ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.UEQ.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_OLT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.OLT.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_ULT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.ULT.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_OLE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.OLE.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_ULE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.ULE.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_SF( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.DF.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_NGLE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.NGLE.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_SEQ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.DEQ.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_NGL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.NGL.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_LT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.LT.D FP%02d < FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_NGE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.NGE.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_LE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.LE.D FP%02d <= FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_NGT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"C.NGT.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_F( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.F.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_UN( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.UN.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_EQ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.EQ.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_UEQ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.UEQ.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_OLT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.OLT.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_ULT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.ULT.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_OLE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.OLE.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_ULE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.ULE.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_SF( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.DF.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_NGLE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.NGLE.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_SEQ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.DEQ.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_NGL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.NGL.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_LT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.LT.D FP%02d < FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_NGE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.NGE.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_LE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.LE.D FP%02d <= FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_D_NGT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"C.NGT.D FP%02d ? FP%02d", op.fs, op.ft); }
void SprintOp_Cop1_WInstr( char * str, u32 address, OpCode op )
{
snprintf(str, sizeof(str),"%-10.10sFP%02d,FP%02d", Cop1WOpCodeNames[op.cop1_funct], op.fd, op.fs);
snprintf(str, 128,"%-10.10sFP%02d,FP%02d", Cop1WOpCodeNames[op.cop1_funct], op.fd, op.fs);
}
void SprintOp_Cop1_LInstr( char * str, u32 address, OpCode op )
{
snprintf(str, sizeof(str),"%-10.10sFP%02d,FP%02d", Cop1LOpCodeNames[op.cop1_funct], op.fd, op.fs);
snprintf(str, 128,"%-10.10sFP%02d,FP%02d", Cop1LOpCodeNames[op.cop1_funct], op.fd, op.fs);
}
@ -923,7 +923,7 @@ SprintOpInstruction SprintRSPOp_VopInstructions[64] = {
void SprintRSPOp_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"?"); }
void SprintRSPOp_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"?"); }
void SprintRSPOp_Special( char * str, u32 address, OpCode op ) { SprintRSPOp_SpecialInstructions[op.spec_op](str, address, op); }
@ -935,70 +935,70 @@ void SprintRSPOp_SWC2( char * str, u32 address, OpCode op ) { SprintRSPOp_SWC2I
void SprintRSPOp_Cop2_VOP( char * str, u32 address, OpCode op ) { SprintRSPOp_VopInstructions[op.cop2_funct](str, address, op); }
void SprintRSPOp_J( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"J 0x%04x %s", RSPJumpTarget(op, address), "?" ); }
void SprintRSPOp_JAL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"JAL 0x%04x %s", RSPJumpTarget(op, address), "?" ); }
void SprintRSPOp_J( char * str, u32 address, OpCode op ) { snprintf(str, 128,"J 0x%04x %s", RSPJumpTarget(op, address), "?" ); }
void SprintRSPOp_JAL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"JAL 0x%04x %s", RSPJumpTarget(op, address), "?" ); }
void SprintRSPOp_BEQ( char * str, u32 address, OpCode op ) {
if (op.rs == 0 && op.rt == 0) snprintf(str, sizeof(str),"B --> 0x%04x", address+4 + (s16)op.immediate*4);
else snprintf(str, sizeof(str),"BEQ %s == %s --> 0x%04x", RegNames[op.rs], RegNames[op.rt], BranchAddress(op, address)); }
void SprintRSPOp_BNE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BNE %s != %s --> 0x%04x", RegNames[op.rs], RegNames[op.rt], BranchAddress(op, address)); }
void SprintRSPOp_BLEZ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BLEZ %s <= 0 --> 0x%04x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintRSPOp_BGTZ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BGTZ %s > 0 --> 0x%04x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintRSPOp_ADDI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ADDI %s = %s + 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_ADDIU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ADDIU %s = %s + 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_SLTI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SLTI %s = (%s < 0x%04x)", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_SLTIU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SLTIU %s = (%s < 0x%04x)", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_ANDI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ANDI %s = %s & 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_ORI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ORI %s = %s | 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_XORI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"XORI %s = %s ^ 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_LUI( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LUI %s = 0x%08x", RegNames[op.rt], op.immediate<<16); }
void SprintRSPOp_LB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LB %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_LH( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LH %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_LW( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LW %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_LBU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LBU %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_LHU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LHU %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_SB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SB %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_SH( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SH %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_SW( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SW %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
if (op.rs == 0 && op.rt == 0) snprintf(str, 128,"B --> 0x%04x", address+4 + (s16)op.immediate*4);
else snprintf(str, 128,"BEQ %s == %s --> 0x%04x", RegNames[op.rs], RegNames[op.rt], BranchAddress(op, address)); }
void SprintRSPOp_BNE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BNE %s != %s --> 0x%04x", RegNames[op.rs], RegNames[op.rt], BranchAddress(op, address)); }
void SprintRSPOp_BLEZ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BLEZ %s <= 0 --> 0x%04x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintRSPOp_BGTZ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BGTZ %s > 0 --> 0x%04x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintRSPOp_ADDI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ADDI %s = %s + 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_ADDIU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ADDIU %s = %s + 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_SLTI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SLTI %s = (%s < 0x%04x)", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_SLTIU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SLTIU %s = (%s < 0x%04x)", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_ANDI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ANDI %s = %s & 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_ORI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ORI %s = %s | 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_XORI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"XORI %s = %s ^ 0x%04x", RegNames[op.rt], RegNames[op.rs], op.immediate); }
void SprintRSPOp_LUI( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LUI %s = 0x%08x", RegNames[op.rt], op.immediate<<16); }
void SprintRSPOp_LB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LB %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_LH( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LH %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_LW( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LW %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_LBU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LBU %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_LHU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LHU %s <- 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_SB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SB %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_SH( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SH %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_SW( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SW %s -> 0x%04x(%s)", RegNames[op.rt], op.immediate, RegNames[op.rs]); }
void SprintRSPOp_Special_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"?"); }
void SprintRSPOp_Special_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"?"); }
void SprintRSPOp_Special_SLL( char * str, u32 address, OpCode op ) {
if (op._u32 == 0) snprintf(str, sizeof(str),"NOP");
else snprintf(str, sizeof(str),"SLL %s = %s << 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintRSPOp_Special_SRL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SRL %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintRSPOp_Special_SRA( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SRA %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintRSPOp_Special_SLLV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SLLV %s = %s << %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintRSPOp_Special_SRLV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SRLV %s = %s >> %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintRSPOp_Special_SRAV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SRAV %s = %s >> %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintRSPOp_Special_JR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"JR %s", RegNames[op.rs]); }
void SprintRSPOp_Special_JALR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"JALR %s, %s", RegNames[op.rd], RegNames[op.rs]); }
void SprintRSPOp_Special_BREAK( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BREAK 0x%08x", (op._u32>>6)&0xFFFFF); }
void SprintRSPOp_Special_ADD( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ADD %s = %s + %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_ADDU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"ADDU %s = %s + %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_SUB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SUB %s = %s - %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_SUBU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SUBU %s = %s - %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_AND( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"AND %s = %s & %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
if (op._u32 == 0) snprintf(str, 128,"NOP");
else snprintf(str, 128,"SLL %s = %s << 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintRSPOp_Special_SRL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SRL %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintRSPOp_Special_SRA( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SRA %s = %s >> 0x%04x", RegNames[op.rd], RegNames[op.rt], op.sa); }
void SprintRSPOp_Special_SLLV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SLLV %s = %s << %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintRSPOp_Special_SRLV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SRLV %s = %s >> %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintRSPOp_Special_SRAV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SRAV %s = %s >> %s", RegNames[op.rd], RegNames[op.rt], RegNames[op.rs]); }
void SprintRSPOp_Special_JR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"JR %s", RegNames[op.rs]); }
void SprintRSPOp_Special_JALR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"JALR %s, %s", RegNames[op.rd], RegNames[op.rs]); }
void SprintRSPOp_Special_BREAK( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BREAK 0x%08x", (op._u32>>6)&0xFFFFF); }
void SprintRSPOp_Special_ADD( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ADD %s = %s + %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_ADDU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"ADDU %s = %s + %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_SUB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SUB %s = %s - %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_SUBU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SUBU %s = %s - %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_AND( char * str, u32 address, OpCode op ) { snprintf(str, 128,"AND %s = %s & %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_OR( char * str, u32 address, OpCode op ) {
if (op.rs == 0 && op.rt == 0) snprintf(str, sizeof(str),"CLEAR %s = 0", RegNames[op.rd]);
else if (op.rt == 0) snprintf(str, sizeof(str),"MOV %s = %s", RegNames[op.rd], RegNames[op.rs]);
else snprintf(str, sizeof(str),"OR %s = %s | %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_XOR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"XOR %s = %s ^ %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_NOR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"NOR %s = ~(%s | %s)", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_SLT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SLT %s = (%s<%s)", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_SLTU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SLTU %s = (%s<%s)", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
if (op.rs == 0 && op.rt == 0) snprintf(str, 128,"CLEAR %s = 0", RegNames[op.rd]);
else if (op.rt == 0) snprintf(str, 128,"MOV %s = %s", RegNames[op.rd], RegNames[op.rs]);
else snprintf(str, 128,"OR %s = %s | %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_XOR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"XOR %s = %s ^ %s", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_NOR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"NOR %s = ~(%s | %s)", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_SLT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SLT %s = (%s<%s)", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_Special_SLTU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SLTU %s = (%s<%s)", RegNames[op.rd], RegNames[op.rs], RegNames[op.rt]); }
void SprintRSPOp_RegImm_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"?"); }
void SprintRSPOp_RegImm_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"?"); }
void SprintRSPOp_RegImm_BLTZ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BLTZ %s < 0 --> 0x%04x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintRSPOp_RegImm_BGEZ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BGEZ %s >= 0 --> 0x%04x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintRSPOp_RegImm_BLTZAL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BLTZAL %s < 0 --> 0x%04x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintRSPOp_RegImm_BGEZAL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"BGEZAL %s >= 0 --> 0x%04x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintRSPOp_RegImm_BLTZ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BLTZ %s < 0 --> 0x%04x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintRSPOp_RegImm_BGEZ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BGEZ %s >= 0 --> 0x%04x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintRSPOp_RegImm_BLTZAL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BLTZAL %s < 0 --> 0x%04x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintRSPOp_RegImm_BGEZAL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"BGEZAL %s >= 0 --> 0x%04x", RegNames[op.rs], BranchAddress(op, address)); }
void SprintRSPOp_Cop0_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"?"); }
void SprintRSPOp_Cop0_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"?"); }
static const char * const g_szRSPControlReg[16] =
{
@ -1023,44 +1023,44 @@ static const char * const g_szRSPControlReg[16] =
void SprintRSPOp_Cop0_MFC0( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MFC0 %s <- [%s]", RegNames[op.rt], g_szRSPControlReg[op.fs&0x0F]); }
void SprintRSPOp_Cop0_MTC0( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MTC0 %s -> [%s]", RegNames[op.rt], g_szRSPControlReg[op.fs&0x0F]); }
void SprintRSPOp_Cop0_MFC0( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MFC0 %s <- [%s]", RegNames[op.rt], g_szRSPControlReg[op.fs&0x0F]); }
void SprintRSPOp_Cop0_MTC0( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MTC0 %s -> [%s]", RegNames[op.rt], g_szRSPControlReg[op.fs&0x0F]); }
void SprintRSPOp_LWC2_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"?"); }
void SprintRSPOp_LWC2_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"?"); }
void SprintRSPOp_LWC2_LBV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LBV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<0, RegNames[op.base]); }
void SprintRSPOp_LWC2_LSV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LSV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<1, RegNames[op.base]); }
void SprintRSPOp_LWC2_LLV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LLV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<2, RegNames[op.base]); }
void SprintRSPOp_LWC2_LDV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LDV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<3, RegNames[op.base]); }
void SprintRSPOp_LWC2_LQV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LQV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_LWC2_LTV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LTV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_LWC2_LRV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LRV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_LWC2_LPV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LPV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<3, RegNames[op.base]); }
void SprintRSPOp_LWC2_LUV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LUV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<3, RegNames[op.base]); }
void SprintRSPOp_LWC2_LHV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LHV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_LWC2_LFV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LFV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_LWC2_LWV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"LWV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_LWC2_LBV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LBV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<0, RegNames[op.base]); }
void SprintRSPOp_LWC2_LSV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LSV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<1, RegNames[op.base]); }
void SprintRSPOp_LWC2_LLV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LLV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<2, RegNames[op.base]); }
void SprintRSPOp_LWC2_LDV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LDV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<3, RegNames[op.base]); }
void SprintRSPOp_LWC2_LQV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LQV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_LWC2_LTV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LTV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_LWC2_LRV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LRV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_LWC2_LPV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LPV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<3, RegNames[op.base]); }
void SprintRSPOp_LWC2_LUV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LUV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<3, RegNames[op.base]); }
void SprintRSPOp_LWC2_LHV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LHV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_LWC2_LFV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LFV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_LWC2_LWV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"LWV vec%02d[%d] <- 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_SWC2_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"?"); }
void SprintRSPOp_SWC2_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"?"); }
void SprintRSPOp_SWC2_SBV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SBV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<0, RegNames[op.base]); }
void SprintRSPOp_SWC2_SSV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SSV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<1, RegNames[op.base]); }
void SprintRSPOp_SWC2_SLV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SLV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<2, RegNames[op.base]); }
void SprintRSPOp_SWC2_SDV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SDV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<3, RegNames[op.base]); }
void SprintRSPOp_SWC2_SQV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SQV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_SWC2_STV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"STV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_SWC2_SRV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SRV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_SWC2_SPV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SPV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<3, RegNames[op.base]); }
void SprintRSPOp_SWC2_SUV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SUV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<3, RegNames[op.base]); }
void SprintRSPOp_SWC2_SHV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SHV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_SWC2_SFV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SFV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_SWC2_SWV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"SWV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_SWC2_SBV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SBV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<0, RegNames[op.base]); }
void SprintRSPOp_SWC2_SSV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SSV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<1, RegNames[op.base]); }
void SprintRSPOp_SWC2_SLV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SLV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<2, RegNames[op.base]); }
void SprintRSPOp_SWC2_SDV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SDV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<3, RegNames[op.base]); }
void SprintRSPOp_SWC2_SQV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SQV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_SWC2_STV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"STV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_SWC2_SRV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SRV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_SWC2_SPV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SPV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<3, RegNames[op.base]); }
void SprintRSPOp_SWC2_SUV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SUV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<3, RegNames[op.base]); }
void SprintRSPOp_SWC2_SHV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SHV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_SWC2_SFV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SFV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_SWC2_SWV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"SWV vec%02d[%d] -> 0x%04x(%s)", op.rt, op.del, op.voffset<<4, RegNames[op.base]); }
void SprintRSPOp_Cop2_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"?"); }
void SprintRSPOp_Cop2_MFC2( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MFC2 %s <- vec%d[%d]", RegNames[op.rt], op.rd, op.sa>>1); }
void SprintRSPOp_Cop2_MTC2( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"MTC2 %s -> vec%d[%d]", RegNames[op.rt], op.rd, op.sa>>1); }
void SprintRSPOp_Cop2_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"?"); }
void SprintRSPOp_Cop2_MFC2( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MFC2 %s <- vec%d[%d]", RegNames[op.rt], op.rd, op.sa>>1); }
void SprintRSPOp_Cop2_MTC2( char * str, u32 address, OpCode op ) { snprintf(str, 128,"MTC2 %s -> vec%d[%d]", RegNames[op.rt], op.rd, op.sa>>1); }
void SprintRSPOp_Vop_Unk( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"?"); }
void SprintRSPOp_Vop_Unk( char * str, u32 address, OpCode op ) { snprintf(str, 128,"?"); }
static const char * gVSelName[16] =
@ -1083,61 +1083,61 @@ static const char * gVSelName[16] =
"7 " // 15
};
void SprintRSPOp_Vop_VMULF( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMULF vec%02d = vec%02d * vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMULU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMULU vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRNDP( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VRNDP vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMULQ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMULQ vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMUDL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMUDL vec%02d = ( acc = vec%02d * vec%02d[%s] )", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMUDM( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMUDM vec%02d = ( acc = vec%02d * vec%02d[%s] >> 16 )", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMUDN( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMUDN vec%02d = ( acc = vec%02d * vec%02d[%s] ) >> 16", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMUDH( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMUDH vec%02d = ( acc = vec%02d * vec%02d[%s] >> 16 ) >> 16", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMULF( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMULF vec%02d = vec%02d * vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMULU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMULU vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRNDP( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VRNDP vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMULQ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMULQ vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMUDL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMUDL vec%02d = ( acc = vec%02d * vec%02d[%s] )", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMUDM( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMUDM vec%02d = ( acc = vec%02d * vec%02d[%s] >> 16 )", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMUDN( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMUDN vec%02d = ( acc = vec%02d * vec%02d[%s] ) >> 16", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMUDH( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMUDH vec%02d = ( acc = vec%02d * vec%02d[%s] >> 16 ) >> 16", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMACF( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMACF vec%02d += vec%02d * vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMACU( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMACU vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRNDN( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VRNDN vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMACQ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMACQ vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMADL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMADL vec%02d = ( acc += vec%02d * vec%02d[%s] )", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMADM( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMADM vec%02d = ( acc += vec%02d * vec%02d[%s] >> 16 )", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMADN( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMADN vec%02d = ( acc += vec%02d * vec%02d[%s] ) >> 16", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMADH( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMADH vec%02d = ( acc += vec%02d * vec%02d[%s] >> 16 ) >> 16", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMACF( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMACF vec%02d += vec%02d * vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMACU( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMACU vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRNDN( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VRNDN vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMACQ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMACQ vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMADL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMADL vec%02d = ( acc += vec%02d * vec%02d[%s] )", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMADM( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMADM vec%02d = ( acc += vec%02d * vec%02d[%s] >> 16 )", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMADN( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMADN vec%02d = ( acc += vec%02d * vec%02d[%s] ) >> 16", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMADH( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMADH vec%02d = ( acc += vec%02d * vec%02d[%s] >> 16 ) >> 16", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VADD( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VADD vec%02d = vec%02d + vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSUB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VSUB vec%02d = vec%02d - vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSUT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VSUT vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VABS( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VABS vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VADDC( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VADDC vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSUBC( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VSUBC vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VADDB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VADDB vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSUBB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VSUBB vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VADD( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VADD vec%02d = vec%02d + vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSUB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VSUB vec%02d = vec%02d - vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSUT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VSUT vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VABS( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VABS vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VADDC( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VADDC vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSUBC( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VSUBC vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VADDB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VADDB vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSUBB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VSUBB vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VACCB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VACCB vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSUCB( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VSUCB vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSAD( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VSAD vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSAC( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VSAC vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSUM( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VSUM vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSAW( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VSAW vec%02d [%d] = vec%02d, vec%02d", op.sa, (op.rs & 0xf), op.rd, op.rt ); }
void SprintRSPOp_Vop_VACCB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VACCB vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSUCB( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VSUCB vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSAD( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VSAD vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSAC( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VSAC vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSUM( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VSUM vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VSAW( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VSAW vec%02d [%d] = vec%02d, vec%02d", op.sa, (op.rs & 0xf), op.rd, op.rt ); }
void SprintRSPOp_Vop_VLT( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VLT vec%02d = vec%02d < vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VEQ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VEQ vec%02d = vec%02d == vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VNE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VNE vec%02d = vec%02d != vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VGE( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VGE vec%02d = vec%02d >= vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VCL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VCL vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VCH( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VCH vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VCR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VCR vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMRG( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMRG vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VAND( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VAND vec%02d = vec%02d & vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VNAND( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VNAND vec%02d = ~(vec%02d & vec%02d[%s])", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VOR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VOR vec%02d = vec%02d | vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VNOR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VNOR vec%02d = ~(vec%02d | vec%02d[%s])", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VXOR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VXOR vec%02d = vec%02d ^ vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VNXOR( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VNXOR vec%02d = ~(vec%02d ^ vec%02d[%s])", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRCP( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VRCP vec%02d [%d], vec%02d[%s]", op.sa, (op.rd & 0x7), op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRCPL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VRCPL vec%02d [%d], vec%02d[%s]", op.sa, (op.rd & 0x7), op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRCPH( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VRCPH vec%02d [%d], vec%02d[%s]", op.sa, (op.rd & 0x7), op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMOV( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VMOV vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRSQ( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VRSQ vec%02d [%d], vec%02d[%s]", op.sa, (op.rd & 0x7), op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRSQL( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VRSQL vec%02d [%d], vec%02d[%s]", op.sa, (op.rd & 0x7), op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRSQH( char * str, u32 address, OpCode op ) { snprintf(str, sizeof(str),"VRSQH vec%02d [%d], vec%02d[%s]", op.sa, (op.rd & 0x7), op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VLT( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VLT vec%02d = vec%02d < vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VEQ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VEQ vec%02d = vec%02d == vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VNE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VNE vec%02d = vec%02d != vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VGE( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VGE vec%02d = vec%02d >= vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VCL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VCL vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VCH( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VCH vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VCR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VCR vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMRG( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMRG vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VAND( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VAND vec%02d = vec%02d & vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VNAND( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VNAND vec%02d = ~(vec%02d & vec%02d[%s])", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VOR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VOR vec%02d = vec%02d | vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VNOR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VNOR vec%02d = ~(vec%02d | vec%02d[%s])", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VXOR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VXOR vec%02d = vec%02d ^ vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VNXOR( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VNXOR vec%02d = ~(vec%02d ^ vec%02d[%s])", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRCP( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VRCP vec%02d [%d], vec%02d[%s]", op.sa, (op.rd & 0x7), op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRCPL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VRCPL vec%02d [%d], vec%02d[%s]", op.sa, (op.rd & 0x7), op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRCPH( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VRCPH vec%02d [%d], vec%02d[%s]", op.sa, (op.rd & 0x7), op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VMOV( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VMOV vec%02d = vec%02d ? vec%02d[%s]", op.sa, op.rd, op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRSQ( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VRSQ vec%02d [%d], vec%02d[%s]", op.sa, (op.rd & 0x7), op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRSQL( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VRSQL vec%02d [%d], vec%02d[%s]", op.sa, (op.rd & 0x7), op.rt, gVSelName[ op.rs & 0xf ]); }
void SprintRSPOp_Vop_VRSQH( char * str, u32 address, OpCode op ) { snprintf(str, 128,"VRSQH vec%02d [%d], vec%02d[%s]", op.sa, (op.rd & 0x7), op.rt, gVSelName[ op.rs & 0xf ]); }

2
Source/Core/ROM.cpp
View file

@ -636,7 +636,7 @@ const char * ROM_GetCountryNameFromID( u8 country_id )
return "?";
}
const u32 ROM_GetTvTypeFromID( u8 country_id )
u32 ROM_GetTvTypeFromID( u8 country_id )
{
for (u32 i = 0; i < g_CountryCodeInfo.size(); i++)
{

2
Source/Core/ROM.h
View file

@ -173,7 +173,7 @@ bool ROM_GetRomDetailsByID( const RomID & id, u32 * rom_size, ECicType * boot_ty
bool ROM_GetRomName( const std::filesystem::path filename, std::string & game_name );
const char * ROM_GetCountryNameFromID( u8 country_id );
const u32 ROM_GetTvTypeFromID( u8 country_id );
u32 ROM_GetTvTypeFromID( u8 country_id );
const char * ROM_GetCicTypeName( ECicType cic_type );
//*****************************************************************************

1
Source/Core/ROMBuffer.cpp
View file

@ -73,6 +73,7 @@ namespace
else
return rom_size < 8 * 1024 * 1024;
#else
DAEDALUS_USE(rom_size);
return true;
#endif
}

4
Source/Core/RSP_HLE.cpp
View file

@ -233,6 +233,7 @@ EProcessResult RSP_HLE_Jpeg(OSTask * task)
EProcessResult RSP_HLE_CICX105(OSTask * task)
{
DAEDALUS_USE(task);
const u32 sum {sum_bytes(g_pu8SpImemBase, 0x1000 >> 1)};
switch(sum)
@ -271,6 +272,9 @@ EProcessResult RSP_HLE_Hvqm(OSTask * task)
return PR_COMPLETED;
}
void RSP_HLE_Reset()
{}
void RSP_HLE_ProcessTask()
{
OSTask * pTask = (OSTask *)(g_pu8SpMemBase + 0x0FC0);

1
Source/Core/RSP_HLE.h
View file

@ -34,6 +34,7 @@ enum EProcessResult
PR_COMPLETED, // Was processed synchronously, completed
};
void RSP_HLE_Reset();
void RSP_HLE_ProcessTask();
#endif // CORE_RSP_HLE_H_

1
Source/Debug/Dump.cpp
View file

@ -74,7 +74,6 @@ void Dump_GetDumpDirectory(char * rootdir, const char * subdir)
//DBGConsole_Msg( 0, "Dump dir: [C%s]", rootdir );
}
#endif
std::filesystem::exists(rootdir);
}

4
Source/DynaRec/Fragment.cpp
View file

@ -931,7 +931,7 @@ void DisassembleBuffer( const u8 * buf, int buf_size, FILE * fh )
void DisassembleBuffer( const u8 * buf, int buf_size, FILE * fh )
{
const int STRBUF_LEN = 1024;
const int STRBUF_LEN = 128;
char strbuf[STRBUF_LEN+1];
const OpCode * p_op( reinterpret_cast< const OpCode * >( buf ) );
@ -1057,7 +1057,7 @@ void CFragment::DumpFragmentInfoHtml( FILE * fh, u64 total_cycles ) const
OpCode op_code( entry.OpCode );
u32 branch_index( entry.BranchIdx );
char buf[100];
char buf[128];
SprintOpCodeInfo( buf, address, op_code );
bool is_jump( address != last_address + 4 );

2
Source/DynaRec/FragmentCache.cpp
View file

@ -394,7 +394,7 @@ void CFragmentCache::DumpStats( const std::filesystem::path outputdir ) const
std::filesystem::path filename = "fragments.html";
std::filesystem::path fragments_dir = "fragments";
std::filesystem::exists(fragments_dir);
// std::filesystem::exists(fragments_dir);
fragments_dir /= filename;
FILE * fh( fopen( filename.c_str(), "w" ) );

6
Source/HLEAudio/ABI3.cpp
View file

@ -32,10 +32,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "HLEAudio/HLEAudioState.h"
// Disables the command because it's not used?
static void DISABLE(AudioHLECommand command) {}
static void WHATISTHIS(AudioHLECommand command) {}
static void DISABLE(AudioHLECommand) {}
static void WHATISTHIS(AudioHLECommand) {}
static void MP3ADDY(AudioHLECommand command) {
static void MP3ADDY(AudioHLECommand) {
// setaddr = (command.cmd1 & 0xffffff);
}

2
Source/HLEAudio/HLEMain.cpp
View file

@ -36,7 +36,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// Audio UCode lists
// Dummy UCode Handler
//
static void SPU(AudioHLECommand command) {}
static void SPU(AudioHLECommand) {}
//
// ABI ? : Unknown or unsupported UCode
//

1
Source/HLEGraphics/BaseRenderer.cpp
View file

@ -175,6 +175,7 @@ BaseRenderer::BaseRenderer()
mTexWrap[i].v = 0;
mActiveTile[i] = 0;
}
memset( &mTnL, 0, sizeof(mTnL) );
mTnL.Flags._u32 = 0;

54
Source/HLEGraphics/uCodes/Ucode_Sprite2D.h
View file

@ -67,38 +67,38 @@ static void DLParser_Sprite2DScaleFlip( MicroCodeCommand command, Sprite2DInfo *
//*****************************************************************************
//
//*****************************************************************************
static void Load_Sprite2D( const Sprite2DStruct *sprite, const Sprite2DInfo info )
{
TextureInfo ti;
ti.SetLoadAddress(RDPSegAddr(sprite->address));
ti.SetFormat(sprite->format);
ti.SetSize(sprite->size);
ti.SetSwapped(false);
ti.SetPalette(0);
ti.SetTlutAddress(RDPSegAddr(sprite->tlut));
ti.SetTLutFormat(kTT_RGBA16);
// static void Load_Sprite2D( const Sprite2DStruct *sprite, const Sprite2DInfo info )
// {
// TextureInfo ti;
// ti.SetLoadAddress(RDPSegAddr(sprite->address));
// ti.SetFormat(sprite->format);
// ti.SetSize(sprite->size);
// ti.SetSwapped(false);
// ti.SetPalette(0);
// ti.SetTlutAddress(RDPSegAddr(sprite->tlut));
// ti.SetTLutFormat(kTT_RGBA16);
u32 width = sprite->stride;
u32 height = sprite->height + sprite->imageY;
u32 pitch = (sprite->stride << sprite->size) >> 1;
// u32 width = sprite->stride;
// u32 height = sprite->height + sprite->imageY;
// u32 pitch = (sprite->stride << sprite->size) >> 1;
if(g_ROM.GameHacks == WCW_NITRO)
{
u32 scaleY = (u32)info.scaleY;
width *= scaleY;
height /= scaleY;
pitch *= scaleY;
}
// if(g_ROM.GameHacks == WCW_NITRO)
// {
// u32 scaleY = (u32)info.scaleY;
// width *= scaleY;
// height /= scaleY;
// pitch *= scaleY;
// }
ti.SetWidth(width);
ti.SetHeight(height);
ti.SetPitch(pitch);
// ti.SetWidth(width);
// ti.SetHeight(height);
// ti.SetPitch(pitch);
DL_PF( " Sprite2D Texture:[Width:%d, Height:%d] -> Address[0x%08x] Format[%s] TLUT[0x%x] Pitch[%d]",
ti.GetWidth(), ti.GetHeight(), ti.GetLoadAddress(), ti.GetFormatName(), ti.GetTlutAddress(), ti.GetPitch());
// DL_PF( " Sprite2D Texture:[Width:%d, Height:%d] -> Address[0x%08x] Format[%s] TLUT[0x%x] Pitch[%d]",
// ti.GetWidth(), ti.GetHeight(), ti.GetLoadAddress(), ti.GetFormatName(), ti.GetTlutAddress(), ti.GetPitch());
gRenderer->LoadTextureDirectly(ti);
}
// gRenderer->LoadTextureDirectly(ti);
// }
//*****************************************************************************
//

15
Source/System/Mutex.h
View file

@ -69,31 +69,20 @@ public:
Mutex()
{
// pthread_mutex_init(&mMutex, NULL);
std::mutex mMutex;
}
explicit Mutex( const char * name )
{
std::mutex mMutex;
// pthread_mutex_init(&mMutex, NULL);
}
~Mutex()
{
// pthread_mutex_destroy(&mMutex);
}
void Lock()
{
// pthread_mutex_lock(&mMutex);
mMutex.lock();
mMutex.lock();
}
void Unlock()
{
// pthread_mutex_unlock(&mMutex);
mMutex.unlock();
mMutex.unlock();
}
public:

10
Source/Utility/Stream.h
View file

@ -38,10 +38,10 @@ class CNullOutputStream : public COutputStream
public:
virtual ~CNullOutputStream() {}
virtual COutputStream & operator<<( const char * p_str ) { return *this; }
virtual COutputStream & operator<<( char val ) { return *this; }
virtual COutputStream & operator<<( s32 val ) { return *this; }
virtual COutputStream & operator<<( u32 val ) { return *this; }
virtual COutputStream & operator<<( const char * ) { return *this; }
virtual COutputStream & operator<<( char ) { return *this; }
virtual COutputStream & operator<<( s32 ) { return *this; }
virtual COutputStream & operator<<( u32 ) { return *this; }
const char * c_str() const { return ""; }
};
@ -64,7 +64,7 @@ private:
class COutputStringStreamImpl * mpImpl;
};
inline COutputStream & operator<<( COutputStream & str, CNullOutputStream & rhs )
inline COutputStream & operator<<( COutputStream & str, CNullOutputStream & )
{
return str;
}