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

Clean up Patch.c a bit, and add a few fixmes to the code. 

git-svn-id: http://pcsx2-playground.googlecode.com/svn/trunk@253 a6443dda-0b58-4228-96e9-037be469359c
This commit is contained in:
arcum42 2008-10-31 12:23:19 +00:00 committed by Gregory Hainaut
parent bce2cfe5f1
commit 76f08e165e
8 changed files with 511 additions and 492 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
pcsx2/Elfheader.c
View File

@ -31,8 +31,8 @@
u32 ElfCRC; u32 ElfCRC;
typedef struct { typedef struct {
u8 e_ident[16]; //0x7f,"ELF" (ELF file identifier) u8 e_ident[16]; //0x7f,"ELF" (ELF file identifier)
u16 e_type; //ELF type: 0=NONE, 1=REL, 2=EXEC, 3=SHARED, 4=CORE u16 e_type; //ELF type: 0=NONE, 1=REL, 2=EXEC, 3=SHARED, 4=CORE
u16 e_machine; //Processor: 8=MIPS R3000 u16 e_machine; //Processor: 8=MIPS R3000
u32 e_version; //Version: 1=current u32 e_version; //Version: 1=current
u32 e_entry; //Entry point address u32 e_entry; //Entry point address
@ -72,7 +72,7 @@ notes1
typedef struct { typedef struct {
u32 sh_name; //No. to the index of the Section header stringtable index u32 sh_name; //No. to the index of the Section header stringtable index
u32 sh_type; //See notes2 u32 sh_type; //See notes2
u32 sh_flags; //see notes3 u32 sh_flags; //see notes3
u32 sh_addr; //Section start address u32 sh_addr; //Section start address
u32 sh_offset; //Offset from start of file to section u32 sh_offset; //Offset from start of file to section
@ -446,22 +446,6 @@ BOOL loadSectionHeaders( char * Exepath )
if ( elfSectH[i].sh_flags & 0x2 ) { if ( elfSectH[i].sh_flags & 0x2 ) {
//2002-09-19 (Florin) //2002-09-19 (Florin)
args_ptr = min( args_ptr, elfSectH[ i ].sh_addr & 0x1ffffff ); args_ptr = min( args_ptr, elfSectH[ i ].sh_addr & 0x1ffffff );
//---------------
/* if (elfSectH[i].sh_offset < elfsize) {
int size;
if ((elfSectH[i].sh_size + elfSectH[i].sh_offset) > elfsize) {
size = elfsize - elfSectH[i].sh_offset;
} else {
size = elfSectH[i].sh_size;
}
memcpy(&PS2MEM_BASE[ elfSectH[ i ].sh_addr &0x1ffffff ],
&elfdata[elfSectH[i].sh_offset],
size);
}
#ifdef ELF_LOG
ELF_LOG( "\t*LOADED*" );
#endif*/
} }
#ifdef ELF_LOG #ifdef ELF_LOG
ELF_LOG("\n"); ELF_LOG("\n");
@ -548,12 +532,7 @@ BOOL loadSectionHeaders( char * Exepath )
for ( i = 1; i < (int)( elfSectH[ i_st ].sh_size / sizeof( Elf32_Sym ) ); i++ ) { for ( i = 1; i < (int)( elfSectH[ i_st ].sh_size / sizeof( Elf32_Sym ) ); i++ ) {
if ( ( eS[ i ].st_value != 0 ) && ( ELF32_ST_TYPE( eS[ i ].st_info ) == 2 ) ) { if ( ( eS[ i ].st_value != 0 ) && ( ELF32_ST_TYPE( eS[ i ].st_info ) == 2 ) ) {
// SysPrintf("%x:%s\n", eS[i].st_value, &SymNames[eS[i].st_name]);
disR5900AddSym( eS[i].st_value, &SymNames[ eS[ i ].st_name ] ); disR5900AddSym( eS[i].st_value, &SymNames[ eS[ i ].st_name ] );
/* if (!strcmp(&SymNames[eS[i].st_name], "sceSifCheckStatRpc")) {
psMu32(eS[i].st_value & 0x1ffffff) = (0x3b << 26) | 1;
SysPrintf("found sceSifCheckStatRpc!!\n");
}*/
} }
} }
} }
@ -587,15 +566,9 @@ int loadElfFile(char *filename) {
if (elfdata == NULL) return -1; if (elfdata == NULL) return -1;
readFile(filename, (char*)elfdata, 0, elfsize); readFile(filename, (char*)elfdata, 0, elfsize);
/* {
FILE *f = fopen("game.elf", "wb");
fwrite(elfdata, 1, elfsize, f);
fclose(f);
}*/
//2002-09-19 (Florin) //2002-09-19 (Florin)
args_ptr = 0xFFFFFFFF; //big value, searching for minimum args_ptr = 0xFFFFFFFF; //big value, searching for minimum
//-------------------
loadHeaders( filename ); loadHeaders( filename );
cpuRegs.pc = elfHeader->e_entry; //set pc to proper place cpuRegs.pc = elfHeader->e_entry; //set pc to proper place
loadProgramHeaders( filename ); loadProgramHeaders( filename );
@ -609,7 +582,6 @@ int loadElfFile(char *filename) {
//2002-09-19 (Florin) //2002-09-19 (Florin)
cpuRegs.GPR.n.a0.UL[0] = parseCommandLine( filename ); cpuRegs.GPR.n.a0.UL[0] = parseCommandLine( filename );
//---------------
for ( i = 0; i < 0x100000; i++ ) { for ( i = 0; i < 0x100000; i++ ) {
if ( strcmp( "rom0:OSDSYS", (char*)PSM( i ) ) == 0 ) { if ( strcmp( "rom0:OSDSYS", (char*)PSM( i ) ) == 0 ) {
@ -652,50 +624,55 @@ int loadElfFile(char *filename) {
extern int g_FFXHack; extern int g_FFXHack;
extern int path3hack; extern int path3hack;
int g_VUGameFixes = 0; int g_VUGameFixes = 0;
void LoadGameSpecificSettings()
// fixme - this should be moved to patches or eliminated
void LoadGameSpecificSettings()
{ {
// default // default
g_VUGameFixes = 0; g_VUGameFixes = 0;
g_FFXHack = 0; g_FFXHack = 0;
switch(ElfCRC) { switch(ElfCRC) {
case 0x0c414549: // spacefisherman, missing gfx // The code involving VUFIX_SIGNEDZERO & VUFIX_EXTRAFLAGS
g_VUGameFixes |= VUFIX_SIGNEDZERO; // is no longer in pcsx2.
break;
case 0x4C9EE7DF: // crazy taxi (u) //case 0x0c414549: // spacefisherman, missing gfx
case 0xC9C145BF: // crazy taxi, missing gfx // g_VUGameFixes |= VUFIX_SIGNEDZERO;
g_VUGameFixes |= VUFIX_EXTRAFLAGS; // break;
break; //case 0x4C9EE7DF: // crazy taxi (u)
//case 0xC9C145BF: // crazy taxi, missing gfx
// g_VUGameFixes |= VUFIX_EXTRAFLAGS;
// break;
case 0xb99379b7: // erementar gerad (discolored chars) case 0xb99379b7: // erementar gerad (discolored chars)
g_VUGameFixes |= VUFIX_XGKICKDELAY2; g_VUGameFixes |= VUFIX_XGKICKDELAY2;
break; break;
case 0xa08c4057: //Sprint Cars (SLUS) case 0xa08c4057: //Sprint Cars (SLUS)
case 0x8b0725d5: //Flinstones Bedrock Racing (SLES) case 0x8b0725d5: //Flinstones Bedrock Racing (SLES)
path3hack = 1; path3hack = 1; // We can move this to patch files right now
break; break;
case 0x6a4efe60: // ffx(j) case 0x6a4efe60: // ffx(j)
case 0xA39517AB: // ffx(e) case 0xA39517AB: // ffx(e)
case 0xBB3D833A: // ffx(u) case 0xBB3D833A: // ffx(u)
case 0x941bb7d9: // ffx(g) case 0x941bb7d9: // ffx(g)
case 0xD9FC6310: // ffx int(j) case 0xD9FC6310: // ffx int(j)
case 0xa39517ae: // ffx(f) case 0xa39517ae: // ffx(f)
case 0xa39517a9: // ffx(i) case 0xa39517a9: // ffx(i)
case 0x658597e2: // ffx int case 0x658597e2: // ffx int
case 0x941BB7DE: // ffx(s) case 0x941BB7DE: // ffx(s)
case 0x3866CA7E: // ffx(asia) case 0x3866CA7E: // ffx(asia)
case 0x48FE0C71: // ffx2 (u) case 0x48FE0C71: // ffx2 (u)
case 0x9aac530d: // ffx2 (g) case 0x9aac530d: // ffx2 (g)
case 0x9AAC5309: // ffx2 (e) case 0x9AAC5309: // ffx2 (e)
case 0x8A6D7F14: // ffx2 (j) case 0x8A6D7F14: // ffx2 (j)
case 0x9AAC530B: // ffx2 (i) case 0x9AAC530B: // ffx2 (i)
case 0x9AAC530A: // ffx2 (f) case 0x9AAC530A: // ffx2 (f)
case 0xe1fd9a2d: // ffx2 last mission (?) case 0xe1fd9a2d: // ffx2 last mission (?)
case 0x93f9b89a: // ffx2 demo (g) case 0x93f9b89a: // ffx2 demo (g)
case 0x304C115C: // harvest moon - awl case 0x304C115C: // harvest moon - awl
case 0xF0A6D880: // harvest moon - sth case 0xF0A6D880: // harvest moon - sth
g_FFXHack = 1; g_FFXHack = 1;
break; break;
} }
} }

2
pcsx2/Misc.h
View File

@ -344,6 +344,7 @@ extern __forceinline long InterlockedExchange(long volatile* Target, long Value)
__asm__ __volatile__(".intel_syntax\n" __asm__ __volatile__(".intel_syntax\n"
"lock xchg [%0], %%eax\n" "lock xchg [%0], %%eax\n"
".att_syntax\n" : : "r"(Target), "a"(Value) : "memory" ); ".att_syntax\n" : : "r"(Target), "a"(Value) : "memory" );
return 0; // The only function that even looks at this is a debugging function
} }
extern __forceinline long InterlockedExchangeAdd(long volatile* Addend, long Value) extern __forceinline long InterlockedExchangeAdd(long volatile* Addend, long Value)
@ -351,6 +352,7 @@ extern __forceinline long InterlockedExchangeAdd(long volatile* Addend, long Val
__asm__ __volatile__(".intel_syntax\n" __asm__ __volatile__(".intel_syntax\n"
"lock xadd [%0], %%eax\n" "lock xadd [%0], %%eax\n"
".att_syntax\n" : : "r"(Addend), "a"(Value) : "memory" ); ".att_syntax\n" : : "r"(Addend), "a"(Value) : "memory" );
return 0; // The return value is never looked at.
} }
#endif #endif

825
pcsx2/Patch.c
View File

@ -15,7 +15,7 @@
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/ */
// //
// Includes // Includes
// //
@ -24,8 +24,9 @@
#include "PsxCommon.h" #include "PsxCommon.h"
#include "Paths.h" #include "Paths.h"
#include "Patch.h"
#include "VU.h"
#ifdef _WIN32 #ifdef _WIN32
#include "windows/cheats/cheats.h" #include "windows/cheats/cheats.h"
@ -38,74 +39,8 @@
#pragma warning(disable:4996) //ignore the stricmp deprecated warning #pragma warning(disable:4996) //ignore the stricmp deprecated warning
#endif #endif
#include "Patch.h"
int g_ZeroGSOptions=0;
//
// Variables
//
PatchTextTable commands[] =
{
{ "comment", 1, patchFunc_comment },
{ "gametitle", 2, patchFunc_gametitle },
{ "patch", 3, patchFunc_patch },
{ "fastmemory", 4, patchFunc_fastmemory }, // enable for faster but bugger mem (mvc2 is faster)
{ "roundmode", 5, patchFunc_roundmode }, // changes rounding mode for floating point
// syntax: roundmode=X,Y
// possible values for X,Y: NEAR, DOWN, UP, CHOP
// X - EE rounding mode (default is NEAR)
// Y - VU rounding mode (default is CHOP)
{ "zerogs", 6, patchFunc_zerogs }, // zerogs=hex
{ "path3hack", 7, patchFunc_path3hack },
{ "vunanmode",8, patchFunc_vunanmode },
{ "", 0, NULL }
};
PatchTextTable dataType[] =
{
{ "byte", 1, NULL },
{ "short", 2, NULL },
{ "word", 3, NULL },
{ "double", 4, NULL },
{ "extended", 5, NULL },
{ "", 0, NULL }
};
PatchTextTable cpuCore[] =
{
{ "EE", 1, NULL },
{ "IOP", 2, NULL },
{ "", 0, NULL }
};
IniPatch patch[ MAX_PATCH ]; IniPatch patch[ MAX_PATCH ];
int patchnumber;
//
// Function Implementations
//
int PatchTableExecute( char * text1, char * text2, PatchTextTable * Table )
{
int i = 0;
while ( Table[ i ].text[ 0 ] )
{
if ( !strcmp( Table[ i ].text, text1 ) )
{
if ( Table[ i ].func )
{
Table[ i ].func( text1, text2 );
}
break;
}
i++;
}
return Table[ i ].code;
}
u32 SkipCount=0; u32 SkipCount=0;
u32 IterationCount=0; u32 IterationCount=0;
u32 IterationIncrement=0; u32 IterationIncrement=0;
@ -114,226 +49,298 @@ u32 PrevCheatType=0;
u32 PrevCheataddr = 0; u32 PrevCheataddr = 0;
u32 LastType = 0; u32 LastType = 0;
int g_ZeroGSOptions=0;
int patchnumber;
extern int RunExe;
char strgametitle[256]= {0};
//
// Variables
//
PatchTextTable commands[] =
{
{ "comment", 1, patchFunc_comment },
{ "gametitle", 2, patchFunc_gametitle },
{ "patch", 3, patchFunc_patch },
{ "fastmemory", 4, patchFunc_fastmemory }, // enable for faster but bugger mem (mvc2 is faster)
{ "roundmode", 5, patchFunc_roundmode }, // changes rounding mode for floating point
// syntax: roundmode=X,Y
// possible values for X,Y: NEAR, DOWN, UP, CHOP
// X - EE rounding mode (default is NEAR)
// Y - VU rounding mode (default is CHOP)
{ "zerogs", 6, patchFunc_zerogs }, // zerogs=hex
{ "path3hack", 7, patchFunc_path3hack },
{ "vunanmode",8, patchFunc_vunanmode },
{ "ffxhack",9, patchFunc_ffxhack},
{ "xkickdelay",10, patchFunc_xkickdelay},
{ "", 0, NULL }
};
PatchTextTable dataType[] =
{
{ "byte", 1, NULL },
{ "short", 2, NULL },
{ "word", 3, NULL },
{ "double", 4, NULL },
{ "extended", 5, NULL },
{ "", 0, NULL }
};
PatchTextTable cpuCore[] =
{
{ "EE", 1, NULL },
{ "IOP", 2, NULL },
{ "", 0, NULL }
};
//
// Function Implementations
//
int PatchTableExecute( char * text1, char * text2, PatchTextTable * Table )
{
int i = 0;
while ( Table[ i ].text[ 0 ] )
{
if ( !strcmp( Table[ i ].text, text1 ) )
{
if ( Table[ i ].func )
{
Table[ i ].func( text1, text2 );
}
break;
}
i++;
}
return Table[ i ].code;
}
void _applypatch(int place, IniPatch *p) { void _applypatch(int place, IniPatch *p) {
u32 Cheataddr = 0;
u8 u8Val=0; u8 u8Val=0;
u16 u16Val=0; u16 u16Val=0;
u32 u32Val=0; u32 u32Val=0;
u32 i; u32 i;
if (p->placetopatch != place) return; if (p->placetopatch != place) return;
if (p->enabled == 0) return; if (p->enabled == 0) return;
if (p->cpu == 1) { //EE switch (p->cpu) {
if (p->type == 1) { //byte case EE:
memWrite8(p->addr, (u8)p->data); switch (p->type) {
} else case BYTE_T:
if (p->type == 2) { //short memWrite8(p->addr, (u8)p->data);
memWrite16(p->addr, (u16)p->data); break;
} else case SHORT_T:
if (p->type == 3) { //word memWrite16(p->addr, (u16)p->data);
memWrite32(p->addr, (u32)p->data); break;
} else case WORD_T:
if (p->type == 4) { //double memWrite32(p->addr, (u32)p->data);
memWrite64(p->addr, p->data); break;
} case DOUBLE_T:
if (p->type == 5) { //extended memWrite64(p->addr, p->data);
break;
if (SkipCount > 0){ case EXTENDED_T:
SkipCount--; if (SkipCount > 0){
}else if (PrevCheatType == 0x3040) { // vvvvvvvv 00000000 Inc SkipCount--;
memRead32(PrevCheataddr,&u32Val); }
memWrite32(PrevCheataddr, u32Val+(p->addr)); else switch (PrevCheatType) {
PrevCheatType = 0; case 0x3040: // vvvvvvvv 00000000 Inc
}else if (PrevCheatType == 0x3050){ // vvvvvvvv 00000000 Dec memRead32(PrevCheataddr,&u32Val);
memRead32(PrevCheataddr,&u32Val); memWrite32(PrevCheataddr, u32Val+(p->addr));
memWrite32(PrevCheataddr, u32Val-(p->addr)); PrevCheatType = 0;
PrevCheatType = 0; break;
}else if (PrevCheatType == 0x4000){ // vvvvvvvv iiiiiiii case 0x3050: // vvvvvvvv 00000000 Dec
for(i=0;i<IterationCount;i++) memRead32(PrevCheataddr,&u32Val);
memWrite32((u32)(PrevCheataddr+(i*IterationIncrement)),(u32)((u32)p->addr+((u32)p->data*i))); memWrite32(PrevCheataddr, u32Val-(p->addr));
PrevCheatType = 0; PrevCheatType = 0;
}else if (PrevCheatType == 0x5000){ // dddddddd iiiiiiii break;
for(i=0;i<IterationCount;i++){ case 0x4000: // vvvvvvvv iiiiiiii
memRead8(PrevCheataddr+i,&u8Val); for(i=0;i<IterationCount;i++)
memWrite8(((u32)p->data)+i,u8Val); memWrite32((u32)(PrevCheataddr+(i*IterationIncrement)),(u32)(p->addr+((u32)p->data*i)));
} PrevCheatType = 0;
PrevCheatType = 0; break;
}else if (PrevCheatType == 0x6000){ // 000Xnnnn iiiiiiii case 0x5000: // dddddddd iiiiiiii
// Get Number of pointers for(i=0;i<IterationCount;i++){
if (IterationCount == 0) memRead8(PrevCheataddr+i,&u8Val);
IterationCount = (u32)p->addr&0x0000FFFF; memWrite8(((u32)p->data)+i,u8Val);
}
PrevCheatType = 0;
break;
case 0x6000: // 000Xnnnn iiiiiiii
// Get Number of pointers
if (IterationCount == 0)
IterationCount = (u32)p->addr&0x0000FFFF;
// Read first pointer // Read first pointer
LastType = ((u32)p->addr&0x000F0000)/0x10000; LastType = ((u32)p->addr&0x000F0000)/0x10000;
memRead32(PrevCheataddr,&u32Val); memRead32(PrevCheataddr,&u32Val);
PrevCheataddr =u32Val+(u32)p->data; PrevCheataddr = u32Val+(u32)p->data;
IterationCount--; IterationCount--;
// Check if needed to read another pointer // Check if needed to read another pointer
if (IterationCount == 0){ if (IterationCount == 0){
PrevCheatType = 0; PrevCheatType = 0;
if (LastType==0x0) if (LastType==0x0)
memWrite8(PrevCheataddr,IterationIncrement&0xFF); memWrite8(PrevCheataddr,IterationIncrement&0xFF);
if (LastType==0x1) if (LastType==0x1)
memWrite16(PrevCheataddr,IterationIncrement&0xFFFF); memWrite16(PrevCheataddr,IterationIncrement&0xFFFF);
if (LastType==0x2) if (LastType==0x2)
memWrite32(PrevCheataddr,IterationIncrement); memWrite32(PrevCheataddr,IterationIncrement);
}else{ }
PrevCheatType = 0x6001; else
} PrevCheatType = 0x6001;
case 0x6001: // 000Xnnnn iiiiiiii
}else if (PrevCheatType == 0x6001){ // 000Xnnnn iiiiiiii // Read first pointer
memRead32(PrevCheataddr,&u32Val);
// Read first pointer PrevCheataddr =u32Val+(u32)p->addr;
memRead32(PrevCheataddr,&u32Val); IterationCount--;
PrevCheataddr =u32Val+(u32)p->addr;
IterationCount--;
// Check if needed to read another pointer // Check if needed to read another pointer
if (IterationCount == 0){ if (IterationCount == 0){
PrevCheatType = 0; PrevCheatType = 0;
if (LastType==0x0) if (LastType==0x0)
memWrite8(PrevCheataddr,IterationIncrement&0xFF); memWrite8(PrevCheataddr,IterationIncrement&0xFF);
if (LastType==0x1) if (LastType==0x1)
memWrite16(PrevCheataddr,IterationIncrement&0xFFFF); memWrite16(PrevCheataddr,IterationIncrement&0xFFFF);
if (LastType==0x2) if (LastType==0x2)
memWrite32(PrevCheataddr,IterationIncrement); memWrite32(PrevCheataddr,IterationIncrement);
}else{ }
memRead32(PrevCheataddr,&u32Val); else
PrevCheataddr =u32Val+(u32)p->data; {
IterationCount--; memRead32(PrevCheataddr,&u32Val);
if (IterationCount == 0){ PrevCheataddr =u32Val+(u32)p->data;
PrevCheatType = 0; IterationCount--;
if (LastType==0x0) if (IterationCount == 0){
memWrite8(PrevCheataddr,IterationIncrement&0xFF); PrevCheatType = 0;
if (LastType==0x1) if (LastType==0x0)
memWrite16(PrevCheataddr,IterationIncrement&0xFFFF); memWrite8(PrevCheataddr,IterationIncrement&0xFF);
if (LastType==0x2) if (LastType==0x1)
memWrite32(PrevCheataddr,IterationIncrement); memWrite16(PrevCheataddr,IterationIncrement&0xFFFF);
} if (LastType==0x2)
memWrite32(PrevCheataddr,IterationIncrement);
}
}
default:
if ((p->addr&0xF0000000) == 0x00000000){ // 0aaaaaaa 0000000vv
memWrite8(p->addr&0x0FFFFFFF, (u8)p->data&0x000000FF);
PrevCheatType = 0;
}
else if ((p->addr&0xF0000000) == 0x10000000){ // 0aaaaaaa 0000vvvv
memWrite16(p->addr&0x0FFFFFFF, (u16)p->data&0x0000FFFF);
PrevCheatType = 0;
}
else if ((p->addr&0xF0000000) == 0x20000000){ // 0aaaaaaa vvvvvvvv
memWrite32(p->addr&0x0FFFFFFF, (u32)p->data);
PrevCheatType = 0;
}
else if ((p->addr&0xFFFF0000) == 0x30000000){ // 300000vv 0aaaaaaa Inc
memRead8((u32)p->data,&u8Val);
memWrite8((u32)p->data, u8Val+(p->addr&0x000000FF));
PrevCheatType = 0;
}
else if ((p->addr&0xFFFF0000) == 0x30100000){ // 301000vv 0aaaaaaa Dec
memRead8((u32)p->data,&u8Val);
memWrite8((u32)p->data, u8Val-(p->addr&0x000000FF));
PrevCheatType = 0;
}
else if ((p->addr&0xFFFF0000) == 0x30200000){ // 3020vvvv 0aaaaaaa Inc
memRead16((u32)p->data,&u16Val);
memWrite16((u32)p->data, u16Val+(p->addr&0x0000FFFF));
PrevCheatType = 0;
}
else if ((p->addr&0xFFFF0000) == 0x30300000){ // 3030vvvv 0aaaaaaa Dec
memRead16((u32)p->data,&u16Val);
memWrite16((u32)p->data, u16Val-(p->addr&0x0000FFFF));
PrevCheatType = 0;
}
else if ((p->addr&0xFFFF0000) == 0x30400000){ // 30400000 0aaaaaaa Inc + Another line
PrevCheatType= 0x3040;
PrevCheataddr= (u32)p->data;
}
else if ((p->addr&0xFFFF0000) == 0x30500000){ // 30500000 0aaaaaaa Inc + Another line
PrevCheatType= 0x3050;
PrevCheataddr= (u32)p->data;
}
else if ((p->addr&0xF0000000) == 0x40000000){ // 4aaaaaaa nnnnssss + Another line
IterationCount=((u32)p->data&0xFFFF0000)/0x10000;
IterationIncrement=((u32)p->data&0x0000FFFF)*4;
PrevCheataddr=(u32)p->addr&0x0FFFFFFF;
PrevCheatType= 0x4000;
}
else if ((p->addr&0xF0000000) == 0x50000000){ // 5sssssss nnnnnnnn + Another line
PrevCheataddr = (u32)p->addr&0x0FFFFFFF;
IterationCount=((u32)p->data);
PrevCheatType= 0x5000;
}
else if ((p->addr&0xF0000000) == 0x60000000){ // 6aaaaaaa 000000vv + Another line/s
PrevCheataddr = (u32)p->addr&0x0FFFFFFF;
IterationIncrement=((u32)p->data);
IterationCount=0;
PrevCheatType= 0x6000;
}
else if ((p->addr&0xF0000000) == 0x70000000) {
if ((p->data&0x00F00000) == 0x00000000){ // 7aaaaaaa 000000vv
memRead8((u32)p->addr&0x0FFFFFFF,&u8Val);
memWrite8((u32)p->addr&0x0FFFFFFF,(u8)(u8Val|(p->data&0x000000FF)));
}else if ((p->data&0x00F00000) == 0x00100000){ // 7aaaaaaa 0010vvvv
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
memWrite16((u32)p->addr&0x0FFFFFFF,(u16)(u16Val|(p->data&0x0000FFFF)));
}else if ((p->data&0x00F00000) == 0x00200000){ // 7aaaaaaa 002000vv
memRead8((u32)p->addr&0x0FFFFFFF,&u8Val);
memWrite8((u32)p->addr&0x0FFFFFFF,(u8)(u8Val&(p->data&0x000000FF)));
}else if ((p->data&0x00F00000) == 0x00300000){ // 7aaaaaaa 0030vvvv
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
memWrite16((u32)p->addr&0x0FFFFFFF,(u16)(u16Val&(p->data&0x0000FFFF)));
}else if ((p->data&0x00F00000) == 0x00400000){ // 7aaaaaaa 004000vv
memRead8((u32)p->addr&0x0FFFFFFF,&u8Val);
memWrite8((u32)p->addr&0x0FFFFFFF,(u8)(u8Val^(p->data&0x000000FF)));
}else if ((p->data&0x00F00000) == 0x00500000){ // 7aaaaaaa 0050vvvv
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
memWrite16((u32)p->addr&0x0FFFFFFF,(u16)(u16Val^(p->data&0x0000FFFF)));
}
}
else if (p->addr < 0xE0000000) {
if ((((u32)p->data & 0xFFFF0000)==0x00000000) ||
(((u32)p->data & 0xFFFF0000)==0x00100000) ||
(((u32)p->data & 0xFFFF0000)==0x00200000) ||
(((u32)p->data & 0xFFFF0000)==0x00300000)) {
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
if (u16Val != (0x0000FFFF&(u32)p->data))
SkipCount = 1;
PrevCheatType= 0;
}
}
else if (p->addr < 0xF0000000) {
if ((((u32)p->data&0xF0000000)==0x00000000) ||
(((u32)p->data&0xF0000000)==0x10000000) ||
(((u32)p->data&0xF0000000)==0x20000000) ||
(((u32)p->data&0xF0000000)==0x30000000)) {
memRead16((u32)p->data&0x0FFFFFFF,&u16Val);
if (u16Val != (0x0000FFFF&(u32)p->addr))
SkipCount = ((u32)p->addr&0xFFF0000)/0x10000;
PrevCheatType= 0;
}
} }
}else if ((p->addr&0xF0000000) == 0x00000000){ // 0aaaaaaa 0000000vv
memWrite8(p->addr&0x0FFFFFFF, (u8)p->data&0x000000FF);
PrevCheatType = 0;
}else if ((p->addr&0xF0000000) == 0x10000000){ // 0aaaaaaa 0000vvvv
memWrite16(p->addr&0x0FFFFFFF, (u16)p->data&0x0000FFFF);
PrevCheatType = 0;
}else if ((p->addr&0xF0000000) == 0x20000000){ // 0aaaaaaa vvvvvvvv
memWrite32(p->addr&0x0FFFFFFF, (u32)p->data);
PrevCheatType = 0;
}else if ((p->addr&0xFFFF0000) == 0x30000000){ // 300000vv 0aaaaaaa Inc
memRead8((u32)p->data,&u8Val);
memWrite8((u32)p->data, u8Val+(p->addr&0x000000FF));
PrevCheatType = 0;
}else if ((p->addr&0xFFFF0000) == 0x30100000){ // 301000vv 0aaaaaaa Dec
memRead8((u32)p->data,&u8Val);
memWrite8((u32)p->data, u8Val-(p->addr&0x000000FF));
PrevCheatType = 0;
}else if ((p->addr&0xFFFF0000) == 0x30200000){ // 3020vvvv 0aaaaaaa Inc
memRead16((u32)p->data,&u16Val);
memWrite16((u32)p->data, u16Val+(p->addr&0x0000FFFF));
PrevCheatType = 0;
}else if ((p->addr&0xFFFF0000) == 0x30300000){ // 3030vvvv 0aaaaaaa Dec
memRead16((u32)p->data,&u16Val);
memWrite16((u32)p->data, u16Val-(p->addr&0x0000FFFF));
PrevCheatType = 0;
}else if ((p->addr&0xFFFF0000) == 0x30400000){ // 30400000 0aaaaaaa Inc + Another line
PrevCheatType= 0x3040;
PrevCheataddr= (u32)p->data;
}else if ((p->addr&0xFFFF0000) == 0x30500000){ // 30500000 0aaaaaaa Inc + Another line
PrevCheatType= 0x3050;
PrevCheataddr= (u32)p->data;
}else if ((p->addr&0xF0000000) == 0x40000000){ // 4aaaaaaa nnnnssss + Another line
IterationCount=((u32)p->data&0xFFFF0000)/0x10000;
IterationIncrement=((u32)p->data&0x0000FFFF)*4;
PrevCheataddr=(u32)p->addr&0x0FFFFFFF;
PrevCheatType= 0x4000;
}else if ((p->addr&0xF0000000) == 0x50000000){ // 5sssssss nnnnnnnn + Another line
PrevCheataddr = (u32)p->addr&0x0FFFFFFF;
IterationCount=((u32)p->data);
PrevCheatType= 0x5000;
}else if ((p->addr&0xF0000000) == 0x60000000){ // 6aaaaaaa 000000vv + Another line/s
PrevCheataddr = (u32)p->addr&0x0FFFFFFF;
IterationIncrement=((u32)p->data);
IterationCount=0;
PrevCheatType= 0x6000;
}else if (((p->addr&0xF0000000) == 0x70000000)&&((p->data&0x00F00000) == 0x00000000)){ // 7aaaaaaa 000000vv
memRead8((u32)p->addr&0x0FFFFFFF,&u8Val);
memWrite8((u32)p->addr&0x0FFFFFFF,(u8)(u8Val|(p->data&0x000000FF)));
}else if (((p->addr&0xF0000000) == 0x70000000)&&((p->data&0x00F00000) == 0x00100000)){ // 7aaaaaaa 0010vvvv
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
memWrite16((u32)p->addr&0x0FFFFFFF,(u16)(u16Val|(p->data&0x0000FFFF)));
}else if (((p->addr&0xF0000000) == 0x70000000)&&((p->data&0x00F00000) == 0x00200000)){ // 7aaaaaaa 002000vv
memRead8((u32)p->addr&0x0FFFFFFF,&u8Val);
memWrite8((u32)p->addr&0x0FFFFFFF,(u8)(u8Val&(p->data&0x000000FF)));
}else if (((p->addr&0xF0000000) == 0x70000000)&&((p->data&0x00F00000) == 0x00300000)){ // 7aaaaaaa 0030vvvv
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
memWrite16((u32)p->addr&0x0FFFFFFF,(u16)(u16Val&(p->data&0x0000FFFF)));
}else if (((p->addr&0xF0000000) == 0x70000000)&&((p->data&0x00F00000) == 0x00400000)){ // 7aaaaaaa 004000vv
memRead8((u32)p->addr&0x0FFFFFFF,&u8Val);
memWrite8((u32)p->addr&0x0FFFFFFF,(u8)(u8Val^(p->data&0x000000FF)));
}else if (((p->addr&0xF0000000) == 0x70000000)&&((p->data&0x00F00000) == 0x00500000)){ // 7aaaaaaa 0050vvvv
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
memWrite16((u32)p->addr&0x0FFFFFFF,(u16)(u16Val^(p->data&0x0000FFFF)));
}else if ((p->addr < 0xE0000000)&&(((u32)p->data&0xFFFF0000)==0x00000000)){
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
if (u16Val != (0x0000FFFF&(u32)p->data))
SkipCount = 1;
PrevCheatType= 0;
}else if ((p->addr < 0xE0000000)&&(((u32)p->data&0xFFFF0000)==0x00100000)){
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
if (u16Val == (0x0000FFFF&(u32)p->data))
SkipCount = 1;
PrevCheatType= 0;
}else if ((p->addr < 0xE0000000)&&(((u32)p->data&0xFFFF0000)==0x00200000)){
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
if (u16Val <= (0x0000FFFF&(u32)p->data))
SkipCount = 1;
PrevCheatType= 0;
}else if ((p->addr < 0xE0000000)&&(((u32)p->data&0xFFFF0000)==0x00300000)){
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
if (u16Val >= (0x0000FFFF&(u32)p->data))
SkipCount = 1;
PrevCheatType= 0;
}else if ((p->addr < 0xF0000000)&&(((u32)p->data&0xF0000000)==0x00000000)){
memRead16((u32)p->data&0x0FFFFFFF,&u16Val);
if (u16Val != (0x0000FFFF&(u32)p->addr))
SkipCount = ((u32)p->addr&0xFFF0000)/0x10000;
PrevCheatType= 0;
}else if ((p->addr < 0xF0000000)&&(((u32)p->data&0xF0000000)==0x10000000)){
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
if (u16Val == (0x0000FFFF&(u32)p->data))
SkipCount = ((u32)p->addr&0xFFF0000)/0x10000;
PrevCheatType= 0;
}else if ((p->addr < 0xF0000000)&&(((u32)p->data&0xF0000000)==0x20000000)){
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
if (u16Val <= (0x0000FFFF&(u32)p->data))
SkipCount = ((u32)p->addr&0xFFF0000)/0x10000;
PrevCheatType= 0;
}else if ((p->addr < 0xF0000000)&&(((u32)p->data&0xF0000000)==0x30000000)){
memRead16((u32)p->addr&0x0FFFFFFF,&u16Val);
if (u16Val >= (0x0000FFFF&(u32)p->data))
SkipCount = ((u32)p->addr&0xFFF0000)/0x10000;
PrevCheatType= 0;
} }
} }
} else break;
if (p->cpu == 2) { //IOP case IOP: {
if (p->type == 1) { //byte switch (p->type) {
psxMemWrite8(p->addr, (u8)p->data); case BYTE_T:
} else psxMemWrite8(p->addr, (u8)p->data);
if (p->type == 2) { //short break;
psxMemWrite16(p->addr, (u16)p->data); case SHORT_T:
} else psxMemWrite16(p->addr, (u16)p->data);
if (p->type == 3) { //word break;
psxMemWrite32(p->addr, (u32)p->data); case WORD_T:
psxMemWrite32(p->addr, (u32)p->data);
break;
} }
} }
}
} }
@ -352,10 +359,9 @@ void applypatch(int place) {
void patchFunc_comment( char * text1, char * text2 ) void patchFunc_comment( char * text1, char * text2 )
{ {
SysPrintf( "comment: %s \n", text2 ); SysPrintf( "comment: %s \n", text2 );
} }
char strgametitle[256] = {0};
void patchFunc_gametitle( char * text1, char * text2 ) void patchFunc_gametitle( char * text1, char * text2 )
{ {
@ -366,180 +372,176 @@ void patchFunc_gametitle( char * text1, char * text2 )
#endif #endif
} }
extern int RunExe;
void patchFunc_patch( char * cmd, char * param ) void patchFunc_patch( char * cmd, char * param )
{ {
//patch=placetopatch,cpucore,address,type,data char * pText;
char * pText;
if ( patchnumber >= MAX_PATCH ) if ( patchnumber >= MAX_PATCH )
{ {
SysPrintf( "Patch ERROR: Maximum number of patches reached: %s=%s\n", cmd, param ); SysPrintf( "Patch ERROR: Maximum number of patches reached: %s=%s\n", cmd, param );
return; return;
}
pText = strtok( param, "," );
pText = param;
// inifile_trim( pText );
if(RunExe == 1) patch[ patchnumber ].placetopatch = 1;
else patch[ patchnumber ].placetopatch = strtol( pText, (char **)NULL, 0 );
pText = strtok( NULL, "," );
inifile_trim( pText );
patch[ patchnumber ].cpu = PatchTableExecute( pText, NULL, cpuCore );
if ( patch[ patchnumber ].cpu == 0 )
{
SysPrintf( "Unrecognized patch '%s'\n", pText );
return;
} }
pText = strtok( NULL, "," ); pText = strtok( param, "," );
inifile_trim( pText ); pText = param;
sscanf( pText, "%X", &patch[ patchnumber ].addr );
pText = strtok( NULL, "," ); if(RunExe == 1)
inifile_trim( pText ); patch[ patchnumber ].placetopatch = 1;
patch[ patchnumber ].type = PatchTableExecute( pText, NULL, dataType ); else
patch[ patchnumber ].placetopatch = strtol( pText, (char **)NULL, 0 );
pText = strtok( NULL, "," );
inifile_trim( pText );
patch[ patchnumber ].cpu = PatchTableExecute( pText, NULL, cpuCore );
if ( patch[ patchnumber ].cpu == 0 )
{
SysPrintf( "Unrecognized patch '%s'\n", pText );
return;
}
pText = strtok( NULL, "," );
inifile_trim( pText );
sscanf( pText, "%X", &patch[ patchnumber ].addr );
pText = strtok( NULL, "," );
inifile_trim( pText );
patch[ patchnumber ].type = PatchTableExecute( pText, NULL, dataType );
if ( patch[ patchnumber ].type == 0 ) if ( patch[ patchnumber ].type == 0 )
{ {
SysPrintf( "Unrecognized patch '%s'\n", pText ); SysPrintf( "Unrecognized patch '%s'\n", pText );
return; return;
} }
pText = strtok( NULL, "," ); pText = strtok( NULL, "," );
inifile_trim( pText ); inifile_trim( pText );
sscanf( pText, "%I64X", &patch[ patchnumber ].data ); sscanf( pText, "%I64X", &patch[ patchnumber ].data );
patch[ patchnumber ].enabled = 1; patch[ patchnumber ].enabled = 1;
patchnumber++; patchnumber++;
} }
//this routine is for execute the commands of the ini file //this routine is for executing the commands of the ini file
void inifile_command( char * cmd ) void inifile_command( char * cmd )
{ {
int code; int code;
char command[ 256 ]; char command[ 256 ];
char parameter[ 256 ]; char parameter[ 256 ];
// extract param part (after '=') // extract param part (after '=')
char * pEqual = strchr( cmd, '=' ); char * pEqual = strchr( cmd, '=' );
if ( ! pEqual ) if ( ! pEqual )
{ {
// fastmemory doesn't have = // fastmemory doesn't have =
pEqual = cmd+strlen(cmd); pEqual = cmd+strlen(cmd);
// SysPrintf( "Ini file ERROR: unknow line: %s \n", cmd ); }
// return;
}
memset( command, 0, sizeof( command ) ); memset( command, 0, sizeof( command ) );
memset( parameter, 0, sizeof( parameter ) ); memset( parameter, 0, sizeof( parameter ) );
strncpy( command, cmd, pEqual - cmd ); strncpy( command, cmd, pEqual - cmd );
strncpy( parameter, pEqual + 1, sizeof( parameter ) ); strncpy( parameter, pEqual + 1, sizeof( parameter ) );
inifile_trim( command ); inifile_trim( command );
inifile_trim( parameter ); inifile_trim( parameter );
code = PatchTableExecute( command, parameter, commands ); code = PatchTableExecute( command, parameter, commands );
} }
void inifile_trim( char * buffer ) void inifile_trim( char * buffer )
{ {
char * pInit = buffer; char * pInit = buffer;
char * pEnd = NULL; char * pEnd = NULL;
while ( ( *pInit == ' ' ) || ( *pInit == '\t' ) ) //skip space while ( ( *pInit == ' ' ) || ( *pInit == '\t' ) ) //skip space
{ {
pInit++; pInit++;
} }
if ( ( pInit[ 0 ] == '/' ) && ( pInit[ 1 ] == '/' ) ) //remove comment if ( ( pInit[ 0 ] == '/' ) && ( pInit[ 1 ] == '/' ) ) //remove comment
{ {
buffer[ 0 ] = '\0'; buffer[ 0 ] = '\0';
return; return;
} }
pEnd = pInit + strlen( pInit ) - 1; pEnd = pInit + strlen( pInit ) - 1;
if ( pEnd <= pInit ) if ( pEnd <= pInit )
{ {
buffer[ 0 ] = '\0'; buffer[ 0 ] = '\0';
return; return;
} }
while ( ( *pEnd == '\r' ) || ( *pEnd == '\n' ) || while ( ( *pEnd == '\r' ) || ( *pEnd == '\n' ) ||
( *pEnd == ' ' ) || ( *pEnd == '\t' ) ) ( *pEnd == ' ' ) || ( *pEnd == '\t' ) )
{ {
pEnd--; pEnd--;
} }
if ( pEnd <= pInit ) if ( pEnd <= pInit )
{ {
buffer[ 0 ] = '\0'; buffer[ 0 ] = '\0';
return; return;
} }
memmove( buffer, pInit, pEnd - pInit + 1 ); memmove( buffer, pInit, pEnd - pInit + 1 );
buffer[ pEnd - pInit + 1 ] = '\0'; buffer[ pEnd - pInit + 1 ] = '\0';
} }
void inisection_process( FILE * f1 ) void inisection_process( FILE * f1 )
{ {
char buffer[ 1024 ]; char buffer[ 1024 ];
while( fgets( buffer, sizeof( buffer ), f1 ) ) while( fgets( buffer, sizeof( buffer ), f1 ) )
{ {
inifile_trim( buffer ); inifile_trim( buffer );
if ( buffer[ 0 ] ) if ( buffer[ 0 ] )
{ {
inifile_command( buffer ); inifile_command( buffer );
} }
} }
} }
//this routine is for reading the ini file //this routine is for reading the ini file
void inifile_read( char * name ) void inifile_read( char * name )
{ {
FILE * f1; FILE * f1;
char buffer[ 1024 ]; char buffer[ 1024 ];
patchnumber = 0; patchnumber = 0;
#ifdef _WIN32 #ifdef _WIN32
sprintf( buffer, PATCHES_DIR "\\%s.pnach", name ); sprintf( buffer, PATCHES_DIR "\\%s.pnach", name );
#else #else
sprintf( buffer, PATCHES_DIR "/%s.pnach", name ); sprintf( buffer, PATCHES_DIR "/%s.pnach", name );
#endif #endif
f1 = fopen( buffer, "rt" ); f1 = fopen( buffer, "rt" );
#ifndef _WIN32 #ifndef _WIN32
if( !f1 ) { if( !f1 ) {
// try all upper case because linux is case sensitive // try all upper case because linux is case sensitive
char* pstart = buffer+8; char* pstart = buffer+8;
char* pend = buffer+strlen(buffer); char* pend = buffer+strlen(buffer);
while(pstart != pend ) { while(pstart != pend ) {
// stop at the first . since we only want to update the hex // stop at the first . since we only want to update the hex
if( *pstart == '.' ) if( *pstart == '.' )
break; break;
*pstart++ = toupper(*pstart); *pstart++ = toupper(*pstart);
} }
f1 = fopen(buffer, "rt"); f1 = fopen(buffer, "rt");
} }
#endif #endif
if( !f1 ) if( !f1 )
{ {
SysPrintf( _( "No patch found.Resuming execution without a patch (this is NOT an error).\n" )); SysPrintf( _( "No patch found.Resuming execution without a patch (this is NOT an error).\n" ));
return; return;
} }
inisection_process( f1 ); inisection_process( f1 );
fclose( f1 ); fclose( f1 );
} }
void resetpatch( void ) void resetpatch( void )
{ {
patchnumber = 0; patchnumber = 0;
} }
int AddPatch(int Mode, int Place, int Address, int Size, u64 data) int AddPatch(int Mode, int Place, int Address, int Size, u64 data)
@ -551,14 +553,27 @@ int AddPatch(int Mode, int Place, int Address, int Size, u64 data)
return -1; return -1;
} }
if(RunExe == 1) patch[patchnumber].placetopatch = 1; if(RunExe == 1)
else patch[patchnumber].placetopatch = Mode; patch[patchnumber].placetopatch = 1;
else
patch[patchnumber].placetopatch = Mode;
patch[patchnumber].cpu = Place; patch[patchnumber].cpu = Place;
patch[patchnumber].addr=Address; patch[patchnumber].addr=Address;
patch[patchnumber].type=Size; patch[patchnumber].type=Size;
patch[patchnumber].data = data; patch[patchnumber].data = data;
return patchnumber++; return patchnumber++;
} }
void patchFunc_ffxhack( char * cmd, char * param )
{
g_FFXHack = 1;
}
void patchFunc_xkickdelay( char * cmd, char * param )
{
g_VUGameFixes |= VUFIX_XGKICKDELAY2;
}
void patchFunc_fastmemory( char * cmd, char * param ) void patchFunc_fastmemory( char * cmd, char * param )
{ {
@ -568,17 +583,15 @@ void patchFunc_fastmemory( char * cmd, char * param )
#endif #endif
} }
extern void SetVUNanMode(int mode);
void patchFunc_vunanmode( char * cmd, char * param ) void patchFunc_vunanmode( char * cmd, char * param )
{ {
#ifndef PCSX2_NORECBUILD #ifndef PCSX2_NORECBUILD
// only valid for recompilers // only valid for recompilers
SetVUNanMode(param != NULL ? atoi(param) : 1); SetVUNanMode(param != NULL ? atoi(param) : 1);
#endif #endif
} }
extern int path3hack;
void patchFunc_path3hack( char * cmd, char * param ) void patchFunc_path3hack( char * cmd, char * param )
{ {
path3hack = 1; path3hack = 1;
@ -586,7 +599,6 @@ void patchFunc_path3hack( char * cmd, char * param )
void patchFunc_roundmode( char * cmd, char * param ) void patchFunc_roundmode( char * cmd, char * param )
{ {
//roundmode = X,Y
int index; int index;
char * pText; char * pText;
@ -597,6 +609,7 @@ void patchFunc_roundmode( char * cmd, char * param )
pText = strtok( param, ", " ); pText = strtok( param, ", " );
while(pText != NULL) { while(pText != NULL) {
u32 type = 0xffff; u32 type = 0xffff;
if( stricmp(pText, "near") == 0 ) { if( stricmp(pText, "near") == 0 ) {
type = 0x0000; type = 0x0000;
} }
@ -615,8 +628,10 @@ void patchFunc_roundmode( char * cmd, char * param )
break; break;
} }
if( index == 0 ) eetype=type; if( index == 0 )
else vutype=type; eetype=type;
else
vutype=type;
if( index == 1 ) if( index == 1 )
break; break;
@ -630,7 +645,7 @@ void patchFunc_roundmode( char * cmd, char * param )
void patchFunc_zerogs(char* cmd, char* param) void patchFunc_zerogs(char* cmd, char* param)
{ {
sscanf(param, "%x", &g_ZeroGSOptions); sscanf(param, "%x", &g_ZeroGSOptions);
} }
void SetRoundMode(u32 ee, u32 vu) void SetRoundMode(u32 ee, u32 vu)

52
pcsx2/Patch.h
View File

@ -27,9 +27,27 @@
#define GETNEXT_PARAM() \ #define GETNEXT_PARAM() \
while ( *param && ( *param != ',' ) ) param++; \ while ( *param && ( *param != ',' ) ) param++; \
if ( *param ) param++; \ if ( *param ) param++; \
while ( *param && ( *param == ' ' ) ) param++; \ while ( *param && ( *param == ' ' ) ) param++; \
if ( *param == 0 ) { SysPrintf( _( "Not enough params for inicommand\n" ) ); return; } if ( *param == 0 ) { SysPrintf( _( "Not enough params for inicommand\n" ) ); return; }
//
// Enums
//
enum patch_cpu_type {
NO_CPU,
EE,
IOP
};
enum patch_data_type {
NO_TYPE,
BYTE_T,
SHORT_T,
WORD_T,
DOUBLE_T,
EXTENDED_T
};
// //
// Typedefs // Typedefs
@ -38,20 +56,20 @@ typedef void (*PATCHTABLEFUNC)( char * text1, char * text2 );
typedef struct typedef struct
{ {
char * text; char *text;
int code; int code;
PATCHTABLEFUNC func; PATCHTABLEFUNC func;
} PatchTextTable; } PatchTextTable;
typedef struct typedef struct
{ {
int enabled; int enabled;
int group; int group;
int type; enum patch_data_type type;
int cpu; enum patch_cpu_type cpu;
int placetopatch; int placetopatch;
u32 addr; u32 addr;
u64 data; u64 data;
} IniPatch; } IniPatch;
// //
@ -65,6 +83,8 @@ void patchFunc_path3hack( char * text1, char * text2 );
void patchFunc_roundmode( char * text1, char * text2 ); void patchFunc_roundmode( char * text1, char * text2 );
void patchFunc_zerogs( char * text1, char * text2 ); void patchFunc_zerogs( char * text1, char * text2 );
void patchFunc_vunanmode( char * text1, char * text2 ); void patchFunc_vunanmode( char * text1, char * text2 );
void patchFunc_ffxhack( char * text1, char * text2 );
void patchFunc_xkickdelay( char * text1, char * text2 );
void inifile_trim( char * buffer ); void inifile_trim( char * buffer );
@ -72,11 +92,8 @@ void inifile_trim( char * buffer );
// Variables // Variables
// //
extern PatchTextTable commands[]; extern PatchTextTable commands[];
extern PatchTextTable dataType[]; extern PatchTextTable dataType[];
extern PatchTextTable cpuCore[]; extern PatchTextTable cpuCore[];
extern IniPatch patch[ MAX_PATCH ]; extern IniPatch patch[ MAX_PATCH ];
extern int patchnumber; extern int patchnumber;
@ -91,6 +108,11 @@ int AddPatch(int Mode, int Place, int Address, int Size, u64 data);
void SetFastMemory(int); // iR5900LoadStore.c void SetFastMemory(int); // iR5900LoadStore.c
void SetVUNanMemory(int); // iVUmicro.c void SetVUNanMemory(int); // iVUmicro.c
extern void SetVUNanMode(int mode);
extern int path3hack;
extern int g_FFXHack;
//extern int g_VUGameFixes;
extern u32 g_sseMXCSR; extern u32 g_sseMXCSR;
extern u32 g_sseVUMXCSR; extern u32 g_sseVUMXCSR;
void SetCPUState(u32 sseMXCSR, u32 sseVUMXCSR); void SetCPUState(u32 sseMXCSR, u32 sseVUMXCSR);

1
pcsx2/configure.ac
View File

@ -17,6 +17,7 @@ CXXFLAGS=
CCASFLAGS= CCASFLAGS=
WARNING_FLAGS="-Wall -Wno-format -Wno-unused-value" WARNING_FLAGS="-Wall -Wno-format -Wno-unused-value"
dnl EXTRA_FLAGS = " -Xlinker -zmuldefs -fpermissive "
NORMAL_FLAGS="-O3 -fomit-frame-pointer ${WARNING_FLAGS}" NORMAL_FLAGS="-O3 -fomit-frame-pointer ${WARNING_FLAGS}"
DEBUG_FLAGS=" -g ${WARNING_FLAGS}" DEBUG_FLAGS=" -g ${WARNING_FLAGS}"

4
pcsx2/windows/cheats/browser.cpp
View File

@ -607,7 +607,7 @@ int ReadPatch(HWND hWnd, IniPatch &temp)
} }
// CPU // CPU
temp.cpu = SendMessage(GetDlgItem(hWnd, IDC_CPU), CB_GETCURSEL, 0, 0) + 1; temp.cpu = (patch_cpu_type)(SendMessage(GetDlgItem(hWnd, IDC_CPU), CB_GETCURSEL, 0, 0) + 1);
if(temp.cpu < 1) if(temp.cpu < 1)
{ {
MessageBox(hWnd, "CPU is not selected.", "Error", 0); MessageBox(hWnd, "CPU is not selected.", "Error", 0);
@ -631,7 +631,7 @@ int ReadPatch(HWND hWnd, IniPatch &temp)
} }
// Type // Type
temp.type = SendMessage(GetDlgItem(hWnd, IDC_TYPE), CB_GETCURSEL, 0, 0) + 1; temp.type = (patch_data_type)(SendMessage(GetDlgItem(hWnd, IDC_TYPE), CB_GETCURSEL, 0, 0) + 1);
if(temp.type < 1) if(temp.type < 1)
{ {
MessageBox(hWnd, "Type is not selected.", "Error", 0); MessageBox(hWnd, "Type is not selected.", "Error", 0);

6
pcsx2/x86/ir5900tables.c
View File

@ -657,7 +657,7 @@ void rpropSPECIAL(EEINST* prev, EEINST* pinst)
case 16: // mfhi case 16: // mfhi
rpropSetWrite(_Rd_, EEINST_LIVE1); rpropSetWrite(_Rd_, EEINST_LIVE1);
rpropSetRead(XMMGPR_HI, (pinst->regs[_Rd_]&EEINST_MMX|EEINST_REALXMM)|EEINST_LIVE1); rpropSetRead(XMMGPR_HI, (pinst->regs[_Rd_]&(EEINST_MMX|EEINST_REALXMM))|EEINST_LIVE1);
break; break;
case 17: // mthi case 17: // mthi
rpropSetWrite(XMMGPR_HI, EEINST_LIVE1); rpropSetWrite(XMMGPR_HI, EEINST_LIVE1);
@ -665,7 +665,7 @@ void rpropSPECIAL(EEINST* prev, EEINST* pinst)
break; break;
case 18: // mflo case 18: // mflo
rpropSetWrite(_Rd_, EEINST_LIVE1); rpropSetWrite(_Rd_, EEINST_LIVE1);
rpropSetRead(XMMGPR_LO, (pinst->regs[_Rd_]&EEINST_MMX|EEINST_REALXMM)|EEINST_LIVE1); rpropSetRead(XMMGPR_LO, (pinst->regs[_Rd_]&(EEINST_MMX|EEINST_REALXMM))|EEINST_LIVE1);
break; break;
case 19: // mtlo case 19: // mtlo
rpropSetWrite(XMMGPR_LO, EEINST_LIVE1); rpropSetWrite(XMMGPR_LO, EEINST_LIVE1);
@ -687,6 +687,8 @@ void rpropSPECIAL(EEINST* prev, EEINST* pinst)
rpropSetWrite(XMMGPR_LO, EEINST_LIVE1); rpropSetWrite(XMMGPR_LO, EEINST_LIVE1);
rpropSetWrite(XMMGPR_HI, EEINST_LIVE1); rpropSetWrite(XMMGPR_HI, EEINST_LIVE1);
rpropSetWrite(_Rd_, EEINST_LIVE1); rpropSetWrite(_Rd_, EEINST_LIVE1);
// fixme - temp is always 0, so I doubt the next three lines are right.
rpropSetRead(_Rs_, temp); rpropSetRead(_Rs_, temp);
rpropSetRead(_Rt_, temp); rpropSetRead(_Rt_, temp);
pinst->info |= temp; pinst->info |= temp;

12
pcsx2/xmlpatchloader.cpp
View File

@ -335,11 +335,11 @@ int LoadGroup(TiXmlNode *group,int gParent)
if(strcmp(place,"EE")==0) if(strcmp(place,"EE")==0)
{ {
patch[patchnumber].cpu=1; patch[patchnumber].cpu= EE;
} else } else
if(strcmp(place,"IOP")==0) if(strcmp(place,"IOP")==0)
{ {
patch[patchnumber].cpu=2; patch[patchnumber].cpu= IOP;
} else } else
{ {
SysPrintf("XML Patch Loader: ERROR: Invalid place attribute.\n"); SysPrintf("XML Patch Loader: ERROR: Invalid place attribute.\n");
@ -349,19 +349,19 @@ int LoadGroup(TiXmlNode *group,int gParent)
if(strcmp(size,"64")==0) if(strcmp(size,"64")==0)
{ {
patch[patchnumber].type=4; patch[patchnumber].type = DOUBLE_T;
} else } else
if(strcmp(size,"32")==0) if(strcmp(size,"32")==0)
{ {
patch[patchnumber].type=3; patch[patchnumber].type = WORD_T;
} else } else
if(strcmp(size,"16")==0) if(strcmp(size,"16")==0)
{ {
patch[patchnumber].type=2; patch[patchnumber].type = SHORT_T;
} else } else
if(strcmp(size,"8")==0) if(strcmp(size,"8")==0)
{ {
patch[patchnumber].type=1; patch[patchnumber].type = BYTE_T;
} else } else
{ {
SysPrintf("XML Patch Loader: ERROR: Invalid size attribute.\n"); SysPrintf("XML Patch Loader: ERROR: Invalid size attribute.\n");