ShuriZma
/
project64
mirror of https://github.com/project64/project64.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

RSP: Get the code to conform to clang-format

This commit is contained in:
zilmar 2023-06-01 21:16:23 +09:30
parent 90fefed579
commit 98b96a60cb
35 changed files with 20444 additions and 17521 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
Source/RSP/Cpu.cpp
View File

@ -1,18 +1,18 @@
#include <windows.h>
#include <stdio.h>
#include <float.h>
#include "Rsp.h"
#include "Cpu.h"
#include "RSP registers.h"
#include "RSP Command.h"
#include "Recompiler CPU.h"
#include "memory.h"
#include "OpCode.h"
#include "log.h"
#include "Profiling.h"
#include "breakpoint.h"
#include "x86.h"
#include "RSP Command.h"
#include "RSP registers.h"
#include "Recompiler CPU.h"
#include "Rsp.h"
#include "Types.h"
#include "breakpoint.h"
#include "log.h"
#include "memory.h"
#include "x86.h"
#include <float.h>
#include <stdio.h>
#include <windows.h>
UDWORD EleSpec[32], Indx[32];
OPCODE RSPOpC;

1
Source/RSP/Cpu.h
View File

@ -1,4 +1,5 @@
#include "OpCode.h"
#include <Windows.h>
extern UDWORD EleSpec[32], Indx[32];

57
Source/RSP/Interpreter CPU.cpp
View File

@ -1,20 +1,21 @@
#include <windows.h>
#include <stdio.h>
#include <float.h>
#include "breakpoint.h"
#include "Rsp.h"
#include "Interpreter CPU.h"
#include "Cpu.h"
#include "Interpreter Ops.h"
#include "Interpreter CPU.h"
#include "RSP registers.h"
#include "RSP Command.h"
#include "RSP registers.h"
#include "Rsp.h"
#include "breakpoint.h"
#include "log.h"
#include "memory.h"
#include "opcode.h"
#include "log.h"
#include <float.h>
#include <stdio.h>
#include <windows.h>
DWORD RSP_NextInstruction, RSP_JumpTo;
void BuildInterpreterCPU(void) {
void BuildInterpreterCPU(void)
{
RSP_Opcode[0] = RSP_Opcode_SPECIAL;
RSP_Opcode[1] = RSP_Opcode_REGIMM;
RSP_Opcode[2] = RSP_Opcode_J;
@ -376,38 +377,51 @@ void BuildInterpreterCPU(void) {
RSP_Sc2[31] = rsp_UnknownOpcode;
}
DWORD RunInterpreterCPU(DWORD Cycles) {
DWORD RunInterpreterCPU(DWORD Cycles)
{
DWORD CycleCount;
RSP_Running = TRUE;
Enable_RSP_Commands_Window();
CycleCount = 0;
while (RSP_Running) {
if (NoOfBpoints != 0) {
if (CheckForRSPBPoint(*PrgCount)) {
if (InRSPCommandsWindow) {
while (RSP_Running)
{
if (NoOfBpoints != 0)
{
if (CheckForRSPBPoint(*PrgCount))
{
if (InRSPCommandsWindow)
{
Enter_RSP_Commands_Window();
if (Stepping_Commands) {
if (Stepping_Commands)
{
DisplayError("Encountered an R4300i breakpoint");
} else {
}
else
{
DisplayError("Encountered an R4300i breakpoint\n\nNow stepping");
SetRSPCommandViewto(*PrgCount);
SetRSPCommandToStepping();
}
} else {
}
else
{
DisplayError("Encountered an RSP breakpoint\n\nEntering command window");
Enter_RSP_Commands_Window();
}
}
}
if (Stepping_Commands) {
if (Stepping_Commands)
{
WaitingForStep = TRUE;
SetRSPCommandViewto(*PrgCount);
UpdateRSPRegistersScreen();
while ( WaitingForStep == TRUE ){
while (WaitingForStep == TRUE)
{
Sleep(20);
if (!Stepping_Commands) {
if (!Stepping_Commands)
{
WaitingForStep = FALSE;
}
}
@ -419,7 +433,8 @@ DWORD RunInterpreterCPU(DWORD Cycles) {
RSP_Opcode[RSPOpC.op]();
RSP_GPR[0].W = 0x00000000; // MIPS $zero hard-wired to 0
switch (RSP_NextInstruction) {
switch (RSP_NextInstruction)
{
case NORMAL:
*PrgCount = (*PrgCount + 4) & 0xFFC;
break;

3
Source/RSP/Interpreter CPU.h
View File

@ -1,3 +1,6 @@
#include <Windows.h>
#include <stdint.h>
#define NORMAL 0
#define DO_DELAY_SLOT 1
#define DELAY_SLOT 2

1415
Source/RSP/Interpreter Ops.cpp
View File

File diff suppressed because it is too large Load Diff

98
Source/RSP/Main.cpp
View File

@ -1,7 +1,7 @@
#ifdef _WIN32
#include <Windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <windowsx.h>
#endif
#if defined(_MSC_VER) && _MSC_VER >= 1910
#include <intrin.h>
@ -10,22 +10,22 @@
#include <stdlib.h>
#include <string.h>
#include "../Settings/Settings.h"
#include <Common/StdString.h>
#include <stdint.h>
#include "../Settings/Settings.h"
#include "Rsp.h"
#include "Cpu.h"
#include "Recompiler CPU.h"
#include "Profiling.h"
#include "RSP Command.h"
#include "RSP Registers.h"
#include "memory.h"
#include "breakpoint.h"
#include "Profiling.h"
#include "log.h"
#include "resource.h"
#include "Version.h"
#include "Recompiler CPU.h"
#include "Rsp.h"
#include "Types.h"
#include "Version.h"
#include "breakpoint.h"
#include "log.h"
#include "memory.h"
#include "resource.h"
void ClearAllx86Code(void);
void ProcessMenuItem(int ID);
@ -52,16 +52,32 @@ void * hinstDLL;
extern uint8_t * pLastSecondary;
enum {
Set_BreakOnStart, Set_CPUCore, Set_LogRDP, Set_LogX86Code, Set_Profiling, Set_IndvidualBlock,
enum
{
Set_BreakOnStart,
Set_CPUCore,
Set_LogRDP,
Set_LogX86Code,
Set_Profiling,
Set_IndvidualBlock,
Set_ShowErrors,
// Compiler settings
Set_CheckDest, Set_Accum, Set_Mmx, Set_Mmx2, Set_Sse, Set_Sections,
Set_ReOrdering, Set_GPRConstants, Set_Flags, Set_AlignVector,
Set_CheckDest,
Set_Accum,
Set_Mmx,
Set_Mmx2,
Set_Sse,
Set_Sections,
Set_ReOrdering,
Set_GPRConstants,
Set_Flags,
Set_AlignVector,
// Game settings
Set_JumpTableSize, Set_Mfc0Count, Set_SemaphoreExit
Set_JumpTableSize,
Set_Mfc0Count,
Set_SemaphoreExit
};
short Set_AudioHle = 0, Set_GraphicsHle = 0;
@ -86,7 +102,10 @@ uint32_t AsciiToHex(char * HexValue)
uint32_t Value = 0;
Finish = strlen(HexValue);
if (Finish > 8 ) { Finish = 8; }
if (Finish > 8)
{
Finish = 8;
}
for (Count = 0; Count < Finish; Count++)
{
@ -273,7 +292,8 @@ void DetectCpuSpecs(void)
DWORD AMD_Features = 0;
#if defined(_MSC_VER)
__try {
__try
{
#ifdef _M_IX86
_asm {
// Intel features
@ -294,7 +314,8 @@ void DetectCpuSpecs(void)
AMD_Features = cpuInfo[3];
#endif
}
__except (EXCEPTION_EXECUTE_HANDLER) {
__except (EXCEPTION_EXECUTE_HANDLER)
{
AMD_Features = Intel_Features = 0;
}
#else
@ -382,14 +403,20 @@ void ProcessMenuItem(int ID)
CheckMenuItem(hRSPMenu, ID_PROFILING_ON, MF_BYCOMMAND | MFS_UNCHECKED);
CheckMenuItem(hRSPMenu, ID_PROFILING_OFF, MF_BYCOMMAND | MFS_CHECKED);
SetSetting(Set_Profiling, FALSE);
if (DebuggingEnabled) { Profiling = FALSE; }
if (DebuggingEnabled)
{
Profiling = FALSE;
}
}
else
{
CheckMenuItem(hRSPMenu, ID_PROFILING_ON, MF_BYCOMMAND | MFS_CHECKED);
CheckMenuItem(hRSPMenu, ID_PROFILING_OFF, MF_BYCOMMAND | MFS_UNCHECKED);
SetSetting(Set_Profiling, TRUE);
if (DebuggingEnabled) { Profiling = TRUE; }
if (DebuggingEnabled)
{
Profiling = TRUE;
}
}
}
break;
@ -403,13 +430,19 @@ void ProcessMenuItem(int ID)
{
CheckMenuItem(hRSPMenu, ID_PROFILING_LOGINDIVIDUALBLOCKS, MF_BYCOMMAND | MFS_UNCHECKED);
SetSetting(Set_IndvidualBlock, FALSE);
if (DebuggingEnabled) { IndvidualBlock = FALSE; }
if (DebuggingEnabled)
{
IndvidualBlock = FALSE;
}
}
else
{
CheckMenuItem(hRSPMenu, ID_PROFILING_LOGINDIVIDUALBLOCKS, MF_BYCOMMAND | MFS_CHECKED);
SetSetting(Set_IndvidualBlock, TRUE);
if (DebuggingEnabled) { IndvidualBlock = TRUE; }
if (DebuggingEnabled)
{
IndvidualBlock = TRUE;
}
}
}
break;
@ -421,13 +454,19 @@ void ProcessMenuItem(int ID)
{
CheckMenuItem(hRSPMenu, ID_SHOWCOMPILERERRORS, MF_BYCOMMAND | MFS_UNCHECKED);
SetSetting(Set_ShowErrors, FALSE);
if (DebuggingEnabled) { ShowErrors = FALSE; }
if (DebuggingEnabled)
{
ShowErrors = FALSE;
}
}
else
{
CheckMenuItem(hRSPMenu, ID_SHOWCOMPILERERRORS, MF_BYCOMMAND | MFS_CHECKED);
SetSetting(Set_ShowErrors, TRUE);
if (DebuggingEnabled) { ShowErrors = TRUE; }
if (DebuggingEnabled)
{
ShowErrors = TRUE;
}
}
}
break;
@ -442,13 +481,19 @@ void ProcessMenuItem(int ID)
{
CheckMenuItem(hRSPMenu, ID_BREAKONSTARTOFTASK, MF_BYCOMMAND | MFS_UNCHECKED);
SetSetting(Set_BreakOnStart, FALSE);
if (DebuggingEnabled) { BreakOnStart = FALSE; }
if (DebuggingEnabled)
{
BreakOnStart = FALSE;
}
}
else
{
CheckMenuItem(hRSPMenu, ID_BREAKONSTARTOFTASK, MF_BYCOMMAND | MFS_CHECKED);
SetSetting(Set_BreakOnStart, TRUE);
if (DebuggingEnabled) { BreakOnStart = TRUE; }
if (DebuggingEnabled)
{
BreakOnStart = TRUE;
}
}
}
break;
@ -768,7 +813,6 @@ EXPORT void PluginLoaded(void)
Compiler.bGPRConstants = TRUE;
DetectCpuSpecs();
SetModuleName("RSP");
Set_GraphicsHle = FindSystemSettingId("HLE GFX");
Set_AudioHle = FindSystemSettingId("HLE Audio");

249
Source/RSP/Mmx.cpp
View File

@ -1,36 +1,44 @@
#include <windows.h>
#include <stdio.h>
#include "Rsp.h"
#include "x86.h"
#include "memory.h"
#include "RSP registers.h"
#include "Rsp.h"
#include "log.h"
#include "memory.h"
#include "x86.h"
#include <stdio.h>
#include <windows.h>
#define PUTDST8(dest,value) (*((BYTE *)(dest))=(BYTE)(value)); dest += 1;
#define PUTDST16(dest,value) (*((WORD *)(dest))=(WORD)(value)); dest += 2;
#define PUTDST32(dest,value) (*((DWORD *)(dest))=(DWORD)(value)); dest += 4;
#define PUTDST8(dest, value) \
(*((BYTE *)(dest)) = (BYTE)(value)); \
dest += 1;
#define PUTDST16(dest, value) \
(*((WORD *)(dest)) = (WORD)(value)); \
dest += 2;
#define PUTDST32(dest, value) \
(*((DWORD *)(dest)) = (DWORD)(value)); \
dest += 4;
#define PUTDSTPTR(dest, value) \
*(void **)(dest) = (void *)(value); dest += sizeof(void *);
*(void **)(dest) = (void *)(value); \
dest += sizeof(void *);
char * mmx_Strings[8] = {
"mm0", "mm1", "mm2", "mm3",
"mm4", "mm5", "mm6", "mm7"
};
"mm4", "mm5", "mm6", "mm7"};
#define mmx_Name(Reg) (mmx_Strings[(Reg)])
void MmxEmptyMultimediaState(void) {
void MmxEmptyMultimediaState(void)
{
CPU_Message(" emms");
PUTDST16(RecompPos, 0x770f);
}
void MmxMoveRegToReg(int Dest, int Source) {
void MmxMoveRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" movq %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0; break;
case x86_MM1: x86Command = 1; break;
case x86_MM2: x86Command = 2; break;
@ -40,7 +48,8 @@ void MmxMoveRegToReg(int Dest, int Source) {
case x86_MM6: x86Command = 6; break;
case x86_MM7: x86Command = 7; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0 << 3; break;
case x86_MM1: x86Command |= 1 << 3; break;
case x86_MM2: x86Command |= 2 << 3; break;
@ -54,12 +63,14 @@ void MmxMoveRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxMoveQwordVariableToReg(int Dest, void *Variable, char *VariableName) {
void MmxMoveQwordVariableToReg(int Dest, void * Variable, char * VariableName)
{
BYTE x86Command = 0;
CPU_Message(" movq %s, qword ptr [%s]", mmx_Name(Dest), VariableName);
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0x05; break;
case x86_MM1: x86Command = 0x0D; break;
case x86_MM2: x86Command = 0x15; break;
@ -75,12 +86,14 @@ void MmxMoveQwordVariableToReg(int Dest, void *Variable, char *VariableName) {
PUTDSTPTR(RecompPos, Variable);
}
void MmxMoveQwordRegToVariable(int Dest, void *Variable, char *VariableName) {
void MmxMoveQwordRegToVariable(int Dest, void * Variable, char * VariableName)
{
BYTE x86Command = 0;
CPU_Message(" movq qword ptr [%s], %s", VariableName, mmx_Name(Dest));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0x05; break;
case x86_MM1: x86Command = 0x0D; break;
case x86_MM2: x86Command = 0x15; break;
@ -96,12 +109,14 @@ void MmxMoveQwordRegToVariable(int Dest, void *Variable, char *VariableName) {
PUTDSTPTR(RecompPos, Variable);
}
void MmxPorRegToReg(int Dest, int Source) {
void MmxPorRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" por %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -111,7 +126,8 @@ void MmxPorRegToReg(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -125,12 +141,14 @@ void MmxPorRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxPorVariableToReg(void * Variable, char * VariableName, int Dest) {
void MmxPorVariableToReg(void * Variable, char * VariableName, int Dest)
{
BYTE x86Command = 0;
CPU_Message(" por %s, qword ptr [%s]", mmx_Name(Dest), VariableName);
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0x05; break;
case x86_MM1: x86Command = 0x0D; break;
case x86_MM2: x86Command = 0x15; break;
@ -146,12 +164,14 @@ void MmxPorVariableToReg(void * Variable, char * VariableName, int Dest) {
PUTDSTPTR(RecompPos, Variable);
}
void MmxPandRegToReg(int Dest, int Source) {
void MmxPandRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" pand %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -161,7 +181,8 @@ void MmxPandRegToReg(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -175,12 +196,14 @@ void MmxPandRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxPandVariableToReg(void * Variable, char * VariableName, int Dest) {
void MmxPandVariableToReg(void * Variable, char * VariableName, int Dest)
{
BYTE x86Command = 0;
CPU_Message(" pand %s, qword ptr [%s]", mmx_Name(Dest), VariableName);
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0x05; break;
case x86_MM1: x86Command = 0x0D; break;
case x86_MM2: x86Command = 0x15; break;
@ -196,12 +219,14 @@ void MmxPandVariableToReg(void * Variable, char * VariableName, int Dest) {
PUTDSTPTR(RecompPos, Variable);
}
void MmxPandnRegToReg(int Dest, int Source) {
void MmxPandnRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" pandn %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -211,7 +236,8 @@ void MmxPandnRegToReg(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -225,12 +251,14 @@ void MmxPandnRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxXorRegToReg(int Dest, int Source) {
void MmxXorRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" pxor %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0x00; break;
case x86_MM1: x86Command = 0x08; break;
case x86_MM2: x86Command = 0x10; break;
@ -240,7 +268,8 @@ void MmxXorRegToReg(int Dest, int Source) {
case x86_MM6: x86Command = 0x30; break;
case x86_MM7: x86Command = 0x38; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command += 0x00; break;
case x86_MM1: x86Command += 0x01; break;
case x86_MM2: x86Command += 0x02; break;
@ -254,12 +283,14 @@ void MmxXorRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxShuffleMemoryToReg(int Dest, void * Variable, char * VariableName, BYTE Immed) {
void MmxShuffleMemoryToReg(int Dest, void * Variable, char * VariableName, BYTE Immed)
{
BYTE x86Command = 0;
CPU_Message(" pshufw %s, [%s], %02X", mmx_Name(Dest), VariableName, Immed);
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0x05; break;
case x86_MM1: x86Command = 0x0D; break;
case x86_MM2: x86Command = 0x15; break;
@ -276,12 +307,14 @@ void MmxShuffleMemoryToReg(int Dest, void * Variable, char * VariableName, BYTE
PUTDST8(RecompPos, Immed);
}
void MmxPcmpeqwRegToReg(int Dest, int Source){
void MmxPcmpeqwRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" pcmpeqw %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -291,7 +324,8 @@ void MmxPcmpeqwRegToReg(int Dest, int Source){
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -305,12 +339,14 @@ void MmxPcmpeqwRegToReg(int Dest, int Source){
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxPmullwRegToReg(int Dest, int Source) {
void MmxPmullwRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" pmullw %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -320,7 +356,8 @@ void MmxPmullwRegToReg(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -334,12 +371,14 @@ void MmxPmullwRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxPmullwVariableToReg(int Dest, void * Variable, char * VariableName) {
void MmxPmullwVariableToReg(int Dest, void * Variable, char * VariableName)
{
BYTE x86Command = 0;
CPU_Message(" pmullw %s, [%s]", mmx_Name(Dest), VariableName);
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0x05; break;
case x86_MM1: x86Command = 0x0D; break;
case x86_MM2: x86Command = 0x15; break;
@ -354,12 +393,14 @@ void MmxPmullwVariableToReg(int Dest, void * Variable, char * VariableName) {
PUTDSTPTR(RecompPos, Variable);
}
void MmxPmulhuwRegToReg(int Dest, int Source) {
void MmxPmulhuwRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" pmulhuw %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -369,7 +410,8 @@ void MmxPmulhuwRegToReg(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -383,12 +425,14 @@ void MmxPmulhuwRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxPmulhwRegToReg(int Dest, int Source) {
void MmxPmulhwRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" pmulhw %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -398,7 +442,8 @@ void MmxPmulhwRegToReg(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -412,12 +457,14 @@ void MmxPmulhwRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxPmulhwRegToVariable(int Dest, void * Variable, char * VariableName) {
void MmxPmulhwRegToVariable(int Dest, void * Variable, char * VariableName)
{
BYTE x86Command = 0;
CPU_Message(" pmulhw %s, [%s]", mmx_Name(Dest), VariableName);
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0x05; break;
case x86_MM1: x86Command = 0x0D; break;
case x86_MM2: x86Command = 0x15; break;
@ -432,13 +479,14 @@ void MmxPmulhwRegToVariable(int Dest, void * Variable, char * VariableName) {
PUTDSTPTR(RecompPos, Variable);
}
void MmxPsrlwImmed(int Dest, BYTE Immed) {
void MmxPsrlwImmed(int Dest, BYTE Immed)
{
BYTE x86Command = 0;
CPU_Message(" psrlw %s, %i", mmx_Name(Dest), Immed);
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0xD0; break;
case x86_MM1: x86Command = 0xD1; break;
case x86_MM2: x86Command = 0xD2; break;
@ -454,12 +502,14 @@ void MmxPsrlwImmed(int Dest, BYTE Immed) {
PUTDST8(RecompPos, Immed);
}
void MmxPsrawImmed(int Dest, BYTE Immed) {
void MmxPsrawImmed(int Dest, BYTE Immed)
{
BYTE x86Command = 0;
CPU_Message(" psraw %s, %i", mmx_Name(Dest), Immed);
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0xE0; break;
case x86_MM1: x86Command = 0xE1; break;
case x86_MM2: x86Command = 0xE2; break;
@ -475,12 +525,14 @@ void MmxPsrawImmed(int Dest, BYTE Immed) {
PUTDST8(RecompPos, Immed);
}
void MmxPsllwImmed(int Dest, BYTE Immed) {
void MmxPsllwImmed(int Dest, BYTE Immed)
{
BYTE x86Command = 0;
CPU_Message(" psllw %s, %i", mmx_Name(Dest), Immed);
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0xF0; break;
case x86_MM1: x86Command = 0xF1; break;
case x86_MM2: x86Command = 0xF2; break;
@ -496,12 +548,14 @@ void MmxPsllwImmed(int Dest, BYTE Immed) {
PUTDST8(RecompPos, Immed);
}
void MmxPaddswRegToReg(int Dest, int Source) {
void MmxPaddswRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" paddsw %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -511,7 +565,8 @@ void MmxPaddswRegToReg(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -525,12 +580,14 @@ void MmxPaddswRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxPsubswRegToReg(int Dest, int Source) {
void MmxPsubswRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" psubsw %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -540,7 +597,8 @@ void MmxPsubswRegToReg(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -554,12 +612,14 @@ void MmxPsubswRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxPaddswVariableToReg(int Dest, void * Variable, char * VariableName) {
void MmxPaddswVariableToReg(int Dest, void * Variable, char * VariableName)
{
BYTE x86Command = 0;
CPU_Message(" paddsw %s, [%s]", mmx_Name(Dest), VariableName);
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0x05; break;
case x86_MM1: x86Command = 0x0D; break;
case x86_MM2: x86Command = 0x15; break;
@ -575,12 +635,14 @@ void MmxPaddswVariableToReg(int Dest, void * Variable, char * VariableName) {
PUTDSTPTR(RecompPos, Variable);
}
void MmxPsubswVariableToReg(int Dest, void * Variable, char * VariableName) {
void MmxPsubswVariableToReg(int Dest, void * Variable, char * VariableName)
{
BYTE x86Command = 0;
CPU_Message(" psubsw %s, [%s]", mmx_Name(Dest), VariableName);
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0x05; break;
case x86_MM1: x86Command = 0x0D; break;
case x86_MM2: x86Command = 0x15; break;
@ -596,12 +658,14 @@ void MmxPsubswVariableToReg(int Dest, void * Variable, char * VariableName) {
PUTDSTPTR(RecompPos, Variable);
}
void MmxPaddwRegToReg(int Dest, int Source) {
void MmxPaddwRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" paddw %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -611,7 +675,8 @@ void MmxPaddwRegToReg(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -625,12 +690,14 @@ void MmxPaddwRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxPackSignedDwords(int Dest, int Source) {
void MmxPackSignedDwords(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" packssdw %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -640,7 +707,8 @@ void MmxPackSignedDwords(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -654,12 +722,14 @@ void MmxPackSignedDwords(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxUnpackLowWord(int Dest, int Source) {
void MmxUnpackLowWord(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" punpcklwd %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -669,7 +739,8 @@ void MmxUnpackLowWord(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -683,12 +754,14 @@ void MmxUnpackLowWord(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxUnpackHighWord(int Dest, int Source) {
void MmxUnpackHighWord(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" punpckhwd %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -698,7 +771,8 @@ void MmxUnpackHighWord(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;
@ -712,12 +786,14 @@ void MmxUnpackHighWord(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void MmxCompareGreaterWordRegToReg(int Dest, int Source) {
void MmxCompareGreaterWordRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" pcmpgtw %s, %s", mmx_Name(Dest), mmx_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_MM0: x86Command = 0 << 3; break;
case x86_MM1: x86Command = 1 << 3; break;
case x86_MM2: x86Command = 2 << 3; break;
@ -727,7 +803,8 @@ void MmxCompareGreaterWordRegToReg(int Dest, int Source) {
case x86_MM6: x86Command = 6 << 3; break;
case x86_MM7: x86Command = 7 << 3; break;
}
switch (Source) {
switch (Source)
{
case x86_MM0: x86Command |= 0; break;
case x86_MM1: x86Command |= 1; break;
case x86_MM2: x86Command |= 2; break;

18
Source/RSP/OpCode.h
View File

@ -4,30 +4,35 @@
#pragma warning(push)
#pragma warning(disable : 4201) // Non-standard extension used: nameless struct/union
typedef union tagOPCODE {
typedef union tagOPCODE
{
uint32_t Hex;
unsigned char Ascii[4];
struct {
struct
{
unsigned immediate : 16;
unsigned rt : 5;
unsigned rs : 5;
unsigned op : 6;
};
struct {
struct
{
unsigned offset : 16;
unsigned : 5;
unsigned base : 5;
unsigned : 6;
};
struct {
struct
{
unsigned target : 26;
unsigned : 6;
};
struct {
struct
{
unsigned funct : 6;
unsigned sa : 5;
unsigned rd : 5;
@ -36,7 +41,8 @@ typedef union tagOPCODE {
unsigned : 6;
};
struct {
struct
{
signed voffset : 7;
unsigned del : 4;
unsigned : 5;

39
Source/RSP/Profiling.cpp
View File

@ -1,11 +1,13 @@
#include <stdio.h>
#include <windows.h>
#include <shellapi.h>
#include "profiling.h"
#pragma warning(disable : 4786)
#include <Common/StdString.h>
#include <Common/File.h>
#include <Common/Log.h>
#include <Common/StdString.h>
#include <map>
#include <vector>
@ -14,7 +16,11 @@ class CProfiling
typedef std::map<DWORD, __int64> PROFILE_ENRTIES;
typedef PROFILE_ENRTIES::iterator PROFILE_ENRTY;
typedef PROFILE_ENRTIES::value_type PROFILE_VALUE;
typedef struct { SPECIAL_TIMERS Timer; char * Name; } TIMER_NAME;
typedef struct
{
SPECIAL_TIMERS Timer;
char * Name;
} TIMER_NAME;
DWORD m_CurrentTimerAddr, CurrentDisplayCount;
DWORD m_StartTimeHi, m_StartTimeLo; // The current timer start time
@ -50,7 +56,10 @@ public:
}
DWORD StopTimer(void)
{
if (m_CurrentTimerAddr == Timer_None) { return m_CurrentTimerAddr; }
if (m_CurrentTimerAddr == Timer_None)
{
return m_CurrentTimerAddr;
}
#if defined(_M_IX86) && defined(_MSC_VER)
DWORD HiValue, LoValue;
@ -142,7 +151,10 @@ public:
char Buffer[255];
float CpuUsage = (float)(((double)ItemList[count]->second / (double)TotalTime) * 100);
if (CpuUsage <= 0.2) { continue; }
if (CpuUsage <= 0.2)
{
continue;
}
sprintf(Buffer, "Function 0x%08X", ItemList[count]->first);
for (int NameID = 0; NameID < (sizeof(TimerNames) / sizeof(TIMER_NAME)); NameID++)
{
@ -161,7 +173,6 @@ public:
}
};
CProfiling & GetProfiler(void)
{
static CProfiling Profile;
@ -189,10 +200,11 @@ void GenerateTimerResults (void)
}
#ifdef todelete
#include <windows.h>
#include <stdio.h>
#include <windows.h>
typedef struct {
typedef struct
{
char Label[100];
__int64 TimeTotal;
} TIME_STAMP_ENTRY;
@ -203,7 +215,10 @@ char LastLabel[100];
void ResetTimerList(void)
{
if (TS_Entries) { free(TS_Entries); }
if (TS_Entries)
{
free(TS_Entries);
}
TS_Entries = NULL;
TSE_Count = 0;
TSE_Max = 0;
@ -230,7 +245,10 @@ void StopTimer (void)
mov StopTimeLo, eax
popad
}
if (strlen(LastLabel) == 0) { return; }
if (strlen(LastLabel) == 0)
{
return;
}
{
DWORD count;
@ -309,8 +327,7 @@ void GenerateTimerResults (void)
{
sprintf(buffer, "%s - %0.2f%c\r\n",
TS_Entries[count].Label,
(((double)TS_Entries[count].TimeTotal / (double)TotalTime) * 100),'%'
);
(((double)TS_Entries[count].TimeTotal / (double)TotalTime) * 100), '%');
WriteFile(hLogFile, buffer, strlen(buffer), &dwWritten, NULL);
}
CloseHandle(hLogFile);

18
Source/RSP/Profiling.h
View File

@ -1,8 +1,16 @@
enum SPECIAL_TIMERS {
Timer_None = 0, Timer_Compiling = -1, Timer_RSP_Running = -2,
Timer_R4300_Running = -3, Timer_RDP_Running = -5, Timer_RefreshScreen = -6,
Timer_UpdateScreen = -7, Timer_UpdateFPS = -9, Timer_Idel = -10,
Timer_FuncLookup = -11,Timer_Done = -13,
enum SPECIAL_TIMERS
{
Timer_None = 0,
Timer_Compiling = -1,
Timer_RSP_Running = -2,
Timer_R4300_Running = -3,
Timer_RDP_Running = -5,
Timer_RefreshScreen = -6,
Timer_UpdateScreen = -7,
Timer_UpdateFPS = -9,
Timer_Idel = -10,
Timer_FuncLookup = -11,
Timer_Done = -13,
};
void ResetTimerList(void);

299
Source/RSP/RSP Command.cpp
View File

@ -1,15 +1,15 @@
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "opcode.h"
#include "Rsp.h"
#include "CPU.h"
#include "RSP Registers.h"
#include "RSP Command.h"
#include "memory.h"
#include "breakpoint.h"
#include "RSP Registers.h"
#include "Rsp.h"
#include "Types.h"
#include "breakpoint.h"
#include "memory.h"
#include "opcode.h"
#define RSP_MaxCommandLines 30
@ -34,7 +34,8 @@ void Paint_RSP_Commands (HWND hDlg);
void RSP_Commands_Setup(HWND hDlg);
LRESULT CALLBACK RSP_Commands_Proc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
typedef struct {
typedef struct
{
DWORD Location;
DWORD opcode;
char String[150];
@ -72,7 +73,8 @@ void Create_RSP_Commands_Window ( int Child )
}
else
{
if (IsIconic((HWND)RSPCommandshWnd)) {
if (IsIconic((HWND)RSPCommandshWnd))
{
SendMessage(RSPCommandshWnd, WM_SYSCOMMAND, SC_RESTORE, 0);
}
SetForegroundWindow(RSPCommandshWnd);
@ -84,7 +86,10 @@ void Disable_RSP_Commands_Window ( void )
{
SCROLLINFO si;
if (!InRSPCommandsWindow) { return; }
if (!InRSPCommandsWindow)
{
return;
}
EnableWindow(hList, FALSE);
EnableWindow(hAddress, FALSE);
EnableWindow(hScrlBar, FALSE);
@ -114,11 +119,26 @@ int DisplayRSPCommand (DWORD location, int InsertPos)
RSP_LW_IMEM(location, &OpCode);
status = 0;
if (location == *PrgCount) {status = RSP_Status_PC; }
if (CheckForRSPBPoint(location)) { status |= RSP_Status_BP; }
if (RSPCommandLine[InsertPos].opcode != OpCode) { Redraw = TRUE; }
if (RSPCommandLine[InsertPos].Location != location) { Redraw = TRUE; }
if (RSPCommandLine[InsertPos].status != status) { Redraw = TRUE; }
if (location == *PrgCount)
{
status = RSP_Status_PC;
}
if (CheckForRSPBPoint(location))
{
status |= RSP_Status_BP;
}
if (RSPCommandLine[InsertPos].opcode != OpCode)
{
Redraw = TRUE;
}
if (RSPCommandLine[InsertPos].Location != location)
{
Redraw = TRUE;
}
if (RSPCommandLine[InsertPos].status != status)
{
Redraw = TRUE;
}
if (Redraw)
{
RSPCommandLine[InsertPos].Location = location;
@ -173,7 +193,8 @@ void DumpRSPCode (void)
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
SetFilePointer(hLogFile, 0, NULL, FILE_BEGIN);
for (location = 0; location < 0x1000; location += 4) {
for (location = 0; location < 0x1000; location += 4)
{
unsigned int characters_to_write;
int characters_converted;
@ -182,10 +203,10 @@ void DumpRSPCode (void)
&string[0],
" 0x%03X\t%s\r\n",
location,
RSPOpcodeName(OpCode, location)
);
RSPOpcodeName(OpCode, location));
if (characters_converted < 0) {
if (characters_converted < 0)
{
DisplayError("Failed to sprintf IMEM from 0x%03X.", location);
break;
}
@ -213,7 +234,8 @@ void DumpRSPData (void)
if (strchr(LogFileName, '\\'))
{
p = LogFileName;
while (strchr(p,'\\')) {
while (strchr(p, '\\'))
{
p = strchr(p, '\\');
p++;
}
@ -237,10 +259,10 @@ void DumpRSPData (void)
&string[0],
" 0x%03X\t0x%08X\r\n",
location,
value
);
value);
if (characters_converted < 0) {
if (characters_converted < 0)
{
DisplayError("Failed to sprintf DMEM from 0x%03X.", location);
break;
}
@ -330,8 +352,7 @@ void DrawRSPCommand ( LPARAM lParam )
ditem->hDC,
&Offset[0], printed_offset,
&TextRect,
DT_SINGLELINE | DT_VCENTER
);
DT_SINGLELINE | DT_VCENTER);
SetRect(&TextRect, ditem->rcItem.left + 83, ditem->rcItem.top, ditem->rcItem.left + 165,
ditem->rcItem.bottom);
@ -339,8 +360,7 @@ void DrawRSPCommand ( LPARAM lParam )
ditem->hDC,
&Instruction[0], printed_instruction,
&TextRect,
DT_SINGLELINE | DT_VCENTER
);
DT_SINGLELINE | DT_VCENTER);
SetRect(&TextRect, ditem->rcItem.left + 165, ditem->rcItem.top, ditem->rcItem.right,
ditem->rcItem.bottom);
@ -348,8 +368,7 @@ void DrawRSPCommand ( LPARAM lParam )
ditem->hDC,
&Arguments[0], printed_arguments,
&TextRect,
DT_SINGLELINE | DT_VCENTER
);
DT_SINGLELINE | DT_VCENTER);
}
else
{
@ -357,11 +376,11 @@ void DrawRSPCommand ( LPARAM lParam )
ditem->hDC,
&Command[0], (signed int)strlen(Command),
&ditem->rcItem,
DT_SINGLELINE | DT_VCENTER
);
DT_SINGLELINE | DT_VCENTER);
}
if (ResetColor == TRUE) {
if (ResetColor == TRUE)
{
SetTextColor(ditem->hDC, oldColor);
}
}
@ -370,7 +389,10 @@ void Enable_RSP_Commands_Window ( void )
{
SCROLLINFO si;
if (!InRSPCommandsWindow) { return; }
if (!InRSPCommandsWindow)
{
return;
}
EnableWindow(hList, TRUE);
EnableWindow(hAddress, TRUE);
EnableWindow(hScrlBar, TRUE);
@ -385,7 +407,8 @@ void Enable_RSP_Commands_Window ( void )
SendMessage(hStepButton, BM_SETSTYLE, BS_DEFPUSHBUTTON, TRUE);
SendMessage(RSPCommandshWnd, DM_SETDEFID, IDC_STEP_BUTTON, 0);
if (Stepping_Commands) {
if (Stepping_Commands)
{
si.cbSize = sizeof(si);
si.fMask = SIF_RANGE | SIF_POS | SIF_PAGE;
si.nMin = 0;
@ -413,32 +436,46 @@ void Paint_RSP_Commands (HWND hDlg)
BeginPaint(hDlg, &ps);
rcBox.left = 5; rcBox.top = 5;
rcBox.right = 343; rcBox.bottom = 463;
rcBox.left = 5;
rcBox.top = 5;
rcBox.right = 343;
rcBox.bottom = 463;
DrawEdge(ps.hdc, &rcBox, EDGE_RAISED, BF_RECT);
rcBox.left = 8; rcBox.top = 8;
rcBox.right = 340; rcBox.bottom = 460;
rcBox.left = 8;
rcBox.top = 8;
rcBox.right = 340;
rcBox.bottom = 460;
DrawEdge(ps.hdc, &rcBox, EDGE_ETCHED, BF_RECT);
rcBox.left = 347; rcBox.top = 7;
rcBox.right = 446; rcBox.bottom = 42;
rcBox.left = 347;
rcBox.top = 7;
rcBox.right = 446;
rcBox.bottom = 42;
DrawEdge(ps.hdc, &rcBox, EDGE_ETCHED, BF_RECT);
rcBox.left = 352; rcBox.top = 2;
rcBox.right = 400; rcBox.bottom = 15;
rcBox.left = 352;
rcBox.top = 2;
rcBox.right = 400;
rcBox.bottom = 15;
FillRect(ps.hdc, &rcBox, (HBRUSH)COLOR_WINDOW);
rcBox.left = 14; rcBox.top = 14;
rcBox.right = 88; rcBox.bottom = 32;
rcBox.left = 14;
rcBox.top = 14;
rcBox.right = 88;
rcBox.bottom = 32;
DrawEdge(ps.hdc, &rcBox, EDGE_ETCHED, BF_RECT);
rcBox.left = 86; rcBox.top = 14;
rcBox.right = 173; rcBox.bottom = 32;
rcBox.left = 86;
rcBox.top = 14;
rcBox.right = 173;
rcBox.bottom = 32;
DrawEdge(ps.hdc, &rcBox, EDGE_ETCHED, BF_RECT);
rcBox.left = 171; rcBox.top = 14;
rcBox.right = 320; rcBox.bottom = 32;
rcBox.left = 171;
rcBox.top = 14;
rcBox.right = 320;
rcBox.bottom = 32;
DrawEdge(ps.hdc, &rcBox, EDGE_ETCHED, BF_RECT);
hOldFont = (HFONT)SelectObject(ps.hdc, GetStockObject(DEFAULT_GUI_FONT));
@ -462,12 +499,18 @@ void RefreshRSPCommands ( void )
char AsciiAddress[20];
int count;
if (InRSPCommandsWindow == FALSE) { return; }
if (InRSPCommandsWindow == FALSE)
{
return;
}
GetWindowTextA(hAddress, AsciiAddress, sizeof(AsciiAddress));
location = AsciiToHex(AsciiAddress) & ~3;
if (location > 0xF88) { location = 0xF88; }
if (location > 0xF88)
{
location = 0xF88;
}
for (count = 0; count < RSP_MaxCommandLines; count += LinesUsed)
{
LinesUsed = DisplayRSPCommand(location, count);
@ -688,8 +731,7 @@ void RSP_Commands_Setup ( HWND hDlg )
char Location[10];
DWORD X, Y, WndPos;
hList = CreateWindowExA(WS_EX_STATICEDGE, "LISTBOX","", WS_CHILD | WS_VISIBLE |
LBS_OWNERDRAWFIXED | LBS_NOTIFY,14,30,303,445, hDlg,
hList = CreateWindowExA(WS_EX_STATICEDGE, "LISTBOX", "", WS_CHILD | WS_VISIBLE | LBS_OWNERDRAWFIXED | LBS_NOTIFY, 14, 30, 303, 445, hDlg,
(HMENU)IDC_LIST, (HINSTANCE)hinstDLL, NULL);
if (hList)
{
@ -698,48 +740,42 @@ void RSP_Commands_Setup ( HWND hDlg )
}
sprintf(Location, "%03X", PrgCount ? *PrgCount : 0);
hAddress = CreateWindowExA(0,"EDIT",Location, WS_CHILD | ES_UPPERCASE | WS_VISIBLE |
WS_BORDER | WS_TABSTOP,375,17,36,18, hDlg,(HMENU)IDC_ADDRESS, (HINSTANCE)hinstDLL, NULL );
hAddress = CreateWindowExA(0, "EDIT", Location, WS_CHILD | ES_UPPERCASE | WS_VISIBLE | WS_BORDER | WS_TABSTOP, 375, 17, 36, 18, hDlg, (HMENU)IDC_ADDRESS, (HINSTANCE)hinstDLL, NULL);
if (hAddress)
{
SendMessage(hAddress, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
SendMessage(hAddress, EM_SETLIMITTEXT, (WPARAM)3, (LPARAM)0);
}
hFunctionlist = CreateWindowExA(0,"COMBOBOX","", WS_CHILD | WS_VSCROLL |
CBS_DROPDOWNLIST | CBS_SORT | WS_TABSTOP,352,56,89,150,hDlg,
hFunctionlist = CreateWindowExA(0, "COMBOBOX", "", WS_CHILD | WS_VSCROLL | CBS_DROPDOWNLIST | CBS_SORT | WS_TABSTOP, 352, 56, 89, 150, hDlg,
(HMENU)IDC_FUNCTION_COMBO, (HINSTANCE)hinstDLL, NULL);
if (hFunctionlist)
{
SendMessage(hFunctionlist, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
hGoButton = CreateWindowExA(WS_EX_STATICEDGE, "BUTTON","&Go", WS_CHILD |
BS_DEFPUSHBUTTON | WS_VISIBLE | WS_TABSTOP, 347,56,100,24, hDlg,(HMENU)IDC_GO_BUTTON,
hGoButton = CreateWindowExA(WS_EX_STATICEDGE, "BUTTON", "&Go", WS_CHILD | BS_DEFPUSHBUTTON | WS_VISIBLE | WS_TABSTOP, 347, 56, 100, 24, hDlg, (HMENU)IDC_GO_BUTTON,
(HINSTANCE)hinstDLL, NULL);
if (hGoButton)
{
SendMessage(hGoButton, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
hBreakButton = CreateWindowExA(WS_EX_STATICEDGE, "BUTTON","&Break", WS_DISABLED |
WS_CHILD | BS_PUSHBUTTON | WS_VISIBLE | WS_TABSTOP | BS_TEXT, 347,85,100,24,hDlg,
hBreakButton = CreateWindowExA(WS_EX_STATICEDGE, "BUTTON", "&Break", WS_DISABLED | WS_CHILD | BS_PUSHBUTTON | WS_VISIBLE | WS_TABSTOP | BS_TEXT, 347, 85, 100, 24, hDlg,
(HMENU)IDC_BREAK_BUTTON, (HINSTANCE)hinstDLL, NULL);
if (hBreakButton)
{
SendMessage(hBreakButton, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
hStepButton = CreateWindowExA(WS_EX_STATICEDGE, "BUTTON","&Step", WS_CHILD |
BS_PUSHBUTTON | WS_VISIBLE | WS_TABSTOP | BS_TEXT, 347,114,100,24,hDlg,
hStepButton = CreateWindowExA(WS_EX_STATICEDGE, "BUTTON", "&Step", WS_CHILD | BS_PUSHBUTTON | WS_VISIBLE | WS_TABSTOP | BS_TEXT, 347, 114, 100, 24, hDlg,
(HMENU)IDC_STEP_BUTTON, (HINSTANCE)hinstDLL, NULL);
if (hStepButton)
{
SendMessage(hStepButton, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
hSkipButton = CreateWindowExA(WS_EX_STATICEDGE, "BUTTON","&Skip", WS_CHILD |
BS_PUSHBUTTON | WS_VISIBLE | WS_TABSTOP | BS_TEXT, 347,143,100,24,hDlg,
hSkipButton = CreateWindowExA(WS_EX_STATICEDGE, "BUTTON", "&Skip", WS_CHILD | BS_PUSHBUTTON | WS_VISIBLE | WS_TABSTOP | BS_TEXT, 347, 143, 100, 24, hDlg,
(HMENU)IDC_SKIP_BUTTON, (HINSTANCE)hinstDLL, NULL);
if (hSkipButton)
{
@ -747,15 +783,26 @@ void RSP_Commands_Setup ( HWND hDlg )
}
WndPos = 324;
if (DebugInfo.Enter_BPoint_Window == NULL) { WndPos += 29;}
if (DebugInfo.Enter_R4300i_Commands_Window == NULL) { WndPos += 29;}
if (DebugInfo.Enter_R4300i_Register_Window == NULL) { WndPos += 29;}
if (DebugInfo.Enter_Memory_Window == NULL) { WndPos += 29;}
if (DebugInfo.Enter_BPoint_Window == NULL)
{
WndPos += 29;
}
if (DebugInfo.Enter_R4300i_Commands_Window == NULL)
{
WndPos += 29;
}
if (DebugInfo.Enter_R4300i_Register_Window == NULL)
{
WndPos += 29;
}
if (DebugInfo.Enter_Memory_Window == NULL)
{
WndPos += 29;
}
if (DebugInfo.Enter_BPoint_Window != NULL)
{
hBPButton = CreateWindowExA(WS_EX_STATICEDGE, "BUTTON","&Break Points", WS_CHILD |
BS_PUSHBUTTON | WS_VISIBLE | WS_TABSTOP | BS_TEXT, 347,WndPos,100,24,hDlg,
hBPButton = CreateWindowExA(WS_EX_STATICEDGE, "BUTTON", "&Break Points", WS_CHILD | BS_PUSHBUTTON | WS_VISIBLE | WS_TABSTOP | BS_TEXT, 347, WndPos, 100, 24, hDlg,
(HMENU)IDC_BP_BUTTON, (HINSTANCE)hinstDLL, NULL);
if (hBPButton)
{
@ -799,8 +846,7 @@ void RSP_Commands_Setup ( HWND hDlg )
WndPos += 29;
if (DebugInfo.Enter_Memory_Window != NULL)
{
hMemory = CreateWindowExA(WS_EX_STATICEDGE,"BUTTON", "&Memory...", WS_CHILD |
BS_PUSHBUTTON | WS_VISIBLE | WS_TABSTOP | BS_TEXT, 347,WndPos,100,24,hDlg,
hMemory = CreateWindowExA(WS_EX_STATICEDGE, "BUTTON", "&Memory...", WS_CHILD | BS_PUSHBUTTON | WS_VISIBLE | WS_TABSTOP | BS_TEXT, 347, WndPos, 100, 24, hDlg,
(HMENU)IDC_MEMORY_BUTTON, (HINSTANCE)hinstDLL, NULL);
if (hMemory)
{
@ -808,8 +854,7 @@ void RSP_Commands_Setup ( HWND hDlg )
}
}
hScrlBar = CreateWindowExA(WS_EX_STATICEDGE, "SCROLLBAR","", WS_CHILD | WS_VISIBLE |
WS_TABSTOP | SBS_VERT, 318,14,18,439, hDlg, (HMENU)IDC_SCRL_BAR, (HINSTANCE)hinstDLL, NULL );
hScrlBar = CreateWindowExA(WS_EX_STATICEDGE, "SCROLLBAR", "", WS_CHILD | WS_VISIBLE | WS_TABSTOP | SBS_VERT, 318, 14, 18, 439, hDlg, (HMENU)IDC_SCRL_BAR, (HINSTANCE)hinstDLL, NULL);
if (RSP_Running)
{
@ -829,6 +874,7 @@ void RSP_Commands_Setup ( HWND hDlg )
SetWindowPos(hDlg, NULL, X, Y, WindowWidth, WindowHeight, SWP_NOZORDER | SWP_SHOWWINDOW);
}
// clang-format off
static const char unused_op[] = "invalid";
static const char* mnemonics_primary[8 << 3] = {
"SPECIAL","REGIMM" ,"J" ,"JAL" ,"BEQ" ,"BNE" ,"BLEZ" ,"BGTZ" ,
@ -890,7 +936,7 @@ static const char* mnemonics_swc2[8 << 2] = {
unused_op,unused_op,unused_op,unused_op,unused_op,unused_op,unused_op,unused_op,
unused_op,unused_op,unused_op,unused_op,unused_op,unused_op,unused_op,unused_op,
};/* 000 | 001 | 010 | 011 | 100 | 101 | 110 | 111 */
// clang-format on
char * RSPSpecialName(DWORD OpCode, DWORD PC)
{
@ -905,8 +951,7 @@ char * RSPSpecialName ( DWORD OpCode, DWORD PC )
command.Ascii[3],
command.Ascii[2],
command.Ascii[1],
command.Ascii[0]
);
command.Ascii[0]);
}
else if (command.Hex == 0x00000000)
{
@ -918,8 +963,7 @@ char * RSPSpecialName ( DWORD OpCode, DWORD PC )
mnemonics_special[command.funct],
GPR_Name(command.rd),
GPR_Name(command.rt),
command.sa
);
command.sa);
}
else if (command.funct >= RSP_SPECIAL_SLLV && command.funct < RSP_SPECIAL_JR)
{
@ -927,23 +971,20 @@ char * RSPSpecialName ( DWORD OpCode, DWORD PC )
mnemonics_special[command.funct],
GPR_Name(command.rd),
GPR_Name(command.rt),
GPR_Name(command.rs)
);
GPR_Name(command.rs));
}
else if (command.funct == RSP_SPECIAL_JR)
{
sprintf(CommandName, "%s\t%s",
mnemonics_special[command.funct],
GPR_Name(command.rs)
);
GPR_Name(command.rs));
}
else if (command.funct == RSP_SPECIAL_JALR)
{
sprintf(CommandName, "%s\t%s, %s",
mnemonics_special[command.funct],
GPR_Name(command.rd),
GPR_Name(command.rs)
);
GPR_Name(command.rs));
}
else if (command.funct == RSP_SPECIAL_BREAK)
{
@ -955,8 +996,7 @@ char * RSPSpecialName ( DWORD OpCode, DWORD PC )
mnemonics_special[command.funct],
GPR_Name(command.rd),
GPR_Name(command.rs),
GPR_Name(command.rt)
);
GPR_Name(command.rt));
}
return CommandName;
}
@ -974,16 +1014,14 @@ char * RSPRegimmName ( DWORD OpCode, DWORD PC )
command.Ascii[3],
command.Ascii[2],
command.Ascii[1],
command.Ascii[0]
);
command.Ascii[0]);
}
else if (command.rt == RSP_REGIMM_BGEZAL && command.rs == 0)
{ // MIPS pseudo-instruction: BAL (branch and link)
sprintf(
CommandName,
"BAL\t0x%04X",
(PC + ((short)command.offset << 2) + 4) & 0x1FFC
);
(PC + ((short)command.offset << 2) + 4) & 0x1FFC);
}
else
{
@ -992,8 +1030,7 @@ char * RSPRegimmName ( DWORD OpCode, DWORD PC )
"%s\t%s, 0x%04X",
mnemonics_regimm[command.rt],
GPR_Name(command.rs),
(PC + ((short)command.offset << 2) + 4) & 0x1FFC
);
(PC + ((short)command.offset << 2) + 4) & 0x1FFC);
}
return CommandName;
}
@ -1013,8 +1050,7 @@ char * RSPCop0Name ( DWORD OpCode, DWORD PC )
command.Ascii[3],
command.Ascii[2],
command.Ascii[1],
command.Ascii[0]
);
command.Ascii[0]);
}
else
{
@ -1023,8 +1059,7 @@ char * RSPCop0Name ( DWORD OpCode, DWORD PC )
"%s\t%s, %s",
mnemonics_cop0[command.rs],
GPR_Name(command.rt),
COP0_Name(command.rd)
);
COP0_Name(command.rd));
}
return CommandName;
}
@ -1044,16 +1079,14 @@ char * RSPCop2Name ( DWORD OpCode, DWORD PC )
command.Ascii[3],
command.Ascii[2],
command.Ascii[1],
command.Ascii[0]
);
command.Ascii[0]);
}
else if (command.rs & 002) // CFC2 or CTC2
{
sprintf(CommandName, "%s\t%s, %d",
mnemonics_cop2[command.rs],
GPR_Name(command.rt),
command.rd % 4
);
command.rd % 4);
}
else
{
@ -1061,8 +1094,7 @@ char * RSPCop2Name ( DWORD OpCode, DWORD PC )
mnemonics_cop2[command.rs],
GPR_Name(command.rt),
command.rd,
command.sa >> 1
);
command.sa >> 1);
}
}
else
@ -1073,8 +1105,7 @@ char * RSPCop2Name ( DWORD OpCode, DWORD PC )
command.Ascii[3],
command.Ascii[2],
command.Ascii[1],
command.Ascii[0]
);
command.Ascii[0]);
}
else if (command.funct >= RSP_VECTOR_VRCP && command.funct < RSP_VECTOR_VNOOP)
{ // RSP division -- VRCP[L,H], VRSQ[L,H], and VMOV
@ -1083,8 +1114,7 @@ char * RSPCop2Name ( DWORD OpCode, DWORD PC )
command.sa,
command.rd & 0x7,
command.rt,
ElementSpecifier(command.rs & 0xF)
);
ElementSpecifier(command.rs & 0xF));
}
else if (command.funct == RSP_VECTOR_VNOOP)
{
@ -1097,8 +1127,7 @@ char * RSPCop2Name ( DWORD OpCode, DWORD PC )
command.sa,
command.rd,
command.rt,
ElementSpecifier(command.rs & 0xF)
);
ElementSpecifier(command.rs & 0xF));
}
}
return CommandName;
@ -1119,8 +1148,7 @@ char * RSPLc2Name ( DWORD OpCode, DWORD PC )
command.Ascii[3],
command.Ascii[2],
command.Ascii[1],
command.Ascii[0]
);
command.Ascii[0]);
}
else
{
@ -1132,8 +1160,7 @@ char * RSPLc2Name ( DWORD OpCode, DWORD PC )
command.del,
(command.voffset < 0) ? '-' : '+',
abs(command.voffset),
GPR_Name(command.base)
);
GPR_Name(command.base));
}
return CommandName;
}
@ -1153,8 +1180,7 @@ char * RSPSc2Name ( DWORD OpCode, DWORD PC )
command.Ascii[3],
command.Ascii[2],
command.Ascii[1],
command.Ascii[0]
);
command.Ascii[0]);
}
else
{
@ -1166,8 +1192,7 @@ char * RSPSc2Name ( DWORD OpCode, DWORD PC )
command.del,
(command.voffset < 0) ? '-' : '+',
abs(command.voffset),
GPR_Name(command.base)
);
GPR_Name(command.base));
}
return CommandName;
}
@ -1189,16 +1214,14 @@ char * RSPOpcodeName ( DWORD OpCode, DWORD PC )
case RSP_JAL:
sprintf(CommandName, "%s\t0x%04X",
mnemonics_primary[command.op],
(command.target << 2) & 0x1FFC
);
(command.target << 2) & 0x1FFC);
break;
case RSP_BEQ:
if (command.rs == 0 && command.rt == 0)
{
sprintf(CommandName, "%s\t0x%04X",
"B",
(PC + ((short)command.offset << 2) + 4) & 0x1FFC
);
(PC + ((short)command.offset << 2) + 4) & 0x1FFC);
break;
}
else if (command.rs == 0 || command.rt == 0)
@ -1206,8 +1229,7 @@ char * RSPOpcodeName ( DWORD OpCode, DWORD PC )
sprintf(CommandName, "%s\t%s, 0x%04X",
"BEQZ",
GPR_Name(command.rs == 0 ? command.rt : command.rs),
(PC + ((short)command.offset << 2) + 4) & 0x1FFC
);
(PC + ((short)command.offset << 2) + 4) & 0x1FFC);
break;
}
// TODO: add example code?
@ -1217,16 +1239,14 @@ char * RSPOpcodeName ( DWORD OpCode, DWORD PC )
mnemonics_primary[command.op],
GPR_Name(command.rs),
GPR_Name(command.rt),
(PC + ((short)command.offset << 2) + 4) & 0x1FFC
);
(PC + ((short)command.offset << 2) + 4) & 0x1FFC);
break;
case RSP_BLEZ:
case RSP_BGTZ:
sprintf(CommandName, "%s\t%s, 0x%04X",
mnemonics_primary[command.op],
GPR_Name(command.rs),
(PC + ((short)command.offset << 2) + 4) & 0x1FFC
);
(PC + ((short)command.offset << 2) + 4) & 0x1FFC);
break;
case RSP_ADDI:
case RSP_ADDIU:
@ -1239,15 +1259,13 @@ char * RSPOpcodeName ( DWORD OpCode, DWORD PC )
mnemonics_primary[command.op],
GPR_Name(command.rt),
GPR_Name(command.rs),
command.immediate
);
command.immediate);
break;
case RSP_LUI:
sprintf(CommandName, "%s\t%s, 0x%04X",
mnemonics_primary[RSP_LUI],
GPR_Name(command.rt),
command.immediate
);
command.immediate);
break;
case RSP_CP0:
return RSPCop0Name(OpCode, PC);
@ -1268,8 +1286,7 @@ char * RSPOpcodeName ( DWORD OpCode, DWORD PC )
GPR_Name(command.rt),
((int16_t)command.offset < 0) ? '-' : '+',
abs((int16_t)command.offset),
GPR_Name(command.base)
);
GPR_Name(command.base));
break;
case RSP_LC2:
return RSPLc2Name(OpCode, PC);
@ -1282,8 +1299,7 @@ char * RSPOpcodeName ( DWORD OpCode, DWORD PC )
command.Ascii[3],
command.Ascii[2],
command.Ascii[1],
command.Ascii[0]
);
command.Ascii[0]);
}
return CommandName;
}
@ -1291,7 +1307,10 @@ char * RSPOpcodeName ( DWORD OpCode, DWORD PC )
void SetRSPCommandToRunning(void)
{
Stepping_Commands = FALSE;
if (InRSPCommandsWindow == FALSE) { return; }
if (InRSPCommandsWindow == FALSE)
{
return;
}
EnableWindow(hGoButton, FALSE);
EnableWindow(hBreakButton, TRUE);
EnableWindow(hStepButton, FALSE);
@ -1304,7 +1323,10 @@ void SetRSPCommandToRunning ( void )
void SetRSPCommandToStepping(void)
{
if (InRSPCommandsWindow == FALSE) { return; }
if (InRSPCommandsWindow == FALSE)
{
return;
}
EnableWindow(hGoButton, TRUE);
EnableWindow(hBreakButton, FALSE);
EnableWindow(hStepButton, TRUE);
@ -1321,7 +1343,10 @@ void SetRSPCommandViewto ( UINT NewLocation )
unsigned int location;
char Value[20];
if (InRSPCommandsWindow == FALSE) { return; }
if (InRSPCommandsWindow == FALSE)
{
return;
}
GetWindowTextA(hAddress, Value, sizeof(Value));
location = AsciiToHex(Value) & ~3;

275
Source/RSP/RSP Register.cpp
View File

@ -1,8 +1,9 @@
#include <windows.h>
#include <commctrl.h>
#include <stdio.h>
#include "Rsp.h"
#include "Types.h"
#include <commctrl.h>
#include <stdio.h>
#define GeneralPurpose 1
#define ControlProcessor0 2
@ -45,21 +46,28 @@ char * GPR_Strings[32] = {
"R0", "AT", "V0", "V1", "A0", "A1", "A2", "A3",
"T0", "T1", "T2", "T3", "T4", "T5", "T6", "T7",
"S0", "S1", "S2", "S3", "S4", "S5", "S6", "S7",
"T8", "T9", "K0", "K1", "GP", "SP", "S8", "RA"
};
"T8", "T9", "K0", "K1", "GP", "SP", "S8", "RA"};
void Create_RSP_Register_Window ( int Child ) {
void Create_RSP_Register_Window(int Child)
{
DWORD ThreadID;
if ( Child ) {
if (Child)
{
InRSPRegisterWindow = TRUE;
DialogBoxA((HINSTANCE)hinstDLL, "RSPREGISTERS", NULL, (DLGPROC)RSP_Registers_Proc);
InRSPRegisterWindow = FALSE;
} else {
if (!InRSPRegisterWindow) {
}
else
{
if (!InRSPRegisterWindow)
{
CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Create_RSP_Register_Window,
(LPVOID)TRUE, 0, &ThreadID);
} else {
if (IsIconic((HWND)RSP_Registers_hDlg)) {
}
else
{
if (IsIconic((HWND)RSP_Registers_hDlg))
{
SendMessage(RSP_Registers_hDlg, WM_SYSCOMMAND, SC_RESTORE, 0);
}
SetForegroundWindow(RSP_Registers_hDlg);
@ -67,58 +75,86 @@ void Create_RSP_Register_Window ( int Child ) {
}
}
void Enter_RSP_Register_Window ( void ) {
void Enter_RSP_Register_Window(void)
{
Create_RSP_Register_Window(FALSE);
}
void HideRSP_RegisterPanel ( int Panel) {
void HideRSP_RegisterPanel(int Panel)
{
int count;
switch( Panel ) {
switch (Panel)
{
case GeneralPurpose:
for (count = 0; count < 32;count ++) { ShowWindow(hGPR[count], FALSE ); }
for (count = 0; count < 32; count++)
{
ShowWindow(hGPR[count], FALSE);
}
break;
case ControlProcessor0:
for (count = 0; count < 16;count ++) { ShowWindow(hCP0[count], FALSE ); }
for (count = 0; count < 16; count++)
{
ShowWindow(hCP0[count], FALSE);
}
break;
case HiddenRegisters:
for (count = 0; count < 12;count ++) { ShowWindow(hHIDDEN[count], FALSE ); }
for (count = 0; count < 12; count++)
{
ShowWindow(hHIDDEN[count], FALSE);
}
break;
case Vector1:
for (count = 0; count < 16;count ++) { ShowWindow(hVECT1[count], FALSE ); }
for (count = 0; count < 16; count++)
{
ShowWindow(hVECT1[count], FALSE);
}
break;
case Vector2:
for (count = 0; count < 16;count ++) { ShowWindow(hVECT2[count], FALSE ); }
for (count = 0; count < 16; count++)
{
ShowWindow(hVECT2[count], FALSE);
}
break;
}
}
void InitilizeRSPRegisters (void) {
void InitilizeRSPRegisters(void)
{
memset(RSP_GPR, 0, sizeof(RSP_GPR));
memset(RSP_Vect, 0, sizeof(RSP_Vect));
}
void PaintRSP_HiddenPanel (HWND hWnd) {
void PaintRSP_HiddenPanel(HWND hWnd)
{
PAINTSTRUCT ps;
RECT rcBox;
HFONT hOldFont;
int OldBkMode;
BeginPaint(hWnd, &ps);
rcBox.left = 66; rcBox.top = 39;
rcBox.right = 320; rcBox.bottom = 265;
rcBox.left = 66;
rcBox.top = 39;
rcBox.right = 320;
rcBox.bottom = 265;
DrawEdge(ps.hdc, &rcBox, EDGE_ETCHED, BF_RECT);
rcBox.left = 350; rcBox.top = 39;
rcBox.right = 510; rcBox.bottom = 265;
rcBox.left = 350;
rcBox.top = 39;
rcBox.right = 510;
rcBox.bottom = 265;
DrawEdge(ps.hdc, &rcBox, EDGE_ETCHED, BF_RECT);
rcBox.left = 75; rcBox.top = 35;
rcBox.right = 150; rcBox.bottom = 50;
rcBox.left = 75;
rcBox.top = 35;
rcBox.right = 150;
rcBox.bottom = 50;
FillRect(ps.hdc, &rcBox, (HBRUSH)COLOR_WINDOW);
rcBox.left = 365; rcBox.top = 35;
rcBox.right = 425; rcBox.bottom = 50;
rcBox.left = 365;
rcBox.top = 35;
rcBox.right = 425;
rcBox.bottom = 50;
FillRect(ps.hdc, &rcBox, (HBRUSH)COLOR_WINDOW);
hOldFont = (HFONT)SelectObject(ps.hdc,
@ -146,7 +182,8 @@ void PaintRSP_HiddenPanel (HWND hWnd) {
EndPaint(hWnd, &ps);
}
void PaintRSP_CP0Panel (HWND hWnd) {
void PaintRSP_CP0Panel(HWND hWnd)
{
PAINTSTRUCT ps;
RECT rcBox;
HFONT hOldFont;
@ -185,7 +222,8 @@ void PaintRSP_CP0Panel (HWND hWnd) {
EndPaint(hWnd, &ps);
}
void PaintRSP_GPRPanel (HWND hWnd) {
void PaintRSP_GPRPanel(HWND hWnd)
{
PAINTSTRUCT ps;
RECT rcBox;
HFONT hOldFont;
@ -240,7 +278,8 @@ void PaintRSP_GPRPanel (HWND hWnd) {
EndPaint(hWnd, &ps);
}
void PaintRSP_Vector1_Panel (HWND hWnd) {
void PaintRSP_Vector1_Panel(HWND hWnd)
{
PAINTSTRUCT ps;
RECT rcBox;
HFONT hOldFont;
@ -279,7 +318,8 @@ void PaintRSP_Vector1_Panel (HWND hWnd) {
EndPaint(hWnd, &ps);
}
void PaintRSP_Vector2_Panel (HWND hWnd) {
void PaintRSP_Vector2_Panel(HWND hWnd)
{
PAINTSTRUCT ps;
RECT rcBox;
HFONT hOldFont;
@ -318,17 +358,21 @@ void PaintRSP_Vector2_Panel (HWND hWnd) {
EndPaint(hWnd, &ps);
}
LRESULT CALLBACK RefreshRSP_RegProc ( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) {
LRESULT CALLBACK RefreshRSP_RegProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
int nSel;
TC_ITEM item;
switch( uMsg ) {
switch (uMsg)
{
case WM_PAINT:
nSel = TabCtrl_GetCurSel(hTab);
if ( nSel > -1 ) {
if (nSel > -1)
{
item.mask = TCIF_PARAM;
TabCtrl_GetItem(hTab, nSel, &item);
switch( item.lParam ) {
switch (item.lParam)
{
case GeneralPurpose:
PaintRSP_GPRPanel(hWnd);
break;
@ -352,12 +396,14 @@ LRESULT CALLBACK RefreshRSP_RegProc ( HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
return CallWindowProc(RefreshProc, hWnd, uMsg, wParam, lParam);
}
LRESULT CALLBACK RSP_Registers_Proc (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
LRESULT CALLBACK RSP_Registers_Proc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static RECT rcDisp;
static int CurrentPanel = GeneralPurpose;
TC_ITEM item;
switch (uMsg) {
switch (uMsg)
{
case WM_INITDIALOG:
RSP_Registers_hDlg = hDlg;
SetupRSP_RegistersMain(hDlg);
@ -370,7 +416,8 @@ LRESULT CALLBACK RSP_Registers_Proc (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM
TabCtrl_AdjustRect(hTab, FALSE, &rcDisp);
break;
case WM_NOTIFY:
switch (((NMHDR *)lParam)->code) {
switch (((NMHDR *)lParam)->code)
{
case TCN_SELCHANGE:
InvalidateRect(hTab, &rcDisp, TRUE);
HideRSP_RegisterPanel(CurrentPanel);
@ -384,7 +431,8 @@ LRESULT CALLBACK RSP_Registers_Proc (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM
}
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
switch (LOWORD(wParam))
{
case IDCANCEL:
CurrentPanel = GeneralPurpose;
EndDialog(hDlg, IDCANCEL);
@ -396,71 +444,76 @@ LRESULT CALLBACK RSP_Registers_Proc (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM
return TRUE;
}
void SetupRSP_HiddenPanel (HWND hDlg) {
void SetupRSP_HiddenPanel(HWND hDlg)
{
int count;
for (count = 0; count < 8;count ++) {
hHIDDEN[count] = CreateWindowExA(WS_EX_CLIENTEDGE,"EDIT","", WS_CHILD |
ES_READONLY | WS_BORDER | WS_TABSTOP,170,(count*25) + 60,140,19,
for (count = 0; count < 8; count++)
{
hHIDDEN[count] = CreateWindowExA(WS_EX_CLIENTEDGE, "EDIT", "", WS_CHILD | ES_READONLY | WS_BORDER | WS_TABSTOP, 170, (count * 25) + 60, 140, 19,
hDlg, 0, (HINSTANCE)hinstDLL, NULL);
SendMessage(hHIDDEN[count], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
for (count = 0; count < 4;count ++) {
hHIDDEN[count + 8] = CreateWindowExA(WS_EX_CLIENTEDGE,"EDIT","", WS_CHILD |
ES_READONLY | WS_BORDER | WS_TABSTOP,425,(count*30) + 90,55,19,
for (count = 0; count < 4; count++)
{
hHIDDEN[count + 8] = CreateWindowExA(WS_EX_CLIENTEDGE, "EDIT", "", WS_CHILD | ES_READONLY | WS_BORDER | WS_TABSTOP, 425, (count * 30) + 90, 55, 19,
hDlg, 0, (HINSTANCE)hinstDLL, NULL);
SendMessage(hHIDDEN[count + 8], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
}
void SetupRSP_CP0Panel (HWND hDlg) {
void SetupRSP_CP0Panel(HWND hDlg)
{
int count;
for (count = 0; count < 8;count ++) {
hCP0[count] = CreateWindowExA(WS_EX_CLIENTEDGE,"EDIT","", WS_CHILD |
ES_READONLY | WS_BORDER | WS_TABSTOP,225,(count*28) + 53,75,19,
for (count = 0; count < 8; count++)
{
hCP0[count] = CreateWindowExA(WS_EX_CLIENTEDGE, "EDIT", "", WS_CHILD | ES_READONLY | WS_BORDER | WS_TABSTOP, 225, (count * 28) + 53, 75, 19,
hDlg, 0, (HINSTANCE)hinstDLL, NULL);
SendMessage(hCP0[count], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
for (count = 0; count < 8;count ++) {
hCP0[count + 8] = CreateWindowExA(WS_EX_CLIENTEDGE,"EDIT","", WS_CHILD |
ES_READONLY | WS_BORDER | WS_TABSTOP,485,(count*28) + 53,75,19,
for (count = 0; count < 8; count++)
{
hCP0[count + 8] = CreateWindowExA(WS_EX_CLIENTEDGE, "EDIT", "", WS_CHILD | ES_READONLY | WS_BORDER | WS_TABSTOP, 485, (count * 28) + 53, 75, 19,
hDlg, 0, (HINSTANCE)hinstDLL, NULL);
SendMessage(hCP0[count + 8], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
}
void SetupRSP_GPRPanel (HWND hDlg) {
void SetupRSP_GPRPanel(HWND hDlg)
{
int count;
for (count = 0; count < 11;count ++) {
hGPR[count] = CreateWindowExA(WS_EX_CLIENTEDGE,"EDIT","", WS_CHILD |
ES_READONLY | WS_BORDER | WS_TABSTOP,135,(count*20) + 50,75,19,
for (count = 0; count < 11; count++)
{
hGPR[count] = CreateWindowExA(WS_EX_CLIENTEDGE, "EDIT", "", WS_CHILD | ES_READONLY | WS_BORDER | WS_TABSTOP, 135, (count * 20) + 50, 75, 19,
hDlg, 0, (HINSTANCE)hinstDLL, NULL);
SendMessage(hGPR[count], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
for (count = 0; count < 11;count ++) {
hGPR[count + 11] = CreateWindowExA(WS_EX_CLIENTEDGE,"EDIT","", WS_CHILD |
ES_READONLY | WS_BORDER | WS_TABSTOP,315,(count*20) + 50,75,19,
for (count = 0; count < 11; count++)
{
hGPR[count + 11] = CreateWindowExA(WS_EX_CLIENTEDGE, "EDIT", "", WS_CHILD | ES_READONLY | WS_BORDER | WS_TABSTOP, 315, (count * 20) + 50, 75, 19,
hDlg, 0, (HINSTANCE)hinstDLL, NULL);
SendMessage(hGPR[count + 11], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
for (count = 0; count < 10;count ++) {
hGPR[count + 22] = CreateWindowExA(WS_EX_CLIENTEDGE,"EDIT","", WS_CHILD |
ES_READONLY | WS_BORDER | WS_TABSTOP,485,(count*20) + 50,75,19,
for (count = 0; count < 10; count++)
{
hGPR[count + 22] = CreateWindowExA(WS_EX_CLIENTEDGE, "EDIT", "", WS_CHILD | ES_READONLY | WS_BORDER | WS_TABSTOP, 485, (count * 20) + 50, 75, 19,
hDlg, 0, (HINSTANCE)hinstDLL, NULL);
SendMessage(hGPR[count + 22], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
}
void SetupRSP_RegistersMain (HWND hDlg) {
void SetupRSP_RegistersMain(HWND hDlg)
{
#define WindowWidth 630
#define WindowHeight 325
DWORD X, Y;
hTab = CreateWindowExA(0, WC_TABCONTROLA, "", WS_TABSTOP | WS_CHILD | WS_VISIBLE, 5, 6, 616, 290,
hDlg, (HMENU)IDC_TAB_CONTROL, (HINSTANCE)hinstDLL, NULL);
if ( hTab ) {
if (hTab)
{
TC_ITEMA item;
SendMessage(hTab, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
item.mask = TCIF_TEXT | TCIF_PARAM;
@ -505,75 +558,101 @@ void SetupRSP_RegistersMain (HWND hDlg) {
SetWindowPos(hDlg, NULL, X, Y, WindowWidth, WindowHeight, SWP_NOZORDER | SWP_SHOWWINDOW);
}
void SetupRSP_Vect1Panel (HWND hDlg) {
void SetupRSP_Vect1Panel(HWND hDlg)
{
int count;
for (count = 0; count < 8;count ++) {
hVECT1[count] = CreateWindowExA(WS_EX_CLIENTEDGE,"EDIT","", WS_CHILD |
ES_READONLY | WS_BORDER | WS_TABSTOP,55,(count*28) + 52,254,19,
for (count = 0; count < 8; count++)
{
hVECT1[count] = CreateWindowExA(WS_EX_CLIENTEDGE, "EDIT", "", WS_CHILD | ES_READONLY | WS_BORDER | WS_TABSTOP, 55, (count * 28) + 52, 254, 19,
hDlg, 0, (HINSTANCE)hinstDLL, NULL);
SendMessage(hVECT1[count], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
for (count = 0; count < 8;count ++) {
hVECT1[count + 8] = CreateWindowExA(WS_EX_CLIENTEDGE,"EDIT","", WS_CHILD |
ES_READONLY | WS_BORDER | WS_TABSTOP,345,(count*28) + 52,254,19,
for (count = 0; count < 8; count++)
{
hVECT1[count + 8] = CreateWindowExA(WS_EX_CLIENTEDGE, "EDIT", "", WS_CHILD | ES_READONLY | WS_BORDER | WS_TABSTOP, 345, (count * 28) + 52, 254, 19,
hDlg, 0, (HINSTANCE)hinstDLL, NULL);
SendMessage(hVECT1[count + 8], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
}
void SetupRSP_Vect2Panel (HWND hDlg) {
void SetupRSP_Vect2Panel(HWND hDlg)
{
int count;
for (count = 0; count < 8;count ++) {
hVECT2[count] = CreateWindowExA(WS_EX_CLIENTEDGE,"EDIT","", WS_CHILD |
ES_READONLY | WS_BORDER | WS_TABSTOP,55,(count*28) + 52,254,19,
for (count = 0; count < 8; count++)
{
hVECT2[count] = CreateWindowExA(WS_EX_CLIENTEDGE, "EDIT", "", WS_CHILD | ES_READONLY | WS_BORDER | WS_TABSTOP, 55, (count * 28) + 52, 254, 19,
hDlg, 0, (HINSTANCE)hinstDLL, NULL);
SendMessage(hVECT2[count], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
for (count = 0; count < 8;count ++) {
hVECT2[count + 8] = CreateWindowExA(WS_EX_CLIENTEDGE,"EDIT","", WS_CHILD |
ES_READONLY | WS_BORDER | WS_TABSTOP,345,(count*28) + 52,254,19,
for (count = 0; count < 8; count++)
{
hVECT2[count + 8] = CreateWindowExA(WS_EX_CLIENTEDGE, "EDIT", "", WS_CHILD | ES_READONLY | WS_BORDER | WS_TABSTOP, 345, (count * 28) + 52, 254, 19,
hDlg, 0, (HINSTANCE)hinstDLL, NULL);
SendMessage(hVECT2[count + 8], WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
}
}
void ShowRSP_RegisterPanel ( int Panel) {
void ShowRSP_RegisterPanel(int Panel)
{
int count;
switch( Panel ) {
switch (Panel)
{
case GeneralPurpose:
for (count = 0; count < 32;count ++) { ShowWindow(hGPR[count], TRUE ); }
for (count = 0; count < 32; count++)
{
ShowWindow(hGPR[count], TRUE);
}
break;
case ControlProcessor0:
for (count = 0; count < 16;count ++) { ShowWindow(hCP0[count], TRUE ); }
for (count = 0; count < 16; count++)
{
ShowWindow(hCP0[count], TRUE);
}
break;
case HiddenRegisters:
for (count = 0; count < 12;count ++) { ShowWindow(hHIDDEN[count], TRUE ); }
for (count = 0; count < 12; count++)
{
ShowWindow(hHIDDEN[count], TRUE);
}
break;
case Vector1:
for (count = 0; count < 16;count ++) { ShowWindow(hVECT1[count], TRUE ); }
for (count = 0; count < 16; count++)
{
ShowWindow(hVECT1[count], TRUE);
}
break;
case Vector2:
for (count = 0; count < 16;count ++) { ShowWindow(hVECT2[count], TRUE ); }
for (count = 0; count < 16; count++)
{
ShowWindow(hVECT2[count], TRUE);
}
break;
}
}
void UpdateRSPRegistersScreen ( void ) {
void UpdateRSPRegistersScreen(void)
{
char RegisterValue[100];
int count, nSel;
TC_ITEM item;
if (!InRSPRegisterWindow) { return; }
if (!InRSPRegisterWindow)
{
return;
}
nSel = TabCtrl_GetCurSel(hTab);
if ( nSel > -1 ) {
if (nSel > -1)
{
item.mask = TCIF_PARAM;
TabCtrl_GetItem(hTab, nSel, &item);
switch( item.lParam ) {
switch (item.lParam)
{
case GeneralPurpose:
for (count = 0; count < 32;count ++) {
for (count = 0; count < 32; count++)
{
sprintf(RegisterValue, " 0x%08X", RSP_GPR[count].UW);
SetWindowTextA(hGPR[count], RegisterValue);
}
@ -616,11 +695,13 @@ void UpdateRSPRegistersScreen ( void ) {
}
break;
case HiddenRegisters:
for (count = 0; count < 8;count ++) {
for (count = 0; count < 8; count++)
{
sprintf(RegisterValue, " 0x%08X - %08X", RSP_ACCUM[count].W[1], RSP_ACCUM[count].W[0]);
SetWindowTextA(hHIDDEN[count], RegisterValue);
}
for (count = 0; count < 3;count ++) {
for (count = 0; count < 3; count++)
{
sprintf(RegisterValue, " 0x%04X", RSP_Flags[count].UHW[0]);
SetWindowTextA(hHIDDEN[count + 8], RegisterValue);
}
@ -628,14 +709,16 @@ void UpdateRSPRegistersScreen ( void ) {
SetWindowTextA(hHIDDEN[11], RegisterValue);
break;
case Vector1:
for (count = 0; count < 16;count ++) {
for (count = 0; count < 16; count++)
{
sprintf(RegisterValue, " 0x%08X - %08X - %08X - %08X", RSP_Vect[count].W[3],
RSP_Vect[count].W[2], RSP_Vect[count].W[1], RSP_Vect[count].W[0]);
SetWindowTextA(hVECT1[count], RegisterValue);
}
break;
case Vector2:
for (count = 0; count < 16;count ++) {
for (count = 0; count < 16; count++)
{
sprintf(RegisterValue, " 0x%08X - %08X - %08X - %08X", RSP_Vect[count + 16].W[3],
RSP_Vect[count + 16].W[2], RSP_Vect[count + 16].W[1], RSP_Vect[count + 16].W[0]);
SetWindowTextA(hVECT2[count], RegisterValue);

55
Source/RSP/RSP Registers.h
View File

@ -87,31 +87,40 @@ extern char * GPR_Strings[32];
*/
#define COP0_Name(Reg) \
(Reg) == 0 ? "SP memory address" :\
(Reg) == 1 ? "SP DRAM DMA address" :\
(Reg) == 2 ? "SP read DMA length" :\
(Reg) == 3 ? "SP write DMA length" :\
(Reg) == 4 ? "SP status" :\
(Reg) == 5 ? "SP DMA full" :\
(Reg) == 6 ? "SP DMA busy" :\
(Reg) == 7 ? "SP semaphore" :\
(Reg) == 8 ? "DP CMD DMA start" :\
(Reg) == 9 ? "DP CMD DMA end" :\
(Reg) == 10 ? "DP CMD DMA current" :\
(Reg) == 11 ? "DP CMD status" :\
(Reg) == 12 ? "DP clock counter" :\
(Reg) == 13 ? "DP buffer busy counter" :\
(Reg) == 14 ? "DP pipe busy counter" :\
(Reg) == 15 ? "DP TMEM load counter" :\
"Unknown Register"
(Reg) == 0 ? "SP memory address" : (Reg) == 1 ? "SP DRAM DMA address" \
: (Reg) == 2 ? "SP read DMA length" \
: (Reg) == 3 ? "SP write DMA length" \
: (Reg) == 4 ? "SP status" \
: (Reg) == 5 ? "SP DMA full" \
: (Reg) == 6 ? "SP DMA busy" \
: (Reg) == 7 ? "SP semaphore" \
: (Reg) == 8 ? "DP CMD DMA start" \
: (Reg) == 9 ? "DP CMD DMA end" \
: (Reg) == 10 ? "DP CMD DMA current" \
: (Reg) == 11 ? "DP CMD status" \
: (Reg) == 12 ? "DP clock counter" \
: (Reg) == 13 ? "DP buffer busy counter" \
: (Reg) == 14 ? "DP pipe busy counter" \
: (Reg) == 15 ? "DP TMEM load counter" \
: "Unknown Register"
#define ElementSpecifier(Elem) \
(Elem) == 0 ? "" : (Elem) == 1 ? "" : (Elem) == 2 ? " [0q]" :\
(Elem) == 3 ? " [1q]" : (Elem) == 4 ? " [0h]" : (Elem) == 5 ? " [1h]" :\
(Elem) == 6 ? " [2h]" : (Elem) == 7 ? " [3h]" : (Elem) == 8 ? " [0]" :\
(Elem) == 9 ? " [1]" : (Elem) == 10 ? " [2]" : (Elem) == 11 ? " [3]" :\
(Elem) == 12 ? " [4]" : (Elem) == 13 ? " [5]" : (Elem) == 14 ? " [6]" :\
(Elem) == 15 ? " [7]" : "Unknown Element"
(Elem) == 0 ? "" : (Elem) == 1 ? "" \
: (Elem) == 2 ? " [0q]" \
: (Elem) == 3 ? " [1q]" \
: (Elem) == 4 ? " [0h]" \
: (Elem) == 5 ? " [1h]" \
: (Elem) == 6 ? " [2h]" \
: (Elem) == 7 ? " [3h]" \
: (Elem) == 8 ? " [0]" \
: (Elem) == 9 ? " [1]" \
: (Elem) == 10 ? " [2]" \
: (Elem) == 11 ? " [3]" \
: (Elem) == 12 ? " [4]" \
: (Elem) == 13 ? " [5]" \
: (Elem) == 14 ? " [6]" \
: (Elem) == 15 ? " [7]" \
: "Unknown Element"
void Enter_RSP_Register_Window(void);
void InitilizeRSPRegisters(void);

707
Source/RSP/Recompiler Analysis.cpp
View File

File diff suppressed because it is too large Load Diff

256
Source/RSP/Recompiler CPU.cpp
View File

@ -1,21 +1,21 @@
#include <windows.h>
#include <stdio.h>
#include <float.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "Rsp.h"
#include "Cpu.h"
#include "Interpreter CPU.h"
#include "Profiling.h"
#include "RSP Command.h"
#include "RSP registers.h"
#include "Recompiler CPU.h"
#include "Recompiler Ops.h"
#include "RSP registers.h"
#include "RSP Command.h"
#include "Rsp.h"
#include "Types.h"
#include "log.h"
#include "memory.h"
#include "opcode.h"
#include "log.h"
#include "Profiling.h"
#include "x86.h"
#include "Types.h"
#pragma warning(disable : 4152) // Non-standard extension, function/data pointer conversion in expression
@ -33,7 +33,8 @@ RSP_CODE RspCode;
BYTE *pLastSecondary = NULL, *pLastPrimary = NULL;
void BuildRecompilerCPU ( void ) {
void BuildRecompilerCPU(void)
{
RSP_Opcode[0] = Compile_SPECIAL;
RSP_Opcode[1] = Compile_REGIMM;
RSP_Opcode[2] = Compile_J;
@ -409,45 +410,61 @@ between branches labels, and actual branches, whichever
occurs first in code
*/
void ReOrderInstructions(DWORD StartPC, DWORD EndPC) {
void ReOrderInstructions(DWORD StartPC, DWORD EndPC)
{
DWORD InstructionCount = EndPC - StartPC;
DWORD Count, ReorderedOps, CurrentPC;
OPCODE PreviousOp, CurrentOp, RspOp;
PreviousOp.Hex = *(DWORD *)(RSPInfo.IMEM + StartPC);
if (TRUE == IsOpcodeBranch(StartPC, PreviousOp)) {
if (TRUE == IsOpcodeBranch(StartPC, PreviousOp))
{
// The sub block ends here anyway
return;
}
if (IsOpcodeNop(StartPC) && IsOpcodeNop(StartPC + 4) && IsOpcodeNop(StartPC + 8)) {
if (IsOpcodeNop(StartPC) && IsOpcodeNop(StartPC + 4) && IsOpcodeNop(StartPC + 8))
{
// Don't even bother
return;
}
CPU_Message("***** Doing reorder (%X to %X) *****", StartPC, EndPC);
if (InstructionCount < 0x0010) { return; }
if (InstructionCount > 0x0A00) { return; }
if (InstructionCount < 0x0010)
{
return;
}
if (InstructionCount > 0x0A00)
{
return;
}
CPU_Message(" Before:");
for (Count = StartPC; Count < EndPC; Count += 4) {
for (Count = StartPC; Count < EndPC; Count += 4)
{
RSP_LW_IMEM(Count, &RspOp.Hex);
CPU_Message(" %X %s", Count, RSPOpcodeName(RspOp.Hex, Count));
}
for (Count = 0; Count < InstructionCount; Count += 4) {
for (Count = 0; Count < InstructionCount; Count += 4)
{
CurrentPC = StartPC;
PreviousOp.Hex = *(DWORD *)(RSPInfo.IMEM + CurrentPC);
ReorderedOps = 0;
for (;;) {
for (;;)
{
CurrentPC += 4;
if (CurrentPC >= EndPC) { break; }
if (CurrentPC >= EndPC)
{
break;
}
CurrentOp.Hex = *(DWORD *)(RSPInfo.IMEM + CurrentPC);
if (TRUE == CompareInstructions(CurrentPC, &PreviousOp, &CurrentOp)) {
if (TRUE == CompareInstructions(CurrentPC, &PreviousOp, &CurrentOp))
{
// Move current opcode up
*(DWORD *)(RSPInfo.IMEM + CurrentPC - 4) = CurrentOp.Hex;
*(DWORD *)(RSPInfo.IMEM + CurrentPC) = PreviousOp.Hex;
@ -460,46 +477,58 @@ void ReOrderInstructions(DWORD StartPC, DWORD EndPC) {
}
PreviousOp.Hex = *(DWORD *)(RSPInfo.IMEM + CurrentPC);
if (IsOpcodeNop(CurrentPC) && IsOpcodeNop(CurrentPC + 4) && IsOpcodeNop(CurrentPC + 8)) {
if (IsOpcodeNop(CurrentPC) && IsOpcodeNop(CurrentPC + 4) && IsOpcodeNop(CurrentPC + 8))
{
CurrentPC = EndPC;
}
}
if (ReorderedOps == 0) {
if (ReorderedOps == 0)
{
Count = InstructionCount;
}
}
CPU_Message(" After:");
for (Count = StartPC; Count < EndPC; Count += 4) {
for (Count = StartPC; Count < EndPC; Count += 4)
{
RSP_LW_IMEM(Count, &RspOp.Hex);
CPU_Message(" %X %s", Count, RSPOpcodeName(RspOp.Hex, Count));
}
CPU_Message("");
}
void ReOrderSubBlock(RSP_BLOCK * Block) {
void ReOrderSubBlock(RSP_BLOCK * Block)
{
DWORD end = 0x0ffc;
DWORD count;
if (!Compiler.bReOrdering) {
if (!Compiler.bReOrdering)
{
return;
}
if (Block->CurrPC > 0xFF0) {
if (Block->CurrPC > 0xFF0)
{
return;
}
// Find the label or jump closest to us
if (RspCode.LabelCount) {
for (count = 0; count < RspCode.LabelCount; count++) {
if (RspCode.BranchLabels[count] < end && RspCode.BranchLabels[count] > Block->CurrPC) {
if (RspCode.LabelCount)
{
for (count = 0; count < RspCode.LabelCount; count++)
{
if (RspCode.BranchLabels[count] < end && RspCode.BranchLabels[count] > Block->CurrPC)
{
end = RspCode.BranchLabels[count];
}
}
}
if (RspCode.BranchCount) {
for (count = 0; count < RspCode.BranchCount; count++) {
if (RspCode.BranchLocations[count] < end && RspCode.BranchLocations[count] > Block->CurrPC) {
if (RspCode.BranchCount)
{
for (count = 0; count < RspCode.BranchCount; count++)
{
if (RspCode.BranchLocations[count] < end && RspCode.BranchLocations[count] > Block->CurrPC)
{
end = RspCode.BranchLocations[count];
}
}
@ -515,13 +544,15 @@ This needs to be called on a sub-block basis, like
after every time we hit a branch and delay slot
*/
void DetectGPRConstants(RSP_CODE * code) {
void DetectGPRConstants(RSP_CODE * code)
{
DWORD Count, Constant = 0;
memset(&code->bIsRegConst, 0, sizeof(Boolean) * 0x20);
memset(&code->MipsRegConst, 0, sizeof(DWORD) * 0x20);
if (!Compiler.bGPRConstants) {
if (!Compiler.bGPRConstants)
{
return;
}
CPU_Message("***** Detecting constants *****");
@ -531,8 +562,10 @@ void DetectGPRConstants(RSP_CODE * code) {
code->MipsRegConst[0] = 0;
// Do your global search for them
for (Count = 1; Count < 31; Count++) {
if (IsRegisterConstant(Count, &Constant) == TRUE) {
for (Count = 1; Count < 31; Count++)
{
if (IsRegisterConstant(Count, &Constant) == TRUE)
{
CPU_Message("Global: %s is a constant of: %08X", GPR_Name(Count), Constant);
code->bIsRegConst[Count] = TRUE;
code->MipsRegConst[Count] = Constant;
@ -549,22 +582,28 @@ taken branches like alignment
2: Clears all the x86 code, jump tables etc.
*/
void CompilerToggleBuffer(void) {
if (dwBuffer == MainBuffer) {
void CompilerToggleBuffer(void)
{
if (dwBuffer == MainBuffer)
{
dwBuffer = SecondaryBuffer;
pLastPrimary = RecompPos;
if (pLastSecondary == NULL) {
if (pLastSecondary == NULL)
{
pLastSecondary = RecompCodeSecondary;
}
RecompPos = pLastSecondary;
CPU_Message(" (Secondary buffer active 0x%08X)", pLastSecondary);
} else {
}
else
{
dwBuffer = MainBuffer;
pLastSecondary = RecompPos;
if (pLastPrimary == NULL) {
if (pLastPrimary == NULL)
{
pLastPrimary = RecompCode;
}
@ -573,7 +612,8 @@ void CompilerToggleBuffer(void) {
}
}
void ClearAllx86Code (void) {
void ClearAllx86Code(void)
{
extern DWORD NoOfMaps, MapsCRC[32];
extern BYTE * JumpTables;
@ -593,23 +633,27 @@ Description:
Resolves all the collected branches, x86 style
*/
void LinkBranches(RSP_BLOCK * Block) {
void LinkBranches(RSP_BLOCK * Block)
{
DWORD OrigPrgCount = *PrgCount;
DWORD Count, Target;
DWORD * JumpWord;
BYTE * X86Code;
RSP_BLOCK Save;
if (!CurrentBlock.ResolveCount) {
if (!CurrentBlock.ResolveCount)
{
return;
}
CPU_Message("***** Linking branches (%i) *****", CurrentBlock.ResolveCount);
for (Count = 0; Count < CurrentBlock.ResolveCount; Count++) {
for (Count = 0; Count < CurrentBlock.ResolveCount; Count++)
{
Target = CurrentBlock.BranchesToResolve[Count].TargetPC;
X86Code = (BYTE *)*(JumpTable + (Target >> 2));
if (!X86Code) {
if (!X86Code)
{
*PrgCount = Target;
CPU_Message("");
CPU_Message("===== (Generate code: %04X) =====", Target);
@ -644,7 +688,8 @@ sections as well as set the jump table to points
within a block that are safe.
*/
void BuildBranchLabels(void) {
void BuildBranchLabels(void)
{
OPCODE RspOp;
DWORD i, Dest;
@ -652,23 +697,30 @@ void BuildBranchLabels(void) {
CPU_Message("***** Building branch labels *****");
#endif
for (i = 0; i < 0x1000; i += 4) {
for (i = 0; i < 0x1000; i += 4)
{
RspOp.Hex = *(DWORD *)(RSPInfo.IMEM + i);
if (TRUE == IsOpcodeBranch(i, RspOp)) {
if (RspCode.LabelCount >= (sizeof(RspCode.BranchLabels) / sizeof(RspCode.BranchLabels[0])) - 1) {
if (TRUE == IsOpcodeBranch(i, RspOp))
{
if (RspCode.LabelCount >= (sizeof(RspCode.BranchLabels) / sizeof(RspCode.BranchLabels[0])) - 1)
{
CompilerWarning("Out of space for branch labels");
return;
}
if (RspCode.BranchCount >= (sizeof(RspCode.BranchLocations) / sizeof(RspCode.BranchLocations[0])) - 1) {
if (RspCode.BranchCount >= (sizeof(RspCode.BranchLocations) / sizeof(RspCode.BranchLocations[0])) - 1)
{
CompilerWarning("Out of space for branch locations");
return;
}
RspCode.BranchLocations[RspCode.BranchCount++] = i;
if (RspOp.op == RSP_SPECIAL) {
if (RspOp.op == RSP_SPECIAL)
{
// Register jump not predictable
} else if (RspOp.op == RSP_J || RspOp.op == RSP_JAL) {
}
else if (RspOp.op == RSP_J || RspOp.op == RSP_JAL)
{
// For JAL its a sub-block for returns
Dest = (RspOp.target << 2) & 0xFFC;
RspCode.BranchLabels[RspCode.LabelCount] = Dest;
@ -676,7 +728,9 @@ void BuildBranchLabels(void) {
#ifdef BUILD_BRANCHLABELS_VERBOSE
CPU_Message("[%02i] Added branch at %X to %X", RspCode.LabelCount, i, Dest);
#endif
} else {
}
else
{
Dest = (i + ((short)RspOp.offset << 2) + 4) & 0xFFC;
RspCode.BranchLabels[RspCode.LabelCount] = Dest;
RspCode.LabelCount += 1;
@ -697,19 +751,23 @@ Boolean IsJumpLabel(DWORD PC)
{
DWORD Count;
if (!RspCode.LabelCount) {
if (!RspCode.LabelCount)
{
return FALSE;
}
for (Count = 0; Count < RspCode.LabelCount; Count++) {
if (PC == RspCode.BranchLabels[Count]) {
for (Count = 0; Count < RspCode.LabelCount; Count++)
{
if (PC == RspCode.BranchLabels[Count])
{
return TRUE;
}
}
return FALSE;
}
void CompilerLinkBlocks(void) {
void CompilerLinkBlocks(void)
{
BYTE * KnownCode = (BYTE *)*(JumpTable + (CompilePC >> 2));
CPU_Message("***** Linking block to X86: %08X *****", KnownCode);
@ -738,7 +796,8 @@ void CompilerRSPBlock(void)
register size_t Count;
const size_t Padding = (8 - (X86BaseAddress & 7)) & 7;
for (Count = 0; Count < Padding; Count++) {
for (Count = 0; Count < Padding; Count++)
{
CPU_Message("%08X: nop", RecompPos);
*(RecompPos++) = 0x90;
}
@ -750,7 +809,8 @@ void CompilerRSPBlock(void)
CPU_Message("Start of block: %X", CurrentBlock.StartPC);
CPU_Message("====== Recompiled code ======");
if (Compiler.bReOrdering == TRUE) {
if (Compiler.bReOrdering == TRUE)
{
memcpy(IMEM_SAVE, RSPInfo.IMEM, 0x1000);
ReOrderSubBlock(&CurrentBlock);
}
@ -758,14 +818,17 @@ void CompilerRSPBlock(void)
// This is for the block about to be compiled
*(JumpTable + (CompilePC >> 2)) = RecompPos;
do {
do
{
// Reordering is setup to allow us to have loop labels
// so here we see if this is one and put it in the jump table
if (NextInstruction == NORMAL && IsJumpLabel(CompilePC)) {
if (NextInstruction == NORMAL && IsJumpLabel(CompilePC))
{
// Jumps come around twice
if (NULL == *(JumpTable + (CompilePC >> 2))) {
if (NULL == *(JumpTable + (CompilePC >> 2)))
{
CPU_Message("***** Adding jump table entry for PC: %04X at X86: %08X *****", CompilePC, RecompPos);
CPU_Message("");
*(JumpTable + (CompilePC >> 2)) = RecompPos;
@ -773,28 +836,33 @@ void CompilerRSPBlock(void)
// Reorder from here to next label or branch
CurrentBlock.CurrPC = CompilePC;
ReOrderSubBlock(&CurrentBlock);
} else if (NextInstruction != DELAY_SLOT_DONE) {
}
else if (NextInstruction != DELAY_SLOT_DONE)
{
// We could link the blocks here, but performance-wise it might be better to just let it run
}
}
if (Compiler.bSections == TRUE) {
if (TRUE == RSP_DoSections()) {
if (Compiler.bSections == TRUE)
{
if (TRUE == RSP_DoSections())
{
continue;
}
}
#ifdef X86_RECOMP_VERBOSE
if (FALSE == IsOpcodeNop(CompilePC)) {
if (FALSE == IsOpcodeNop(CompilePC))
{
CPU_Message("X86 Address: %08X", RecompPos);
}
#endif
RSP_LW_IMEM(CompilePC, &RSPOpC.Hex);
if (LogRDP && NextInstruction != DELAY_SLOT_DONE){
if (LogRDP && NextInstruction != DELAY_SLOT_DONE)
{
char str[40];
sprintf(str, "%X", CompilePC);
PushImm32(str, CompilePC);
@ -802,14 +870,18 @@ void CompilerRSPBlock(void)
AddConstToX86Reg(x86_ESP, 4);
}
if (RSPOpC.Hex == 0xFFFFFFFF) {
if (RSPOpC.Hex == 0xFFFFFFFF)
{
// I think this pops up an unknown OP dialog
// NextInstruction = FINISH_BLOCK;
} else {
}
else
{
RSP_Opcode[RSPOpC.op]();
}
switch (NextInstruction) {
switch (NextInstruction)
{
case NORMAL:
CompilePC += 4;
break;
@ -828,9 +900,12 @@ void CompilerRSPBlock(void)
case FINISH_SUB_BLOCK:
NextInstruction = NORMAL;
CompilePC += 8;
if (CompilePC >= 0x1000) {
if (CompilePC >= 0x1000)
{
NextInstruction = FINISH_BLOCK;
} else if (NULL == *(JumpTable + (CompilePC >> 2))) {
}
else if (NULL == *(JumpTable + (CompilePC >> 2)))
{
// This is for the new block being compiled now
CPU_Message("***** Continuing static SubBlock (jump table entry added for PC: %04X at X86: %08X) *****", CompilePC, RecompPos);
*(JumpTable + (CompilePC >> 2)) = RecompPos;
@ -838,7 +913,9 @@ void CompilerRSPBlock(void)
CurrentBlock.CurrPC = CompilePC;
// Reorder from after delay to next label or branch
ReOrderSubBlock(&CurrentBlock);
} else {
}
else
{
CompilerLinkBlocks();
}
break;
@ -852,13 +929,15 @@ void CompilerRSPBlock(void)
} while (NextInstruction != FINISH_BLOCK && (CompilePC < 0x1000 || NextInstruction == DELAY_SLOT));
CPU_Message("===== End of recompiled code =====");
if (Compiler.bReOrdering == TRUE) {
if (Compiler.bReOrdering == TRUE)
{
memcpy(RSPInfo.IMEM, IMEM_SAVE, 0x1000);
}
free(IMEM_SAVE);
}
DWORD RunRecompilerCPU ( DWORD Cycles ) {
DWORD RunRecompilerCPU(DWORD Cycles)
{
BYTE * Block;
RSP_Running = TRUE;
@ -868,18 +947,23 @@ DWORD RunRecompilerCPU ( DWORD Cycles ) {
{
Block = (BYTE *)*(JumpTable + (*PrgCount >> 2));
if (Block == NULL) {
if (Profiling && !IndvidualBlock) {
if (Block == NULL)
{
if (Profiling && !IndvidualBlock)
{
StartTimer((DWORD)Timer_Compiling);
}
memset(&RspCode, 0, sizeof(RspCode));
#if defined(_MSC_VER)
__try {
__try
{
BuildBranchLabels();
DetectGPRConstants(&RspCode);
CompilerRSPBlock();
} __except(EXCEPTION_EXECUTE_HANDLER) {
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
DisplayError("Error CompilePC = %08X", CompilePC);
ClearAllx86Code();
continue;
@ -897,12 +981,14 @@ DWORD RunRecompilerCPU ( DWORD Cycles ) {
// that go out of it, let's rock
LinkBranches(&CurrentBlock);
if (Profiling && !IndvidualBlock) {
if (Profiling && !IndvidualBlock)
{
StopTimer();
}
}
if (Profiling && IndvidualBlock) {
if (Profiling && IndvidualBlock)
{
StartTimer(*PrgCount);
}
@ -915,7 +1001,8 @@ DWORD RunRecompilerCPU ( DWORD Cycles ) {
#else
DebugBreak();
#endif
if (Profiling && IndvidualBlock) {
if (Profiling && IndvidualBlock)
{
StopTimer();
}
if (RSP_NextInstruction == SINGLE_STEP)
@ -924,7 +1011,8 @@ DWORD RunRecompilerCPU ( DWORD Cycles ) {
}
}
if (IsMmxEnabled == TRUE) {
if (IsMmxEnabled == TRUE)
{
#if defined(_M_IX86) && defined(_MSC_VER)
_asm emms
#else

15
Source/RSP/Recompiler CPU.h
View File

@ -4,7 +4,8 @@
extern uint32_t CompilePC, NextInstruction, JumpTableSize;
extern Boolean ChangedPC;
#define CompilerWarning if (ShowErrors) DisplayError
#define CompilerWarning \
if (ShowErrors) DisplayError
#define High16BitAccum 1
#define Middle16BitAccum 2
@ -36,10 +37,12 @@ void CompilerRSPBlock ( void );
void CompilerToggleBuffer(void);
Boolean RSP_DoSections(void);
typedef struct {
typedef struct
{
DWORD StartPC, CurrPC; // Block start
struct {
struct
{
DWORD TargetPC; // Target for this unknown branch
DWORD * X86JumpLoc; // Our x86 DWORD to fill
} BranchesToResolve[200]; // Branches inside or outside block
@ -49,7 +52,8 @@ typedef struct {
extern RSP_BLOCK CurrentBlock;
typedef struct {
typedef struct
{
Boolean bIsRegConst[32]; // Boolean toggle for constant
DWORD MipsRegConst[32]; // Value of register 32-bit
DWORD BranchLabels[250];
@ -63,7 +67,8 @@ extern RSP_CODE RspCode;
#define IsRegConst(i) (RspCode.bIsRegConst[i])
#define MipsRegConst(i) (RspCode.MipsRegConst[i])
typedef struct {
typedef struct
{
Boolean mmx, mmx2, sse; // CPU specs and compiling
Boolean bFlags; // RSP flag analysis
Boolean bReOrdering; // Instruction reordering

2486
Source/RSP/Recompiler Ops.cpp
View File

File diff suppressed because it is too large Load Diff

514
Source/RSP/Recompiler Sections.cpp
View File

File diff suppressed because it is too large Load Diff

2
Source/RSP/Rsp.h
View File

@ -1,8 +1,8 @@
#pragma once
#include <Project64-plugin-spec/Rsp.h>
#include <stdint.h>
#include "Types.h"
#include <stdint.h>
// Profiling
#define Default_ProfilingOn FALSE

115
Source/RSP/Sse.cpp
View File

@ -1,30 +1,38 @@
#include <windows.h>
#include <stdio.h>
#include "Rsp.h"
#include "x86.h"
#include "memory.h"
#include "RSP registers.h"
#include "Rsp.h"
#include "log.h"
#include "memory.h"
#include "x86.h"
#include <stdio.h>
#include <windows.h>
#define PUTDST8(dest,value) (*((BYTE *)(dest))=(BYTE)(value)); dest += 1;
#define PUTDST16(dest,value) (*((WORD *)(dest))=(WORD)(value)); dest += 2;
#define PUTDST32(dest,value) (*((DWORD *)(dest))=(DWORD)(value)); dest += 4;
#define PUTDST8(dest, value) \
(*((BYTE *)(dest)) = (BYTE)(value)); \
dest += 1;
#define PUTDST16(dest, value) \
(*((WORD *)(dest)) = (WORD)(value)); \
dest += 2;
#define PUTDST32(dest, value) \
(*((DWORD *)(dest)) = (DWORD)(value)); \
dest += 4;
#define PUTDSTPTR(dest, value) \
*(void **)(dest) = (void *)(value); dest += sizeof(void *);
*(void **)(dest) = (void *)(value); \
dest += sizeof(void *);
char * sse_Strings[8] = {
"xmm0", "xmm1", "xmm2", "xmm3",
"xmm4", "xmm5", "xmm6", "xmm7"
};
"xmm4", "xmm5", "xmm6", "xmm7"};
#define sse_Name(Reg) (sse_Strings[(Reg)])
void SseMoveAlignedVariableToReg(void *Variable, char *VariableName, int sseReg) {
void SseMoveAlignedVariableToReg(void * Variable, char * VariableName, int sseReg)
{
BYTE x86Command = 0;
CPU_Message(" movaps %s, xmmword ptr [%s]", sse_Name(sseReg), VariableName);
switch (sseReg) {
switch (sseReg)
{
case x86_XMM0: x86Command = 0x05; break;
case x86_XMM1: x86Command = 0x0D; break;
case x86_XMM2: x86Command = 0x15; break;
@ -40,12 +48,14 @@ void SseMoveAlignedVariableToReg(void *Variable, char *VariableName, int sseReg)
PUTDSTPTR(RecompPos, Variable);
}
void SseMoveAlignedN64MemToReg(int sseReg, int AddrReg) {
void SseMoveAlignedN64MemToReg(int sseReg, int AddrReg)
{
BYTE x86Command = 0;
CPU_Message(" movaps %s, xmmword ptr [Dmem+%s]", sse_Name(sseReg), x86_Name(AddrReg));
switch (sseReg) {
switch (sseReg)
{
case x86_XMM0: x86Command = 0x80; break;
case x86_XMM1: x86Command = 0x88; break;
case x86_XMM2: x86Command = 0x90; break;
@ -55,7 +65,8 @@ void SseMoveAlignedN64MemToReg(int sseReg, int AddrReg) {
case x86_XMM6: x86Command = 0xB0; break;
case x86_XMM7: x86Command = 0xB8; break;
}
switch (AddrReg) {
switch (AddrReg)
{
case x86_EAX: x86Command += 0x00; break;
case x86_EBX: x86Command += 0x03; break;
case x86_ECX: x86Command += 0x01; break;
@ -71,12 +82,14 @@ void SseMoveAlignedN64MemToReg(int sseReg, int AddrReg) {
PUTDSTPTR(RecompPos, RSPInfo.DMEM);
}
void SseMoveAlignedRegToVariable(int sseReg, void *Variable, char *VariableName) {
void SseMoveAlignedRegToVariable(int sseReg, void * Variable, char * VariableName)
{
BYTE x86Command = 0;
CPU_Message(" movaps xmmword ptr [%s], %s", VariableName, sse_Name(sseReg));
switch (sseReg) {
switch (sseReg)
{
case x86_XMM0: x86Command = 0x05; break;
case x86_XMM1: x86Command = 0x0D; break;
case x86_XMM2: x86Command = 0x15; break;
@ -92,12 +105,14 @@ void SseMoveAlignedRegToVariable(int sseReg, void *Variable, char *VariableName)
PUTDSTPTR(RecompPos, Variable);
}
void SseMoveAlignedRegToN64Mem(int sseReg, int AddrReg) {
void SseMoveAlignedRegToN64Mem(int sseReg, int AddrReg)
{
BYTE x86Command = 0;
CPU_Message(" movaps xmmword ptr [Dmem+%s], %s", x86_Name(AddrReg), sse_Name(sseReg));
switch (sseReg) {
switch (sseReg)
{
case x86_XMM0: x86Command = 0x80; break;
case x86_XMM1: x86Command = 0x88; break;
case x86_XMM2: x86Command = 0x90; break;
@ -107,7 +122,8 @@ void SseMoveAlignedRegToN64Mem(int sseReg, int AddrReg) {
case x86_XMM6: x86Command = 0xB0; break;
case x86_XMM7: x86Command = 0xB8; break;
}
switch (AddrReg) {
switch (AddrReg)
{
case x86_EAX: x86Command += 0x00; break;
case x86_EBX: x86Command += 0x03; break;
case x86_ECX: x86Command += 0x01; break;
@ -123,12 +139,14 @@ void SseMoveAlignedRegToN64Mem(int sseReg, int AddrReg) {
PUTDSTPTR(RecompPos, RSPInfo.DMEM);
}
void SseMoveUnalignedVariableToReg(void *Variable, char *VariableName, int sseReg) {
void SseMoveUnalignedVariableToReg(void * Variable, char * VariableName, int sseReg)
{
BYTE x86Command = 0;
CPU_Message(" movups %s, xmmword ptr [%s]", sse_Name(sseReg), VariableName);
switch (sseReg) {
switch (sseReg)
{
case x86_XMM0: x86Command = 0x05; break;
case x86_XMM1: x86Command = 0x0D; break;
case x86_XMM2: x86Command = 0x15; break;
@ -144,12 +162,14 @@ void SseMoveUnalignedVariableToReg(void *Variable, char *VariableName, int sseRe
PUTDSTPTR(RecompPos, Variable);
}
void SseMoveUnalignedN64MemToReg(int sseReg, int AddrReg) {
void SseMoveUnalignedN64MemToReg(int sseReg, int AddrReg)
{
BYTE x86Command = 0;
CPU_Message(" movups %s, xmmword ptr [Dmem+%s]", sse_Name(sseReg), x86_Name(AddrReg));
switch (sseReg) {
switch (sseReg)
{
case x86_XMM0: x86Command = 0x80; break;
case x86_XMM1: x86Command = 0x88; break;
case x86_XMM2: x86Command = 0x90; break;
@ -159,7 +179,8 @@ void SseMoveUnalignedN64MemToReg(int sseReg, int AddrReg) {
case x86_XMM6: x86Command = 0xB0; break;
case x86_XMM7: x86Command = 0xB8; break;
}
switch (AddrReg) {
switch (AddrReg)
{
case x86_EAX: x86Command += 0x00; break;
case x86_EBX: x86Command += 0x03; break;
case x86_ECX: x86Command += 0x01; break;
@ -175,12 +196,14 @@ void SseMoveUnalignedN64MemToReg(int sseReg, int AddrReg) {
PUTDSTPTR(RecompPos, RSPInfo.DMEM);
}
void SseMoveUnalignedRegToVariable(int sseReg, void *Variable, char *VariableName) {
void SseMoveUnalignedRegToVariable(int sseReg, void * Variable, char * VariableName)
{
BYTE x86Command = 0;
CPU_Message(" movups xmmword ptr [%s], %s", VariableName, sse_Name(sseReg));
switch (sseReg) {
switch (sseReg)
{
case x86_XMM0: x86Command = 0x05; break;
case x86_XMM1: x86Command = 0x0D; break;
case x86_XMM2: x86Command = 0x15; break;
@ -196,12 +219,14 @@ void SseMoveUnalignedRegToVariable(int sseReg, void *Variable, char *VariableNam
PUTDSTPTR(RecompPos, Variable);
}
void SseMoveUnalignedRegToN64Mem(int sseReg, int AddrReg) {
void SseMoveUnalignedRegToN64Mem(int sseReg, int AddrReg)
{
BYTE x86Command = 0;
CPU_Message(" movups xmmword ptr [Dmem+%s], %s", x86_Name(AddrReg), sse_Name(sseReg));
switch (sseReg) {
switch (sseReg)
{
case x86_XMM0: x86Command = 0x80; break;
case x86_XMM1: x86Command = 0x88; break;
case x86_XMM2: x86Command = 0x90; break;
@ -211,7 +236,8 @@ void SseMoveUnalignedRegToN64Mem(int sseReg, int AddrReg) {
case x86_XMM6: x86Command = 0xB0; break;
case x86_XMM7: x86Command = 0xB8; break;
}
switch (AddrReg) {
switch (AddrReg)
{
case x86_EAX: x86Command += 0x00; break;
case x86_EBX: x86Command += 0x03; break;
case x86_ECX: x86Command += 0x01; break;
@ -227,12 +253,14 @@ void SseMoveUnalignedRegToN64Mem(int sseReg, int AddrReg) {
PUTDSTPTR(RecompPos, RSPInfo.DMEM);
}
void SseMoveRegToReg(int Dest, int Source) {
void SseMoveRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" movaps %s, %s", sse_Name(Dest), sse_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_XMM0: x86Command = 0x00; break;
case x86_XMM1: x86Command = 0x08; break;
case x86_XMM2: x86Command = 0x10; break;
@ -242,7 +270,8 @@ void SseMoveRegToReg(int Dest, int Source) {
case x86_XMM6: x86Command = 0x30; break;
case x86_XMM7: x86Command = 0x38; break;
}
switch (Source) {
switch (Source)
{
case x86_XMM0: x86Command += 0x00; break;
case x86_XMM1: x86Command += 0x01; break;
case x86_XMM2: x86Command += 0x02; break;
@ -257,12 +286,14 @@ void SseMoveRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void SseXorRegToReg(int Dest, int Source) {
void SseXorRegToReg(int Dest, int Source)
{
BYTE x86Command = 0;
CPU_Message(" xorps %s, %s", sse_Name(Dest), sse_Name(Source));
switch (Dest) {
switch (Dest)
{
case x86_XMM0: x86Command = 0x00; break;
case x86_XMM1: x86Command = 0x08; break;
case x86_XMM2: x86Command = 0x10; break;
@ -272,7 +303,8 @@ void SseXorRegToReg(int Dest, int Source) {
case x86_XMM6: x86Command = 0x30; break;
case x86_XMM7: x86Command = 0x38; break;
}
switch (Source) {
switch (Source)
{
case x86_XMM0: x86Command += 0x00; break;
case x86_XMM1: x86Command += 0x01; break;
case x86_XMM2: x86Command += 0x02; break;
@ -286,12 +318,14 @@ void SseXorRegToReg(int Dest, int Source) {
PUTDST8(RecompPos, 0xC0 | x86Command);
}
void SseShuffleReg(int Dest, int Source, BYTE Immed) {
void SseShuffleReg(int Dest, int Source, BYTE Immed)
{
BYTE x86Command = 0;
CPU_Message(" shufps %s, %s, %02X", sse_Name(Dest), sse_Name(Source), Immed);
switch (Dest) {
switch (Dest)
{
case x86_XMM0: x86Command = 0x00; break;
case x86_XMM1: x86Command = 0x08; break;
case x86_XMM2: x86Command = 0x10; break;
@ -301,7 +335,8 @@ void SseShuffleReg(int Dest, int Source, BYTE Immed) {
case x86_XMM6: x86Command = 0x30; break;
case x86_XMM7: x86Command = 0x38; break;
}
switch (Source) {
switch (Source)
{
case x86_XMM0: x86Command += 0x00; break;
case x86_XMM1: x86Command += 0x01; break;
case x86_XMM2: x86Command += 0x02; break;

9
Source/RSP/Types.h
View File

@ -25,7 +25,8 @@ typedef int Boolean;
#define TRUE 1
#endif
typedef union tagUWORD {
typedef union tagUWORD
{
int32_t W;
uint32_t UW;
int16_t HW[2];
@ -36,7 +37,8 @@ typedef union tagUWORD {
float F;
} UWORD32;
typedef union tagUDWORD {
typedef union tagUDWORD
{
int64_t DW;
uint64_t UDW;
int32_t W[2];
@ -50,7 +52,8 @@ typedef union tagUDWORD {
float F[2];
} UDWORD;
typedef union tagVect {
typedef union tagVect
{
int64_t DW[2];
uint64_t UDW[2];
int32_t W[4];

1103
Source/RSP/X86.cpp
View File

File diff suppressed because it is too large Load Diff

45
Source/RSP/X86.h
View File

@ -1,16 +1,37 @@
enum x86RegValues {
x86_EAX = 0, x86_EBX = 1, x86_ECX = 2, x86_EDX = 3,
x86_ESI = 4, x86_EDI = 5, x86_EBP = 6, x86_ESP = 7
enum x86RegValues
{
x86_EAX = 0,
x86_EBX = 1,
x86_ECX = 2,
x86_EDX = 3,
x86_ESI = 4,
x86_EDI = 5,
x86_EBP = 6,
x86_ESP = 7
};
enum mmxRegValues {
x86_MM0 = 0, x86_MM1 = 1, x86_MM2 = 2, x86_MM3 = 3,
x86_MM4 = 4, x86_MM5 = 5, x86_MM6 = 6, x86_MM7 = 7
enum mmxRegValues
{
x86_MM0 = 0,
x86_MM1 = 1,
x86_MM2 = 2,
x86_MM3 = 3,
x86_MM4 = 4,
x86_MM5 = 5,
x86_MM6 = 6,
x86_MM7 = 7
};
enum sseRegValues {
x86_XMM0 = 0, x86_XMM1 = 1, x86_XMM2 = 2, x86_XMM3 = 3,
x86_XMM4 = 4, x86_XMM5 = 5, x86_XMM6 = 6, x86_XMM7 = 7
enum sseRegValues
{
x86_XMM0 = 0,
x86_XMM1 = 1,
x86_XMM2 = 2,
x86_XMM3 = 3,
x86_XMM4 = 4,
x86_XMM5 = 5,
x86_XMM6 = 6,
x86_XMM7 = 7
};
void AdcX86RegToX86Reg(int Destination, int Source);
@ -226,8 +247,10 @@ void SseXorRegToReg ( int Dest, int Source );
#pragma warning(push)
#pragma warning(disable : 4201) // Non-standard extension used: nameless struct/union
typedef union {
struct {
typedef union
{
struct
{
unsigned Reg0 : 2;
unsigned Reg1 : 2;
unsigned Reg2 : 2;

25
Source/RSP/breakpoint.cpp
View File

@ -1,8 +1,8 @@
#include <windows.h>
#include <stdio.h>
#include "Rsp.h"
#include "CPU.h"
#include "breakpoint.h"
#include "CPU.h"
#include "Rsp.h"
#include <stdio.h>
#include <windows.h>
#define IDC_LOCATION_EDIT 105
HWND BPoint_Win_hDlg, hRSPLocation = NULL;
@ -15,7 +15,8 @@ void Add_BPoint ( void )
char Title[10];
GetWindowTextA(hRSPLocation, Title, sizeof(Title));
if (!AddRSP_BPoint(AsciiToHex(Title),TRUE )) {
if (!AddRSP_BPoint(AsciiToHex(Title), TRUE))
{
SendMessage(hRSPLocation, EM_SETSEL, (WPARAM)0, (LPARAM)-1);
SetFocus(hRSPLocation);
}
@ -78,7 +79,10 @@ int CheckForRSPBPoint ( DWORD Location )
void CreateBPPanel(void * hDlg, rectangle rcBox)
{
if (hRSPLocation != NULL) { return; }
if (hRSPLocation != NULL)
{
return;
}
rcBox = rcBox; // Remove warning of unused
@ -118,15 +122,15 @@ void RefreshBpoints ( void * hList )
LRESULT location;
int count;
for (count = 0; count < NoOfBpoints; count ++ ) {
for (count = 0; count < NoOfBpoints; count++)
{
sprintf(Message, " at 0x%03X (RSP)", BPoint[count].Location);
location = SendMessageA((HWND)hList, LB_ADDSTRING, 0, (LPARAM)Message);
SendMessageA(
(HWND)hList,
LB_SETITEMDATA,
(WPARAM)location,
(LPARAM)BPoint[count].Location
);
(LPARAM)BPoint[count].Location);
}
}
@ -145,8 +149,7 @@ void RemoveBpoint (void * hList, int index )
{
DisplayError(
"LB_GETITEMDATA response for %i out of DWORD range.",
index
);
index);
}
location = (uint32_t)response;
RemoveRSPBreakPoint(location);

4
Source/RSP/breakpoint.h
View File

@ -1,8 +1,10 @@
#include "Rsp.h"
#include <Windows.h>
#define MaxBPoints 0x30
typedef struct {
typedef struct
{
unsigned int Location;
} BPOINT;

4
Source/RSP/dma.cpp
View File

@ -1,9 +1,9 @@
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "Rsp.h"
#include "RSP Registers.h"
#include "Rsp.h"
#include "memory.h"
// #define RSP_SAFE_DMA // Unoptimized DMA transfers

67
Source/RSP/log.cpp
View File

@ -1,14 +1,13 @@
#include <stdio.h>
#include <windows.h>
#include <Common/StdString.h>
#include <Common/File.h>
#include <Common/Log.h>
#include <Common/StdString.h>
#include <Common/path.h>
#include <stdio.h>
#include <windows.h>
#include "Log.h"
#include "Rsp.h"
#include "Rsp Registers.h"
#include "Rsp.h"
CLog * RDPLog = NULL;
CLog * CPULog = NULL;
@ -101,7 +100,8 @@ void RDP_LogMT0 ( DWORD PC, int Reg, DWORD Value )
{
return;
}
switch (Reg) {
switch (Reg)
{
case 0: RDP_Message("%03X: Stored 0x%08X into SP_MEM_ADDR_REG", PC, Value); break;
case 1: RDP_Message("%03X: Stored 0x%08X into SP_DRAM_ADDR_REG", PC, Value); break;
case 2: RDP_Message("%03X: Stored 0x%08X into SP_RD_LEN_REG", PC, Value); break;
@ -120,7 +120,8 @@ void RDP_LogMT0 ( DWORD PC, int Reg, DWORD Value )
void RDP_LogMF0(DWORD PC, int Reg)
{
switch (Reg) {
switch (Reg)
{
case 8: RDP_Message("%03X: Read 0x%08X from DPC_START_REG", PC, *RSPInfo.DPC_START_REG); break;
case 9: RDP_Message("%03X: Read 0x%08X from DPC_END_REG", PC, *RSPInfo.DPC_END_REG); break;
case 10: RDP_Message("%03X: Read 0x%08X from DPC_CURRENT_REG", PC, *RSPInfo.DPC_CURRENT_REG); break;
@ -129,7 +130,6 @@ void RDP_LogMF0 ( DWORD PC, int Reg )
}
}
void RDP_LogDlist(void)
{
if (RDPLog == NULL)
@ -154,22 +154,28 @@ void RDP_LogDlist ( void )
Mem = RSPInfo.RDRAM;
}
for (count = 0; count < 0x10; count ++, Pos++ ) {
for (count = 0; count < 0x10; count++, Pos++)
{
char tmp[3];
if ((count % 4) != 0 || count == 0) {
if ((count % 4) != 0 || count == 0)
{
sprintf(tmp, "%02X", Mem[Pos]);
strcat(Hex, " ");
strcat(Hex, tmp);
} else {
}
else
{
sprintf(tmp, "%02X", Mem[Pos]);
strcat(Hex, " - ");
strcat(Hex, tmp);
}
if (Mem[Pos] < 30 || Mem[Pos] > 127) {
if (Mem[Pos] < 30 || Mem[Pos] > 127)
{
strcat(Ascii, ".");
} else {
}
else
{
sprintf(tmp, "%c", Mem[Pos]);
strcat(Ascii, tmp);
}
@ -185,12 +191,11 @@ void RDP_LogLoc ( DWORD /*PC*/ )
// RSP_Vect[28].UW[0],RSP_Vect[28].UW[1],RSP_Vect[28].UW[2],RSP_Vect[28].UW[3],RSP_Vect[31].UW[0]);
}
#ifdef old
#include <windows.h>
#include "RSP Registers.h"
#include "log.h"
#include <windows.h>
#ifdef Log_x86Code
static HANDLE hCPULogFile = NULL;
@ -201,7 +206,8 @@ static HANDLE hLogFile = NULL;
#endif
#ifdef Log_x86Code
void CPU_Message (char * Message, ...) {
void CPU_Message(char * Message, ...)
{
DWORD dwWritten;
char Msg[400];
va_list ap;
@ -216,7 +222,8 @@ void CPU_Message (char * Message, ...) {
#endif
#ifdef GenerateLog
void Log_Message (char * Message, ...) {
void Log_Message(char * Message, ...)
{
DWORD dwWritten;
char Msg[400];
va_list ap;
@ -232,7 +239,8 @@ void Log_Message (char * Message, ...) {
#endif
#ifdef Log_x86Code
void Start_x86_Log (void) {
void Start_x86_Log(void)
{
char path_buffer[_MAX_PATH], drive[_MAX_DRIVE], dir[_MAX_DIR];
char File[_MAX_PATH];
@ -248,8 +256,10 @@ void Start_x86_Log (void) {
#endif
#ifdef GenerateLog
void Log_MT_CP0 ( unsigned int PC, int CP0Reg, int Value ) {
switch (CP0Reg) {
void Log_MT_CP0(unsigned int PC, int CP0Reg, int Value)
{
switch (CP0Reg)
{
//case 0: Log_Message("%03X: Stored 0x%08X in SP_MEM_ADDR_REG",PC,Value); break;
//case 1: Log_Message("%03X: Stored 0x%08X in SP_DRAM_ADDR_REG",PC,Value); break;
//case 2: Log_Message("%03X: Stored 0x%08X in SP_RD_LEN_REG",PC,Value); break;
@ -276,7 +286,8 @@ void Log_MT_CP0 ( unsigned int PC, int CP0Reg, int Value ) {
}
}
void Start_Log (void) {
void Start_Log(void)
{
char path_buffer[_MAX_PATH], drive[_MAX_DRIVE], dir[_MAX_DIR];
char File[_MAX_PATH];
@ -290,8 +301,10 @@ void Start_Log (void) {
SetFilePointer(hLogFile, 0, NULL, FILE_BEGIN);
}
void Stop_Log (void) {
if (hLogFile) {
void Stop_Log(void)
{
if (hLogFile)
{
CloseHandle(hLogFile);
hLogFile = NULL;
}
@ -299,8 +312,10 @@ void Stop_Log (void) {
#endif
#ifdef Log_x86Code
void Stop_x86_Log (void) {
if (hCPULogFile) {
void Stop_x86_Log(void)
{
if (hCPULogFile)
{
CloseHandle(hCPULogFile);
hCPULogFile = NULL;
}

2
Source/RSP/log.h
View File

@ -1,3 +1,5 @@
#include <windows.h>
void StartCPULog(void);
void StopCPULog(void);
void CPU_Message(const char * Message, ...);

255
Source/RSP/memory.cpp
View File

@ -1,36 +1,46 @@
enum { MaxMaps = 32 };
enum
{
MaxMaps = 32
};
#include <windows.h>
#include "Rsp.h"
#include "RSP Registers.h"
#include "Rsp.h"
#include <windows.h>
DWORD NoOfMaps, MapsCRC[MaxMaps];
uint32_t Table;
BYTE *RecompCode, *RecompCodeSecondary, *RecompPos, *JumpTables;
void ** JumpTable;
int AllocateMemory (void) {
if (RecompCode == NULL){
int AllocateMemory(void)
{
if (RecompCode == NULL)
{
RecompCode = (BYTE *)VirtualAlloc(NULL, 0x00400004, MEM_RESERVE, PAGE_EXECUTE_READWRITE);
RecompCode = (BYTE *)VirtualAlloc(RecompCode, 0x00400000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if(RecompCode == NULL) {
if (RecompCode == NULL)
{
DisplayError("Not enough memory for RSP RecompCode!");
return FALSE;
}
}
if (RecompCodeSecondary == NULL){
if (RecompCodeSecondary == NULL)
{
RecompCodeSecondary = (BYTE *)VirtualAlloc(NULL, 0x00200000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if(RecompCodeSecondary == NULL) {
if (RecompCodeSecondary == NULL)
{
DisplayError("Not enough memory for RSP RecompCode Secondary!");
return FALSE;
}
}
if (JumpTables == NULL){
if (JumpTables == NULL)
{
JumpTables = (BYTE *)VirtualAlloc(NULL, 0x1000 * MaxMaps, MEM_COMMIT, PAGE_READWRITE);
if( JumpTables == NULL ) {
if (JumpTables == NULL)
{
DisplayError("Not enough memory for jump table!");
return FALSE;
}
@ -42,7 +52,8 @@ int AllocateMemory (void) {
return TRUE;
}
void FreeMemory (void) {
void FreeMemory(void)
{
VirtualFree(RecompCode, 0, MEM_RELEASE);
VirtualFree(JumpTable, 0, MEM_RELEASE);
VirtualFree(RecompCodeSecondary, 0, MEM_RELEASE);
@ -59,7 +70,8 @@ void ResetJumpTables ( void )
NoOfMaps = 0;
}
void SetJumpTable (uint32_t End) {
void SetJumpTable(uint32_t End)
{
DWORD CRC, count;
CRC = 0;
@ -73,19 +85,23 @@ void SetJumpTable (uint32_t End) {
End = 0x800;
}
for (count = 0; count < End; count += 0x40) {
for (count = 0; count < End; count += 0x40)
{
CRC += *(DWORD *)(RSPInfo.IMEM + count);
}
for (count = 0; count < NoOfMaps; count++ ) {
if (CRC == MapsCRC[count]) {
for (count = 0; count < NoOfMaps; count++)
{
if (CRC == MapsCRC[count])
{
JumpTable = (void **)(JumpTables + count * 0x1000);
Table = count;
return;
}
}
//DisplayError("%X %X",NoOfMaps,CRC);
if (NoOfMaps == MaxMaps) {
if (NoOfMaps == MaxMaps)
{
ResetJumpTables();
}
MapsCRC[NoOfMaps] = CRC;
@ -94,34 +110,40 @@ void SetJumpTable (uint32_t End) {
NoOfMaps += 1;
}
void RSP_LB_DMEM ( uint32_t Addr, uint8_t * Value ) {
void RSP_LB_DMEM(uint32_t Addr, uint8_t * Value)
{
*Value = *(uint8_t *)(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF));
}
void RSP_LBV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_LBV_DMEM(uint32_t Addr, int vect, int element)
{
RSP_Vect[vect].B[15 - element] = *(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF));
}
void RSP_LDV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_LDV_DMEM(uint32_t Addr, int vect, int element)
{
int length, Count;
length = 8;
if (length > 16 - element) {
if (length > 16 - element)
{
length = 16 - element;
}
for (Count = element; Count < (length + element); Count ++ ){
for (Count = element; Count < (length + element); Count++)
{
RSP_Vect[vect].B[15 - Count] = *(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF));
Addr += 1;
}
}
void RSP_LFV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_LFV_DMEM(uint32_t Addr, int vect, int element)
{
int length, count;
VECTOR Temp;
length = 8;
if (length > 16 - element) {
if (length > 16 - element)
{
length = 16 - element;
}
@ -134,14 +156,18 @@ void RSP_LFV_DMEM ( uint32_t Addr, int vect, int element ) {
Temp.HW[1] = *(RSPInfo.DMEM + (((Addr + ((0x10 - element) ^ 3) & 0xf)) & 0xFFF)) << 7;
Temp.HW[0] = *(RSPInfo.DMEM + (((Addr + ((0x4 - element) ^ 3) & 0xf)) & 0xFFF)) << 7;
for (count = element; count < (length + element); count ++ ){
for (count = element; count < (length + element); count++)
{
RSP_Vect[vect].B[15 - count] = Temp.B[15 - count];
}
}
void RSP_LH_DMEM ( uint32_t Addr, uint16_t * Value ) {
if ((Addr & 0x1) != 0) {
if (Addr > 0xFFE) {
void RSP_LH_DMEM(uint32_t Addr, uint16_t * Value)
{
if ((Addr & 0x1) != 0)
{
if (Addr > 0xFFE)
{
DisplayError("There is a problem with:\nRSP_LH_DMEM");
return;
}
@ -153,7 +179,8 @@ void RSP_LH_DMEM ( uint32_t Addr, uint16_t * Value ) {
*Value = *(uint16_t *)(RSPInfo.DMEM + ((Addr ^ 2) & 0xFFF));
}
void RSP_LHV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_LHV_DMEM(uint32_t Addr, int vect, int element)
{
RSP_Vect[vect].HW[7] = *(RSPInfo.DMEM + ((Addr + ((0x10 - element) & 0xF) ^ 3) & 0xFFF)) << 7;
RSP_Vect[vect].HW[6] = *(RSPInfo.DMEM + ((Addr + ((0x10 - element + 2) & 0xF) ^ 3) & 0xFFF)) << 7;
RSP_Vect[vect].HW[5] = *(RSPInfo.DMEM + ((Addr + ((0x10 - element + 4) & 0xF) ^ 3) & 0xFFF)) << 7;
@ -164,21 +191,24 @@ void RSP_LHV_DMEM ( uint32_t Addr, int vect, int element ) {
RSP_Vect[vect].HW[0] = *(RSPInfo.DMEM + ((Addr + ((0x10 - element + 14) & 0xF) ^ 3) & 0xFFF)) << 7;
}
void RSP_LLV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_LLV_DMEM(uint32_t Addr, int vect, int element)
{
int length, Count;
length = 4;
if (length > 16 - element) {
if (length > 16 - element)
{
length = 16 - element;
}
for (Count = element; Count < (length + element); Count ++ ){
for (Count = element; Count < (length + element); Count++)
{
RSP_Vect[vect].B[15 - Count] = *(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF));
Addr += 1;
}
}
void RSP_LPV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_LPV_DMEM(uint32_t Addr, int vect, int element)
{
RSP_Vect[vect].HW[7] = *(RSPInfo.DMEM + ((Addr + ((0x10 - element) & 0xF) ^ 3) & 0xFFF)) << 8;
RSP_Vect[vect].HW[6] = *(RSPInfo.DMEM + ((Addr + ((0x10 - element + 1) & 0xF) ^ 3) & 0xFFF)) << 8;
RSP_Vect[vect].HW[5] = *(RSPInfo.DMEM + ((Addr + ((0x10 - element + 2) & 0xF) ^ 3) & 0xFFF)) << 8;
@ -189,56 +219,65 @@ void RSP_LPV_DMEM ( uint32_t Addr, int vect, int element ) {
RSP_Vect[vect].HW[0] = *(RSPInfo.DMEM + ((Addr + ((0x10 - element + 7) & 0xF) ^ 3) & 0xFFF)) << 8;
}
void RSP_LRV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_LRV_DMEM(uint32_t Addr, int vect, int element)
{
int length, Count, offset;
offset = (Addr & 0xF) - 1;
length = (Addr & 0xF) - element;
Addr &= 0xFF0;
for (Count = element; Count < (length + element); Count ++ ){
for (Count = element; Count < (length + element); Count++)
{
RSP_Vect[vect].B[offset - Count] = *(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF));
Addr += 1;
}
}
void RSP_LQV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_LQV_DMEM(uint32_t Addr, int vect, int element)
{
int length, Count;
length = ((Addr + 0x10) & ~0xF) - Addr;
if (length > 16 - element) {
if (length > 16 - element)
{
length = 16 - element;
}
for (Count = element; Count < (length + element); Count ++ ){
for (Count = element; Count < (length + element); Count++)
{
RSP_Vect[vect].B[15 - Count] = *(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF));
Addr += 1;
}
}
void RSP_LSV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_LSV_DMEM(uint32_t Addr, int vect, int element)
{
int length, Count;
length = 2;
if (length > 16 - element) {
if (length > 16 - element)
{
length = 16 - element;
}
for (Count = element; Count < (length + element); Count ++ ){
for (Count = element; Count < (length + element); Count++)
{
RSP_Vect[vect].B[15 - Count] = *(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF));
Addr += 1;
}
}
void RSP_LTV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_LTV_DMEM(uint32_t Addr, int vect, int element)
{
int del, count, length;
length = 8;
if (length > 32 - vect) {
if (length > 32 - vect)
{
length = 32 - vect;
}
Addr = ((Addr + 8) & 0xFF0) + (element & 0x1);
for (count = 0; count < length; count ++) {
for (count = 0; count < length; count++)
{
del = ((8 - (element >> 1) + count) << 1) & 0xF;
RSP_Vect[vect + count].B[15 - del] = *(RSPInfo.DMEM + (Addr ^ 3));
RSP_Vect[vect + count].B[14 - del] = *(RSPInfo.DMEM + ((Addr + 1) ^ 3));
@ -246,7 +285,8 @@ void RSP_LTV_DMEM ( uint32_t Addr, int vect, int element ) {
}
}
void RSP_LUV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_LUV_DMEM(uint32_t Addr, int vect, int element)
{
RSP_Vect[vect].HW[7] = *(RSPInfo.DMEM + ((Addr + ((0x10 - element) & 0xF) ^ 3) & 0xFFF)) << 7;
RSP_Vect[vect].HW[6] = *(RSPInfo.DMEM + ((Addr + ((0x10 - element + 1) & 0xF) ^ 3) & 0xFFF)) << 7;
RSP_Vect[vect].HW[5] = *(RSPInfo.DMEM + ((Addr + ((0x10 - element + 2) & 0xF) ^ 3) & 0xFFF)) << 7;
@ -257,10 +297,13 @@ void RSP_LUV_DMEM ( uint32_t Addr, int vect, int element ) {
RSP_Vect[vect].HW[0] = *(RSPInfo.DMEM + ((Addr + ((0x10 - element + 7) & 0xF) ^ 3) & 0xFFF)) << 7;
}
void RSP_LW_DMEM ( uint32_t Addr, uint32_t * Value ) {
if ((Addr & 0x3) != 0) {
void RSP_LW_DMEM(uint32_t Addr, uint32_t * Value)
{
if ((Addr & 0x3) != 0)
{
Addr &= 0xFFF;
if (Addr > 0xFFC) {
if (Addr > 0xFFC)
{
DisplayError("There is a problem with:\nRSP_LW_DMEM");
return;
}
@ -273,35 +316,43 @@ void RSP_LW_DMEM ( uint32_t Addr, uint32_t * Value ) {
*Value = *(uint32_t *)(RSPInfo.DMEM + (Addr & 0xFFF));
}
void RSP_LW_IMEM ( uint32_t Addr, uint32_t * Value ) {
if ((Addr & 0x3) != 0) {
void RSP_LW_IMEM(uint32_t Addr, uint32_t * Value)
{
if ((Addr & 0x3) != 0)
{
DisplayError("Unaligned RSP_LW_IMEM");
}
*Value = *(uint32_t *)(RSPInfo.IMEM + (Addr & 0xFFF));
}
void RSP_SB_DMEM ( uint32_t Addr, uint8_t Value ) {
void RSP_SB_DMEM(uint32_t Addr, uint8_t Value)
{
*(uint8_t *)(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = Value;
}
void RSP_SBV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_SBV_DMEM(uint32_t Addr, int vect, int element)
{
*(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = RSP_Vect[vect].B[15 - element];
}
void RSP_SDV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_SDV_DMEM(uint32_t Addr, int vect, int element)
{
int Count;
for (Count = element; Count < (8 + element); Count ++ ){
for (Count = element; Count < (8 + element); Count++)
{
*(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = RSP_Vect[vect].B[15 - (Count & 0xF)];
Addr += 1;
}
}
void RSP_SFV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_SFV_DMEM(uint32_t Addr, int vect, int element)
{
int offset = Addr & 0xF;
Addr &= 0xFF0;
switch (element) {
switch (element)
{
case 0:
*(RSPInfo.DMEM + ((Addr + offset) ^ 3)) = (RSP_Vect[vect].UHW[7] >> 7) & 0xFF;
*(RSPInfo.DMEM + ((Addr + ((offset + 4) & 0xF)) ^ 3)) = (RSP_Vect[vect].UHW[6] >> 7) & 0xFF;
@ -401,15 +452,18 @@ void RSP_SFV_DMEM ( uint32_t Addr, int vect, int element ) {
}
}
void RSP_SH_DMEM ( uint32_t Addr, uint16_t Value ) {
if ((Addr & 0x1) != 0) {
void RSP_SH_DMEM(uint32_t Addr, uint16_t Value)
{
if ((Addr & 0x1) != 0)
{
DisplayError("Unaligned RSP_SH_DMEM");
return;
}
*(uint16_t *)(RSPInfo.DMEM + ((Addr ^ 2) & 0xFFF)) = Value;
}
void RSP_SHV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_SHV_DMEM(uint32_t Addr, int vect, int element)
{
*(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = (RSP_Vect[vect].UB[(15 - element) & 0xF] << 1) +
(RSP_Vect[vect].UB[(14 - element) & 0xF] >> 7);
*(RSPInfo.DMEM + (((Addr + 2) ^ 3) & 0xFFF)) = (RSP_Vect[vect].UB[(13 - element) & 0xF] << 1) +
@ -428,22 +482,29 @@ void RSP_SHV_DMEM ( uint32_t Addr, int vect, int element ) {
(RSP_Vect[vect].UB[(0 - element) & 0xF] >> 7);
}
void RSP_SLV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_SLV_DMEM(uint32_t Addr, int vect, int element)
{
int Count;
for (Count = element; Count < (4 + element); Count ++ ){
for (Count = element; Count < (4 + element); Count++)
{
*(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = RSP_Vect[vect].B[15 - (Count & 0xF)];
Addr += 1;
}
}
void RSP_SPV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_SPV_DMEM(uint32_t Addr, int vect, int element)
{
int Count;
for (Count = element; Count < (8 + element); Count ++ ){
if (((Count) & 0xF) < 8) {
for (Count = element; Count < (8 + element); Count++)
{
if (((Count)&0xF) < 8)
{
*(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = RSP_Vect[vect].UB[15 - ((Count & 0xF) << 1)];
} else {
}
else
{
*(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = (RSP_Vect[vect].UB[15 - ((Count & 0x7) << 1)] << 1) +
(RSP_Vect[vect].UB[14 - ((Count & 0x7) << 1)] >> 7);
}
@ -451,47 +512,56 @@ void RSP_SPV_DMEM ( uint32_t Addr, int vect, int element ) {
}
}
void RSP_SQV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_SQV_DMEM(uint32_t Addr, int vect, int element)
{
int length, Count;
length = ((Addr + 0x10) & ~0xF) - Addr;
for (Count = element; Count < (length + element); Count ++ ){
for (Count = element; Count < (length + element); Count++)
{
*(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = RSP_Vect[vect].B[15 - (Count & 0xF)];
Addr += 1;
}
}
void RSP_SRV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_SRV_DMEM(uint32_t Addr, int vect, int element)
{
int length, Count, offset;
length = (Addr & 0xF);
offset = (0x10 - length) & 0xF;
Addr &= 0xFF0;
for (Count = element; Count < (length + element); Count ++ ){
for (Count = element; Count < (length + element); Count++)
{
*(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = RSP_Vect[vect].B[15 - ((Count + offset) & 0xF)];
Addr += 1;
}
}
void RSP_SSV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_SSV_DMEM(uint32_t Addr, int vect, int element)
{
int Count;
for (Count = element; Count < (2 + element); Count ++ ){
for (Count = element; Count < (2 + element); Count++)
{
*(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = RSP_Vect[vect].B[15 - (Count & 0xF)];
Addr += 1;
}
}
void RSP_STV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_STV_DMEM(uint32_t Addr, int vect, int element)
{
int del, count, length;
length = 8;
if (length > 32 - vect) {
if (length > 32 - vect)
{
length = 32 - vect;
}
length = length << 1;
del = element >> 1;
for (count = 0; count < length; count += 2) {
for (count = 0; count < length; count += 2)
{
*(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = RSP_Vect[vect + del].UB[15 - count];
*(RSPInfo.DMEM + (((Addr + 1) ^ 3) & 0xFFF)) = RSP_Vect[vect + del].UB[14 - count];
del = (del + 1) & 7;
@ -499,24 +569,33 @@ void RSP_STV_DMEM ( uint32_t Addr, int vect, int element ) {
}
}
void RSP_SUV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_SUV_DMEM(uint32_t Addr, int vect, int element)
{
int Count;
for (Count = element; Count < (8 + element); Count ++ ){
if (((Count) & 0xF) < 8) {
for (Count = element; Count < (8 + element); Count++)
{
if (((Count)&0xF) < 8)
{
*(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = ((RSP_Vect[vect].UB[15 - ((Count & 0x7) << 1)] << 1) +
(RSP_Vect[vect].UB[14 - ((Count & 0x7) << 1)] >> 7)) & 0xFF;
} else {
(RSP_Vect[vect].UB[14 - ((Count & 0x7) << 1)] >> 7)) &
0xFF;
}
else
{
*(RSPInfo.DMEM + ((Addr ^ 3) & 0xFFF)) = RSP_Vect[vect].UB[15 - ((Count & 0x7) << 1)];
}
Addr += 1;
}
}
void RSP_SW_DMEM ( uint32_t Addr, uint32_t Value ) {
void RSP_SW_DMEM(uint32_t Addr, uint32_t Value)
{
Addr &= 0xFFF;
if ((Addr & 0x3) != 0) {
if (Addr > 0xFFC) {
if ((Addr & 0x3) != 0)
{
if (Addr > 0xFFC)
{
DisplayError("There is a problem with:\nRSP_SW_DMEM");
return;
}
@ -529,12 +608,14 @@ void RSP_SW_DMEM ( uint32_t Addr, uint32_t Value ) {
*(uint32_t *)(RSPInfo.DMEM + Addr) = Value;
}
void RSP_SWV_DMEM ( uint32_t Addr, int vect, int element ) {
void RSP_SWV_DMEM(uint32_t Addr, int vect, int element)
{
int Count, offset;
offset = Addr & 0xF;
Addr &= 0xFF0;
for (Count = element; Count < (16 + element); Count ++ ){
for (Count = element; Count < (16 + element); Count++)
{
*(RSPInfo.DMEM + ((Addr + (offset & 0xF)) ^ 3)) = RSP_Vect[vect].B[15 - (Count & 0xF)];
offset += 1;
}

3
Source/Script/clang.cmd
View File

@ -9,12 +9,15 @@ cd /d %origdir%
set ScanDir[0]="%base_dir%\Source\Common"
set ScanDir[1]="%base_dir%\Source\Project64"
set ScanDir[2]="%base_dir%\Source\Project64-core"
set ScanDir[3]="%base_dir%\Source\RSP"
set ScanFiles[0]="*.cpp"
set ScanFiles[1]="*.h"
set Exclude[0]="%base_dir%\Source\Project64-core\Version.h"
set Exclude[1]="%base_dir%\Source\Project64\UserInterface\resource.h"
set Exclude[2]="%base_dir%\Source\RSP\Version.h"
set Exclude[3]="%base_dir%\Source\RSP\resource.h"
set ValidParam=0
if "%1" == "check" set ValidParam=1