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

microVU/pcsx2: 

- Removed flaghack1 since it didn't do much over flaghack2 (except break games :p).
Flaghack2 is now renamed to "Status Flag Hack", and so-far we haven't found a single game it breaks, so compatibility is high.


git-svn-id: http://pcsx2.googlecode.com/svn/trunk@1313 96395faa-99c1-11dd-bbfe-3dabce05a288
This commit is contained in:
cottonvibes 2009-06-03 23:51:23 +00:00
parent db8feac8c3
commit 07a4eb3491
13 changed files with 41 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
common/include/Pcsx2Config.h
View File

@ -171,8 +171,7 @@ public:
bool INTCSTATSlow; bool INTCSTATSlow;
bool IdleLoopFF; bool IdleLoopFF;
int VUCycleSteal; int VUCycleSteal;
bool vuFlagHack1; bool vuFlagHack;
bool vuFlagHack2;
bool vuMinMax; bool vuMinMax;
bool ESCExits; // this is a hack!? bool ESCExits; // this is a hack!?
} Hacks; } Hacks;

6
pcsx2/Linux/HacksDlg.cpp
View File

@ -79,8 +79,7 @@ void on_Speed_Hacks(GtkMenuItem *menuitem, gpointer user_data)
set_checked(SpeedHacksDlg, "check_wait_cycles_sync_hack", Config.Hacks.WaitCycleExt); set_checked(SpeedHacksDlg, "check_wait_cycles_sync_hack", Config.Hacks.WaitCycleExt);
set_checked(SpeedHacksDlg, "check_intc_sync_hack", Config.Hacks.INTCSTATSlow); set_checked(SpeedHacksDlg, "check_intc_sync_hack", Config.Hacks.INTCSTATSlow);
set_checked(SpeedHacksDlg, "check_idle_loop_fastforward", Config.Hacks.IdleLoopFF); set_checked(SpeedHacksDlg, "check_idle_loop_fastforward", Config.Hacks.IdleLoopFF);
set_checked(SpeedHacksDlg, "check_microvu_flag_hack_1", Config.Hacks.vuFlagHack1); set_checked(SpeedHacksDlg, "check_microvu_flag_hack", Config.Hacks.vuFlagHack);
set_checked(SpeedHacksDlg, "check_microvu_flag_hack_2", Config.Hacks.vuFlagHack2);
set_checked(SpeedHacksDlg, "check_microvu_min_max_hack", Config.Hacks.vuMinMax); set_checked(SpeedHacksDlg, "check_microvu_min_max_hack", Config.Hacks.vuMinMax);
gtk_range_set_value(vuScale, Config.Hacks.VUCycleSteal); gtk_range_set_value(vuScale, Config.Hacks.VUCycleSteal);
@ -104,8 +103,7 @@ void on_Speed_Hack_OK(GtkButton *button, gpointer user_data)
newhacks.WaitCycleExt = is_checked(SpeedHacksDlg, "check_wait_cycles_sync_hack"); newhacks.WaitCycleExt = is_checked(SpeedHacksDlg, "check_wait_cycles_sync_hack");
newhacks.INTCSTATSlow = is_checked(SpeedHacksDlg, "check_intc_sync_hack"); newhacks.INTCSTATSlow = is_checked(SpeedHacksDlg, "check_intc_sync_hack");
newhacks.IdleLoopFF = is_checked(SpeedHacksDlg, "check_idle_loop_fastforward"); newhacks.IdleLoopFF = is_checked(SpeedHacksDlg, "check_idle_loop_fastforward");
newhacks.vuFlagHack1 = is_checked(SpeedHacksDlg, "check_microvu_flag_hack_1"); newhacks.vuFlagHack = is_checked(SpeedHacksDlg, "check_microvu_flag_hack");
newhacks.vuFlagHack2 = is_checked(SpeedHacksDlg, "check_microvu_flag_hack_2");
newhacks.vuMinMax = is_checked(SpeedHacksDlg, "check_microvu_min_max_hack"); newhacks.vuMinMax = is_checked(SpeedHacksDlg, "check_microvu_min_max_hack");
newhacks.VUCycleSteal = gtk_range_get_value(GTK_RANGE(lookup_widget(SpeedHacksDlg, "VUCycleHackScale"))); newhacks.VUCycleSteal = gtk_range_get_value(GTK_RANGE(lookup_widget(SpeedHacksDlg, "VUCycleHackScale")));

3
pcsx2/Linux/Pref.cpp
View File

@ -108,8 +108,7 @@ int LoadConfig()
GetValuel("WaitCycleExt", Config.Hacks.WaitCycleExt); GetValuel("WaitCycleExt", Config.Hacks.WaitCycleExt);
GetValuel("INTCSTATSlow", Config.Hacks.INTCSTATSlow); GetValuel("INTCSTATSlow", Config.Hacks.INTCSTATSlow);
GetValuel("VUCycleSteal", Config.Hacks.VUCycleSteal); GetValuel("VUCycleSteal", Config.Hacks.VUCycleSteal);
GetValuel("vuFlagHack1", Config.Hacks.vuFlagHack1); GetValuel("vuFlagHack", Config.Hacks.vuFlagHack);
GetValuel("vuFlagHack2", Config.Hacks.vuFlagHack2);
GetValuel("vuMinMax", Config.Hacks.vuMinMax); GetValuel("vuMinMax", Config.Hacks.vuMinMax);
GetValuel("IdleLoopFF", Config.Hacks.IdleLoopFF); GetValuel("IdleLoopFF", Config.Hacks.IdleLoopFF);
GetValuel("ESCExits", Config.Hacks.ESCExits); GetValuel("ESCExits", Config.Hacks.ESCExits);

6
pcsx2/windows/HacksDlg.cpp
View File

@ -48,8 +48,7 @@ BOOL APIENTRY HacksProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
if(Config.Hacks.INTCSTATSlow) CheckDlgButton(hDlg, IDC_INTCSTATHACK, TRUE); if(Config.Hacks.INTCSTATSlow) CheckDlgButton(hDlg, IDC_INTCSTATHACK, TRUE);
if(Config.Hacks.IdleLoopFF) CheckDlgButton(hDlg, IDC_IDLELOOPFF, TRUE); if(Config.Hacks.IdleLoopFF) CheckDlgButton(hDlg, IDC_IDLELOOPFF, TRUE);
if(Config.Hacks.ESCExits) CheckDlgButton(hDlg, IDC_ESCHACK, TRUE); if(Config.Hacks.ESCExits) CheckDlgButton(hDlg, IDC_ESCHACK, TRUE);
if(Config.Hacks.vuFlagHack1) CheckDlgButton(hDlg, IDC_VUHACK1, TRUE); if(Config.Hacks.vuFlagHack) CheckDlgButton(hDlg, IDC_VUHACK1, TRUE);
if(Config.Hacks.vuFlagHack2) CheckDlgButton(hDlg, IDC_VUHACK2, TRUE);
if(Config.Hacks.vuMinMax) CheckDlgButton(hDlg, IDC_VUHACK3, TRUE); if(Config.Hacks.vuMinMax) CheckDlgButton(hDlg, IDC_VUHACK3, TRUE);
SendDlgItemMessage(hDlg, IDC_VUCYCLE, TBM_SETRANGE, TRUE, MAKELONG(0, 4)); SendDlgItemMessage(hDlg, IDC_VUCYCLE, TBM_SETRANGE, TRUE, MAKELONG(0, 4));
@ -93,8 +92,7 @@ BOOL APIENTRY HacksProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
newhacks.WaitCycleExt = !!IsDlgButtonChecked(hDlg, IDC_WAITCYCLES); newhacks.WaitCycleExt = !!IsDlgButtonChecked(hDlg, IDC_WAITCYCLES);
newhacks.INTCSTATSlow = !!IsDlgButtonChecked(hDlg, IDC_INTCSTATHACK); newhacks.INTCSTATSlow = !!IsDlgButtonChecked(hDlg, IDC_INTCSTATHACK);
newhacks.ESCExits = !!IsDlgButtonChecked(hDlg, IDC_ESCHACK); newhacks.ESCExits = !!IsDlgButtonChecked(hDlg, IDC_ESCHACK);
newhacks.vuFlagHack1 = !!IsDlgButtonChecked(hDlg, IDC_VUHACK1); newhacks.vuFlagHack = !!IsDlgButtonChecked(hDlg, IDC_VUHACK1);
newhacks.vuFlagHack2 = !!IsDlgButtonChecked(hDlg, IDC_VUHACK2);
newhacks.vuMinMax = !!IsDlgButtonChecked(hDlg, IDC_VUHACK3); newhacks.vuMinMax = !!IsDlgButtonChecked(hDlg, IDC_VUHACK3);
newhacks.IdleLoopFF = !!IsDlgButtonChecked(hDlg, IDC_IDLELOOPFF); newhacks.IdleLoopFF = !!IsDlgButtonChecked(hDlg, IDC_IDLELOOPFF);
newhacks.VUCycleSteal = SendDlgItemMessage(hDlg, IDC_VUCYCLE, TBM_GETPOS, 0, 0); newhacks.VUCycleSteal = SendDlgItemMessage(hDlg, IDC_VUCYCLE, TBM_GETPOS, 0, 0);

3
pcsx2/windows/ini.cpp
View File

@ -231,8 +231,7 @@ void IniFile::DoConfig( PcsxConfig& Conf )
Entry("WaitCycleExt", Config.Hacks.WaitCycleExt); Entry("WaitCycleExt", Config.Hacks.WaitCycleExt);
Entry("INTCSTATSlow", Config.Hacks.INTCSTATSlow); Entry("INTCSTATSlow", Config.Hacks.INTCSTATSlow);
Entry("VUCycleSteal", Config.Hacks.VUCycleSteal); Entry("VUCycleSteal", Config.Hacks.VUCycleSteal);
Entry("vuFlagHack1", Config.Hacks.vuFlagHack1); Entry("vuFlagHack", Config.Hacks.vuFlagHack);
Entry("vuFlagHack2", Config.Hacks.vuFlagHack2);
Entry("vuMinMax", Config.Hacks.vuMinMax); Entry("vuMinMax", Config.Hacks.vuMinMax);
Entry("IdleLoopFF", Config.Hacks.IdleLoopFF); Entry("IdleLoopFF", Config.Hacks.IdleLoopFF);
if (Conf.Hacks.VUCycleSteal < 0 || Conf.Hacks.VUCycleSteal > 4) if (Conf.Hacks.VUCycleSteal < 0 || Conf.Hacks.VUCycleSteal > 4)

17
pcsx2/windows/pcsx2.rc
View File

@ -369,20 +369,18 @@ BEGIN
LTEXT "Moderate speedup and works well with most games.",IDC_STATIC,25,90,129,19 LTEXT "Moderate speedup and works well with most games.",IDC_STATIC,25,90,129,19
CONTROL "INTC Sync Hack",IDC_INTCSTATHACK,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,187,43,127,10 CONTROL "INTC Sync Hack",IDC_INTCSTATHACK,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,187,43,127,10
LTEXT "Huge speedup in many games, and a pretty high compatibility rate (some games still work better with EE sync hacks).",IDC_STATIC,200,55,140,28 LTEXT "Huge speedup in many games, and a pretty high compatibility rate (some games still work better with EE sync hacks).",IDC_STATIC,200,55,140,28
CONTROL "",IDC_VUCYCLE,"msctls_trackbar32",TBS_BOTH | TBS_NOTICKS | WS_TABSTOP,372,152,36,15 CONTROL "",IDC_VUCYCLE,"msctls_trackbar32",TBS_BOTH | TBS_NOTICKS | WS_TABSTOP,372,141,36,15
LTEXT "This space intentionally left blank",IDC_VUCYCLEDESC,383,171,142,26 LTEXT "This space intentionally left blank",IDC_VUCYCLEDESC,383,160,142,26
LTEXT "VU Cycle Stealing (experimental)",IDC_STATIC,408,157,105,8 LTEXT "VU Cycle Stealing (experimental)",IDC_STATIC,408,146,105,8
CONTROL "Idle Loop Fast-Forward (experimental)",IDC_IDLELOOPFF, CONTROL "Idle Loop Fast-Forward (experimental)",IDC_IDLELOOPFF,
"Button",BS_AUTOCHECKBOX | WS_TABSTOP,187,179,139,10 "Button",BS_AUTOCHECKBOX | WS_TABSTOP,187,179,139,10
LTEXT "Speedup for a few games, including FFX with no known side effects.",IDC_STATIC,200,193,144,23 LTEXT "Speedup for a few games, including FFX with no known side effects.",IDC_STATIC,200,193,144,23
GROUPBOX "EmotionEngine (EE) Misc Hacks",IDC_STATIC,177,26,179,192 GROUPBOX "EmotionEngine (EE) Misc Hacks",IDC_STATIC,177,26,179,192
GROUPBOX "Vertex Unit (VU) Hacks",IDC_STATIC,363,26,173,173 GROUPBOX "Vertex Unit (VU) Hacks",IDC_STATIC,363,26,173,173
CONTROL "Flag Hack 1 (microVU only)",IDC_VUHACK1,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,372,42,155,12 CONTROL "Status Flag Hack (microVU only)",IDC_VUHACK1,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,372,42,155,12
CONTROL "Flag Hack 2 (microVU only)",IDC_VUHACK2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,372,79,154,12 LTEXT "Big Speedup and high compatibility.\nSuperVU does something similar by default.",IDC_STATIC,383,55,144,20
LTEXT "Big Speedup and moderately compatible. May cause SPS and Infinite loop problems.",IDC_STATIC,386,56,142,19 CONTROL "Min / Max Hack (microVU only)",IDC_VUHACK3,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,372,85,156,12
LTEXT "Big Speedup and moderately compatible. SuperVU does something similar by default.",IDC_STATIC,385,92,144,20 LTEXT "Small Speedup. May cause SPS, hanging, graphical corruption, and missing geometry.",IDC_STATIC,383,99,143,28
CONTROL "Min / Max Hack (microVU only)",IDC_VUHACK3,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,372,115,156,12
LTEXT "Small Speedup. May cause SPS, hanging, and missing geometry.",IDC_STATIC,386,130,143,19
END END
@ -409,6 +407,7 @@ BEGIN
VERTGUIDE, 187 VERTGUIDE, 187
VERTGUIDE, 200 VERTGUIDE, 200
VERTGUIDE, 372 VERTGUIDE, 372
VERTGUIDE, 383
TOPMARGIN, 7 TOPMARGIN, 7
BOTTOMMARGIN, 222 BOTTOMMARGIN, 222
HORZGUIDE, 26 HORZGUIDE, 26

2
pcsx2/x86/microVU.cpp
View File

@ -133,7 +133,6 @@ microVUf(void) mVUclearProg(int progIndex) {
microVU* mVU = mVUx; microVU* mVU = mVUx;
mVU->prog.prog[progIndex].used = 1; mVU->prog.prog[progIndex].used = 1;
mVU->prog.prog[progIndex].last_used = 3; mVU->prog.prog[progIndex].last_used = 3;
mVU->prog.prog[progIndex].sFlagHack = 0;
mVU->prog.prog[progIndex].range[0] = -1; mVU->prog.prog[progIndex].range[0] = -1;
mVU->prog.prog[progIndex].range[1] = -1; mVU->prog.prog[progIndex].range[1] = -1;
mVU->prog.prog[progIndex].x86ptr = mVU->prog.prog[progIndex].x86start; mVU->prog.prog[progIndex].x86ptr = mVU->prog.prog[progIndex].x86start;
@ -148,7 +147,6 @@ microVUf(void) mVUcacheProg(int progIndex) {
microVU* mVU = mVUx; microVU* mVU = mVUx;
memcpy_fast(mVU->prog.prog[progIndex].data, mVU->regs->Micro, mVU->microSize); memcpy_fast(mVU->prog.prog[progIndex].data, mVU->regs->Micro, mVU->microSize);
mVUdumpProg(progIndex); mVUdumpProg(progIndex);
mVUcheckSflag(mVU, progIndex);
} }
// Finds the least used program, (if program list full clears and returns an old program; if not-full, returns free program) // Finds the least used program, (if program list full clears and returns an old program; if not-full, returns free program)

1
pcsx2/x86/microVU.h
View File

@ -74,7 +74,6 @@ struct microProgram {
u32 data[progSize]; u32 data[progSize];
u32 used; // Number of times its been used u32 used; // Number of times its been used
u32 last_used; // Counters # of frames since last use (starts at 3 and counts backwards to 0 for each 30fps vSync) u32 last_used; // Counters # of frames since last use (starts at 3 and counts backwards to 0 for each 30fps vSync)
u32 sFlagHack; // Optimize out Status Flag Updates if Program doesn't use Status Flags
s32 range[2]; // The range of microMemory that has already been recompiled for the current program s32 range[2]; // The range of microMemory that has already been recompiled for the current program
u8* x86ptr; // Pointer to program's recompilation code u8* x86ptr; // Pointer to program's recompilation code
u8* x86start; // Start of program's rec-cache u8* x86start; // Start of program's rec-cache

4
pcsx2/x86/microVU_Compile.inl
View File

@ -168,10 +168,8 @@ microVUt(void) mVUendProgram(mV, int qInst, int pInst, int fStatus, int fMac, in
} }
// Save Flag Instances // Save Flag Instances
if (!mVUflagHack) {
mVUallocSFLAGc(gprT1, gprT2, fStatus); mVUallocSFLAGc(gprT1, gprT2, fStatus);
MOV32RtoM((uptr)&mVU->regs->VI[REG_STATUS_FLAG].UL, gprT1); MOV32RtoM((uptr)&mVU->regs->VI[REG_STATUS_FLAG].UL, gprT1);
}
mVUallocMFLAGa(mVU, gprT1, fMac); mVUallocMFLAGa(mVU, gprT1, fMac);
mVUallocCFLAGa(mVU, gprT2, fClip); mVUallocCFLAGa(mVU, gprT2, fClip);
MOV32RtoM((uptr)&mVU->regs->VI[REG_MAC_FLAG].UL, gprT1); MOV32RtoM((uptr)&mVU->regs->VI[REG_MAC_FLAG].UL, gprT1);
@ -242,7 +240,7 @@ microVUf(void*) __fastcall mVUcompile(u32 startPC, uptr pState) {
mVUpBlock = pBlock; mVUpBlock = pBlock;
mVUregs.flags = 0; mVUregs.flags = 0;
mVUflagInfo = 0; mVUflagInfo = 0;
mVUsFlagHack = CHECK_VU_FLAGHACK2 | mVUflagHack; mVUsFlagHack = CHECK_VU_FLAGHACK;
bool eBitBranch = 0; // E-bit Set on Branch bool eBitBranch = 0; // E-bit Set on Branch
for (int branch = 0; mVUcount < (vuIndex ? (0x3fff/8) : (0xfff/8)); ) { for (int branch = 0; mVUcount < (vuIndex ? (0x3fff/8) : (0xfff/8)); ) {

2
pcsx2/x86/microVU_Flags.inl
View File

@ -153,7 +153,7 @@ microVUt(int) mVUsetFlags(mV, int* xStatus, int* xMac, int* xClip) {
// Recompiles Code for Proper Flags on Block Linkings // Recompiles Code for Proper Flags on Block Linkings
microVUt(void) mVUsetupFlags(mV, int* xStatus, int* xMac, int* xClip, int cycles) { microVUt(void) mVUsetupFlags(mV, int* xStatus, int* xMac, int* xClip, int cycles) {
if (__Status && !mVUflagHack) { if (__Status) {
int bStatus[4]; int bStatus[4];
sortFlag(xStatus, bStatus, cycles); sortFlag(xStatus, bStatus, cycles);
MOV32RtoR(gprT1, getFlagReg1(bStatus[0])); MOV32RtoR(gprT1, getFlagReg1(bStatus[0]));

21
pcsx2/x86/microVU_Lower.inl
View File

@ -424,7 +424,7 @@ mVUop(mVU_FCAND) {
mVUallocVIb(mVU, gprT1, 1); mVUallocVIb(mVU, gprT1, 1);
} }
pass3 { mVUlog("FCAND vi01, $%x", _Imm24_); } pass3 { mVUlog("FCAND vi01, $%x", _Imm24_); }
pass4 { mVUflagInfo |= 0xf << (/*mVUcount +*/ 8); } pass4 { mVUflagInfo |= 0xf << 8; }
} }
mVUop(mVU_FCEQ) { mVUop(mVU_FCEQ) {
@ -437,7 +437,7 @@ mVUop(mVU_FCEQ) {
mVUallocVIb(mVU, gprT1, 1); mVUallocVIb(mVU, gprT1, 1);
} }
pass3 { mVUlog("FCEQ vi01, $%x", _Imm24_); } pass3 { mVUlog("FCEQ vi01, $%x", _Imm24_); }
pass4 { mVUflagInfo |= 0xf << (/*mVUcount +*/ 8); } pass4 { mVUflagInfo |= 0xf << 8; }
} }
mVUop(mVU_FCGET) { mVUop(mVU_FCGET) {
@ -448,7 +448,7 @@ mVUop(mVU_FCGET) {
mVUallocVIb(mVU, gprT1, _It_); mVUallocVIb(mVU, gprT1, _It_);
} }
pass3 { mVUlog("FCGET vi%02d", _Ft_); } pass3 { mVUlog("FCGET vi%02d", _Ft_); }
pass4 { mVUflagInfo |= 0xf << (/*mVUcount +*/ 8); } pass4 { mVUflagInfo |= 0xf << 8; }
} }
mVUop(mVU_FCOR) { mVUop(mVU_FCOR) {
@ -461,7 +461,7 @@ mVUop(mVU_FCOR) {
mVUallocVIb(mVU, gprT1, 1); mVUallocVIb(mVU, gprT1, 1);
} }
pass3 { mVUlog("FCOR vi01, $%x", _Imm24_); } pass3 { mVUlog("FCOR vi01, $%x", _Imm24_); }
pass4 { mVUflagInfo |= 0xf << (/*mVUcount +*/ 8); } pass4 { mVUflagInfo |= 0xf << 8; }
} }
mVUop(mVU_FCSET) { mVUop(mVU_FCSET) {
@ -486,7 +486,7 @@ mVUop(mVU_FMAND) {
mVUallocVIb(mVU, gprT1, _It_); mVUallocVIb(mVU, gprT1, _It_);
} }
pass3 { mVUlog("FMAND vi%02d, vi%02d", _Ft_, _Fs_); } pass3 { mVUlog("FMAND vi%02d, vi%02d", _Ft_, _Fs_); }
pass4 { mVUflagInfo |= 0xf << (/*mVUcount +*/ 4); } pass4 { mVUflagInfo |= 0xf << 4; }
} }
mVUop(mVU_FMEQ) { mVUop(mVU_FMEQ) {
@ -500,7 +500,7 @@ mVUop(mVU_FMEQ) {
mVUallocVIb(mVU, gprT1, _It_); mVUallocVIb(mVU, gprT1, _It_);
} }
pass3 { mVUlog("FMEQ vi%02d, vi%02d", _Ft_, _Fs_); } pass3 { mVUlog("FMEQ vi%02d, vi%02d", _Ft_, _Fs_); }
pass4 { mVUflagInfo |= 0xf << (/*mVUcount +*/ 4); } pass4 { mVUflagInfo |= 0xf << 4; }
} }
mVUop(mVU_FMOR) { mVUop(mVU_FMOR) {
@ -512,7 +512,7 @@ mVUop(mVU_FMOR) {
mVUallocVIb(mVU, gprT1, _It_); mVUallocVIb(mVU, gprT1, _It_);
} }
pass3 { mVUlog("FMOR vi%02d, vi%02d", _Ft_, _Fs_); } pass3 { mVUlog("FMOR vi%02d, vi%02d", _Ft_, _Fs_); }
pass4 { mVUflagInfo |= 0xf << (/*mVUcount +*/ 4); } pass4 { mVUflagInfo |= 0xf << 4; }
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
@ -527,7 +527,7 @@ mVUop(mVU_FSAND) {
mVUallocVIb(mVU, gprT1, _It_); mVUallocVIb(mVU, gprT1, _It_);
} }
pass3 { mVUlog("FSAND vi%02d, $%x", _Ft_, _Imm12_); } pass3 { mVUlog("FSAND vi%02d, $%x", _Ft_, _Imm12_); }
pass4 { mVUflagInfo |= 0xf << (/*mVUcount +*/ 0); mVUsFlagHack = 0; } pass4 { mVUflagInfo |= 0xf; }
} }
mVUop(mVU_FSOR) { mVUop(mVU_FSOR) {
@ -538,7 +538,7 @@ mVUop(mVU_FSOR) {
mVUallocVIb(mVU, gprT1, _It_); mVUallocVIb(mVU, gprT1, _It_);
} }
pass3 { mVUlog("FSOR vi%02d, $%x", _Ft_, _Imm12_); } pass3 { mVUlog("FSOR vi%02d, $%x", _Ft_, _Imm12_); }
pass4 { mVUflagInfo |= 0xf << (/*mVUcount +*/ 0); mVUsFlagHack = 0; } pass4 { mVUflagInfo |= 0xf; }
} }
mVUop(mVU_FSEQ) { mVUop(mVU_FSEQ) {
@ -570,7 +570,7 @@ mVUop(mVU_FSEQ) {
mVUallocVIb(mVU, gprT1, _It_); mVUallocVIb(mVU, gprT1, _It_);
} }
pass3 { mVUlog("FSEQ vi%02d, $%x", _Ft_, _Imm12_); } pass3 { mVUlog("FSEQ vi%02d, $%x", _Ft_, _Imm12_); }
pass4 { mVUflagInfo |= 0xf << (/*mVUcount +*/ 0); mVUsFlagHack = 0; } pass4 { mVUflagInfo |= 0xf; }
} }
mVUop(mVU_FSSET) { mVUop(mVU_FSSET) {
@ -591,7 +591,6 @@ mVUop(mVU_FSSET) {
if (imm) OR32ItoR(sReg, imm); if (imm) OR32ItoR(sReg, imm);
} }
pass3 { mVUlog("FSSET $%x", _Imm12_); } pass3 { mVUlog("FSSET $%x", _Imm12_); }
pass4 { mVUsFlagHack = 0; }
} }
//------------------------------------------------------------------ //------------------------------------------------------------------

7
pcsx2/x86/microVU_Misc.h
View File

@ -154,7 +154,6 @@ declareAllVariables
#define microVUx(aType) template<int vuIndex> aType #define microVUx(aType) template<int vuIndex> aType
#define microVUf(aType) template<int vuIndex> __forceinline aType #define microVUf(aType) template<int vuIndex> __forceinline aType
// Define Passes // Define Passes
#define pass1 if (recPass == 0) #define pass1 if (recPass == 0)
#define pass2 if (recPass == 1) #define pass2 if (recPass == 1)
@ -175,7 +174,6 @@ declareAllVariables
#define mVUregsTemp mVUallocInfo.regsTemp #define mVUregsTemp mVUallocInfo.regsTemp
#define iPC mVUallocInfo.curPC #define iPC mVUallocInfo.curPC
#define mVUsFlagHack mVUallocInfo.sFlagHack #define mVUsFlagHack mVUallocInfo.sFlagHack
#define mVUinfo mVUallocInfo.info[iPC / 2] #define mVUinfo mVUallocInfo.info[iPC / 2]
#define mVUstall mVUinfo.stall #define mVUstall mVUinfo.stall
#define mVUup mVUinfo.uOp #define mVUup mVUinfo.uOp
@ -183,10 +181,8 @@ declareAllVariables
#define sFLAG mVUinfo.sFlag #define sFLAG mVUinfo.sFlag
#define mFLAG mVUinfo.mFlag #define mFLAG mVUinfo.mFlag
#define cFLAG mVUinfo.cFlag #define cFLAG mVUinfo.cFlag
#define mVUstartPC mVUallocInfo.startPC #define mVUstartPC mVUallocInfo.startPC
#define mVUflagInfo mVUregs.needExactMatch #define mVUflagInfo mVUregs.needExactMatch
#define mVUflagHack (mVUcurProg.sFlagHack)
#define xPC ((iPC / 2) * 8) #define xPC ((iPC / 2) * 8)
#define curI ((u32*)mVU->regs->Micro)[iPC] //mVUcurProg.data[iPC] #define curI ((u32*)mVU->regs->Micro)[iPC] //mVUcurProg.data[iPC]
#define setCode() { mVU->code = curI; } #define setCode() { mVU->code = curI; }
@ -248,8 +244,7 @@ declareAllVariables
#endif #endif
// Speed Hacks // Speed Hacks
#define CHECK_VU_FLAGHACK1 (u32)Config.Hacks.vuFlagHack1 // (Can cause Infinite loops, SPS, etc...) #define CHECK_VU_FLAGHACK (u32)Config.Hacks.vuFlagHack // (Can cause Infinite loops, SPS, etc...)
#define CHECK_VU_FLAGHACK2 (u32)Config.Hacks.vuFlagHack2 // (Can cause Infinite loops, SPS, etc...)
#define CHECK_VU_MINMAXHACK (u32)Config.Hacks.vuMinMax // (Can cause SPS, Black Screens, etc...) #define CHECK_VU_MINMAXHACK (u32)Config.Hacks.vuMinMax // (Can cause SPS, Black Screens, etc...)
// Unknown Data // Unknown Data

18
pcsx2/x86/microVU_Misc.inl
View File

@ -295,24 +295,6 @@ microVUt(void) mVUrestoreRegs(mV) {
MOV32ItoR(gprR, Roffset); // Restore gprR MOV32ItoR(gprR, Roffset); // Restore gprR
} }
// Reads entire microProgram and finds out if Status Flag is Used
microVUt(void) mVUcheckSflag(mV, int progIndex) {
if (CHECK_VU_FLAGHACK1) {
int bFlagInfo = mVUflagInfo;
int bCode = mVU->code;
int bFlagHack = mVUsFlagHack;
mVUsFlagHack = 1;
for (u32 i = 0; i < mVU->progSize; i+=2) {
mVU->code = mVU->prog.prog[progIndex].data[i];
mVUopL(mVU, 3);
}
mVUflagInfo = bFlagInfo;
mVU->code = bCode;
mVU->prog.prog[progIndex].sFlagHack = mVUsFlagHack;
mVUsFlagHack = bFlagHack;
}
}
static const u32 PCSX2_ALIGNED16(MIN_MAX_MASK1[4]) = {0xffffffff, 0x80000000, 0xffffffff, 0x80000000}; static const u32 PCSX2_ALIGNED16(MIN_MAX_MASK1[4]) = {0xffffffff, 0x80000000, 0xffffffff, 0x80000000};
static const u32 PCSX2_ALIGNED16(MIN_MAX_MASK2[4]) = {0x00000000, 0x40000000, 0x00000000, 0x40000000}; static const u32 PCSX2_ALIGNED16(MIN_MAX_MASK2[4]) = {0x00000000, 0x40000000, 0x00000000, 0x40000000};