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

Removed most of the cluttery code that used PCSX2_VIRTUAL_MEM. Left in various parts of VM code which could be useful for reference in the future. 

git-svn-id: http://pcsx2-playground.googlecode.com/svn/trunk@672 a6443dda-0b58-4228-96e9-037be469359c
This commit is contained in:
Jake.Stine 2009-01-31 10:47:26 +00:00 committed by Gregory Hainaut
parent e8e5eb320a
commit 271eee8dea
26 changed files with 175 additions and 634 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
pcsx2/COP0.cpp
View File

@ -47,16 +47,15 @@ void MapTLB(int i)
u32 mask, addr;
u32 saddr, eaddr;
#ifndef PCSX2_VIRTUAL_MEM
DevCon::WriteLn("MAP TLB %d: %08x-> [%08x %08x] S=%d G=%d ASID=%d Mask= %03X", params
i,tlb[i].VPN2,tlb[i].PFN0,tlb[i].PFN1,tlb[i].S,tlb[i].G,tlb[i].ASID,tlb[i].Mask);
if (tlb[i].S)
{
SysPrintf("OMG SPRAM MAPPING %08X %08X\n",tlb[i].VPN2,tlb[i].Mask);
DevCon::WriteLn("OMG SPRAM MAPPING %08X %08X\n",params tlb[i].VPN2,tlb[i].Mask);
vtlb_VMapBuffer(tlb[i].VPN2,psS,0x4000);
}
#endif
if (tlb[i].VPN2 == 0x70000000) return; //uh uhh right ...
if (tlb[i].EntryLo0 & 0x2) {
@ -92,13 +91,11 @@ void UnmapTLB(int i)
u32 mask, addr;
u32 saddr, eaddr;
#ifndef PCSX2_VIRTUAL_MEM
if (tlb[i].S)
{
vtlb_VMapUnmap(tlb[i].VPN2,0x4000);
return;
}
#endif
if (tlb[i].EntryLo0 & 0x2)
{
@ -142,9 +139,8 @@ void WriteTLB(int i)
tlb[i].G = cpuRegs.CP0.n.EntryLo0 & cpuRegs.CP0.n.EntryLo1 & 0x1;
tlb[i].PFN0 = (((cpuRegs.CP0.n.EntryLo0 >> 6) & 0xFFFFF) & (~tlb[i].Mask)) << 12;
tlb[i].PFN1 = (((cpuRegs.CP0.n.EntryLo1 >> 6) & 0xFFFFF) & (~tlb[i].Mask)) << 12;
#ifndef PCSX2_VIRTUAL_MEM
tlb[i].S = cpuRegs.CP0.n.EntryLo0&0x80000000;
#endif
MapTLB(i);
}

10
pcsx2/Counters.cpp
View File

@ -852,16 +852,6 @@ void SaveState::rcntFreeze()
{
UpdateVSyncRate();
#ifdef PCSX2_VIRTUAL_MEM
// Sanity check for loading older savestates:
if( counters[4].sCycle == 0 )
counters[4].sCycle = cpuRegs.cycle;
if( counters[5].sCycle == 0 )
counters[5].sCycle = cpuRegs.cycle;
#endif
// make sure the gate flags are set based on the counter modes...
for( int i=0; i<4; i++ )
_rcntSetGate( i );

8
pcsx2/GS.cpp
View File

@ -108,12 +108,8 @@ __forceinline void GSVSYNC(void) {
u32 CSRw;
#ifdef PCSX2_VIRTUAL_MEM
#define PS2GS_BASE(mem) ((PS2MEM_BASE+0x12000000)+(mem&0x13ff))
#else
PCSX2_ALIGNED16( u8 g_RealGSMem[0x2000] );
#define PS2GS_BASE(mem) (g_RealGSMem+(mem&0x13ff))
#endif
extern int m_nCounters[];
@ -262,9 +258,7 @@ void gsReset()
UpdateVSyncRate()
);
#ifndef PCSX2_VIRTUAL_MEM
memzero_obj(g_RealGSMem);
#endif
Path3transfer = 0;
@ -298,10 +292,8 @@ bool gsGIFSoftReset( int mask )
void gsGIFReset()
{
#ifndef PCSX2_VIRTUAL_MEM
// fixme - should this be here? (air)
//memzero_obj(g_RealGSMem);
#endif
// perform a soft reset (but do not do a full reset if the soft reset API is unavailable)
gsGIFSoftReset( 7 );

6
pcsx2/GS.h
View File

@ -30,16 +30,10 @@
#define GSPATH3FIX
#ifdef PCSX2_VIRTUAL_MEM
#define GSCSRr *((u64*)(PS2MEM_GS+0x1000))
#define GSIMR *((u32*)(PS2MEM_GS+0x1010))
#define GSSIGLBLID ((GSRegSIGBLID*)(PS2MEM_GS+0x1080))
#else
PCSX2_ALIGNED16( extern u8 g_RealGSMem[0x2000] );
#define GSCSRr *((u64*)(g_RealGSMem+0x1000))
#define GSIMR *((u32*)(g_RealGSMem+0x1010))
#define GSSIGLBLID ((GSRegSIGBLID*)(g_RealGSMem+0x1080))
#endif
/////////////////////////////////////////////////////////////////////////////
// MTGS GIFtag Parser - Declaration

19
pcsx2/Gif.cpp
View File

@ -29,11 +29,7 @@
using std::min;
#ifdef PCSX2_VIRTUAL_MEM
#define gif ((DMACh*)&PS2MEM_HW[0xA000])
#else
#define gif ((DMACh*)&psH[0xA000])
#endif
static u64 s_gstag=0; // used for querying the last tag
static int gspath3done=0;
@ -100,21 +96,6 @@ static void WRITERING_DMA(u32 *pMem, u32 qwc)
// fixed? PrepDataPacket now returns the actual size of the packet.
// VIF handles scratchpad wrapping also, so this code shouldn't be needed anymore.
//vm build still needs this, fixes Fatal Frame init(rama)
#ifdef PCSX2_VIRTUAL_MEM //only do this for vm build, vtlb is fine
u32 pendmem = (u32)gif->madr + sizetoread;
if( dmaGetAddr(pendmem-16) == NULL )
{
pendmem = ((pendmem-16)&~0xfff)-16;
while(dmaGetAddr(pendmem) == NULL)
{
pendmem = (pendmem&~0xfff)-16;
}
memcpy_aligned(pgsmem, pMem, pendmem-(u32)gif->madr+16);
}
else
#endif
memcpy_aligned(pgsmem, pMem, sizetoread<<4);
mtgsThread->SendDataPacket();

14
pcsx2/Hw.cpp
View File

@ -35,9 +35,7 @@
using namespace R5900;
#ifndef PCSX2_VIRTUAL_MEM
u8 *psH; // hw mem
#endif
int rdram_devices = 2; // put 8 for TOOL and 2 for PS2 and PSX
int rdram_sdevid = 0;
@ -1367,7 +1365,7 @@ int hwDmacSrcChain(DMACh *dma, int id) {
}
// Original hwRead/Write32 functions .. left in for now, for troubleshooting purposes.
#if 1
#if 0
mem32_t __fastcall hwRead32(u32 mem)
{
// *Performance Warning* This function is called -A-LOT. Be weary when making changes. It
@ -1811,14 +1809,10 @@ __forceinline void __fastcall hwWrite32(u32 mem, u32 value)
break;
//------------------------------------------------------------------
default:
#ifndef PCSX2_VIRTUAL_MEM
if (mem < 0x10010000)
#endif
{
psHu32(mem) = value;
}
psHu32(mem) = value;
HW_LOG("Unknown Hardware write 32 at %x with value %x (%x)\n", mem, value, cpuRegs.CP0.n.Status.val);
break;
}
}
#endif
#endif

7
pcsx2/Hw.h
View File

@ -19,9 +19,7 @@
#ifndef __HW_H__
#define __HW_H__
#ifndef PCSX2_VIRTUAL_MEM
extern u8 *psH; // hw mem
#endif
#define psHs8(mem) (*(s8 *)&PS2MEM_HW[(mem) & 0xffff])
#define psHs16(mem) (*(s16*)&PS2MEM_HW[(mem) & 0xffff])
@ -308,6 +306,7 @@ struct DMACh {
extern PSMEMORYMAP* memLUT;
#endif
// VM-version of dmaGetAddr -- Left in for references purposes for now (air)
static __forceinline u8* dmaGetAddr(u32 mem)
{
u8* p, *pbase;
@ -414,10 +413,6 @@ void hwConstWrite32(u32 mem, int mmreg);
void hwConstWrite64(u32 mem, int mmreg);
void hwConstWrite128(u32 mem, int xmmreg);
#ifdef PCSX2_VIRTUAL_MEM
void iMemRead32Check();
#endif
extern void intcInterrupt();
extern void dmacInterrupt();

4
pcsx2/IPU/IPU.cpp
View File

@ -48,9 +48,7 @@ using namespace std; // for min / max
# define IPU_FORCEINLINE __forceinline
#endif
#ifndef PCSX2_VIRTUAL_MEM
IPUregisters g_ipuRegsReal;
#endif
//IPUregisters g_ipuRegsReal;
#define ipu0dma ((DMACh *)&PS2MEM_HW[0xb000])
#define ipu1dma ((DMACh *)&PS2MEM_HW[0xb400])

51
pcsx2/IopCounters.cpp
View File

@ -720,58 +720,7 @@ u64 psxRcntCycles(int index)
void SaveState::psxRcntFreeze()
{
#ifdef PCSX2_VIRTUAL_MEM
if( IsLoading() && (GetVersion() < 0x10) )
{
// --- Reading Mode, Old Version ---
// struct used to be 32bit count and target
int i;
u32 val;
for(i = 0; i < ARRAYSIZE(psxCounters); ++i)
{
Freeze(val); psxCounters[i].count = val;
Freeze(val); psxCounters[i].mode = val;
Freeze(val); psxCounters[i].target = val;
FreezeMem((u8*)&psxCounters[i].rate, sizeof(psxCounters[i])-20);
}
}
else
{
Freeze(psxCounters);
// new in v.11
if( GetVersion() > 0x10 )
{
Freeze(psxNextCounter);
Freeze(psxNextsCounter);
}
}
if( IsLoading() && (GetVersion() <= 0x10) )
{
psxNextCounter = 0;
psxNextsCounter = psxRegs.cycle;
// This is needed to make old save states compatible.
psxCounters[6].rate = 768*12;
psxCounters[6].CycleT = psxCounters[6].rate;
psxCounters[7].rate = PSXCLK/1000;
psxCounters[7].CycleT = psxCounters[7].rate;
// PSXHBLANK is now an arbitrary value, since it can differ based
// on PAL/NTSC and is timed by the EE.
if(psxCounters[1].mode & IOPCNT_ALT_SOURCE)
psxCounters[1].rate = PSXHBLANK;
if(psxCounters[3].mode & IOPCNT_ALT_SOURCE)
psxCounters[3].rate = PSXHBLANK;
}
#else
// vTLB's new savestate version! :D
Freeze(psxCounters);
Freeze(psxNextCounter);
Freeze(psxNextsCounter);
#endif
}

15
pcsx2/IopMem.h
View File

@ -19,18 +19,6 @@
#ifndef __PSXMEMORY_H__
#define __PSXMEMORY_H__
#ifdef PCSX2_VIRTUAL_MEM
// VM
#define psxM PS2MEM_PSX
#define psxH PS2MEM_PSXHW
#define PSXM(mem) ((mem&0x10000000)?PSM(mem):(PS2MEM_PSX+(mem&0x1fffff)))
#define _PSXM(mem) PSXM(mem)
#else
// TLB
extern u8 *psxM;
extern u8 *psxP;
extern u8 *psxH;
@ -38,7 +26,6 @@ extern u8 *psxS;
extern uptr *psxMemWLUT;
extern const uptr *psxMemRLUT;
//#define TLB_DEBUG_MEM
#ifdef TLB_DEBUG_MEM
void* PSXM(u32 mem);
void* _PSXM(u32 mem);
@ -54,8 +41,6 @@ void* _PSXM(u32 mem);
#define psxSu16(mem) (*(u16*)&psxS[(mem) & 0xffff])
#define psxSu32(mem) (*(u32*)&psxS[(mem) & 0xffff])
#endif
#define psxMs8(mem) psxM[(mem) & 0x1fffff]
#define psxMs16(mem) (*(s16*)&psxM[(mem) & 0x1fffff])
#define psxMs32(mem) (*(s32*)&psxM[(mem) & 0x1fffff])

4
pcsx2/Memory.cpp
View File

@ -130,8 +130,6 @@ void loadBiosRom( const char *ext, u8 *dest, long maxSize )
fclose(fp);
}
#ifndef PCSX2_VIRTUAL_MEM
u32 psMPWC[(Ps2MemSize::Base/32)>>12];
std::vector<u32> psMPWVA[Ps2MemSize::Base>>12];
@ -907,5 +905,3 @@ __forceinline void __fastcall SysPageFaultExceptionFilter( int signal, siginfo_t
psMPWVA[offset].clear();
}
#endif
#endif

314
pcsx2/Memory.h
View File

@ -45,6 +45,163 @@ namespace Ps2MemSize
static const uint GSregs = 0x00002000; // 8k for the GS registers and stuff.
}
extern u8 *psM; //32mb Main Ram
extern u8 *psR; //4mb rom area
extern u8 *psR1; //256kb rom1 area (actually 196kb, but can't mask this)
extern u8 *psR2; // 0x00080000
extern u8 *psER; // 0x001C0000
extern u8 *psS; //0.015 mb, scratch pad
#define PS2MEM_BASE psM
#define PS2MEM_HW psH
#define PS2MEM_ROM psR
#define PS2MEM_ROM1 psR1
#define PS2MEM_ROM2 psR2
#define PS2MEM_EROM psER
#define PS2MEM_SCRATCH psS
extern u8 g_RealGSMem[0x2000];
#define PS2MEM_GS g_RealGSMem
//#define _PSM(mem) (memLUTR[(mem) >> 12] == 0 ? NULL : (void*)(memLUTR[(mem) >> 12] + ((mem) & 0xfff)))
#define PSM(mem) (vtlb_GetPhyPtr(mem&0x1fffffff)) //pcsx2 is a competition.The one with most hacks wins :D
#define FREE(ptr) _aligned_free(ptr)
#define psMs8(mem) (*(s8 *)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMs16(mem) (*(s16*)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMs32(mem) (*(s32*)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMs64(mem) (*(s64*)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMu8(mem) (*(u8 *)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMu16(mem) (*(u16*)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMu32(mem) (*(u32*)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMu64(mem) (*(u64*)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psRs8(mem) (*(s8 *)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRs16(mem) (*(s16*)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRs32(mem) (*(s32*)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRs64(mem) (*(s64*)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRu8(mem) (*(u8 *)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRu16(mem) (*(u16*)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRu32(mem) (*(u32*)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRu64(mem) (*(u64*)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psR1s8(mem) (*(s8 *)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1s16(mem) (*(s16*)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1s32(mem) (*(s32*)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1s64(mem) (*(s64*)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1u8(mem) (*(u8 *)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1u16(mem) (*(u16*)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1u32(mem) (*(u32*)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1u64(mem) (*(u64*)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR2s8(mem) (*(s8 *)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2s16(mem) (*(s16*)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2s32(mem) (*(s32*)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2s64(mem) (*(s64*)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2u8(mem) (*(u8 *)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2u16(mem) (*(u16*)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2u32(mem) (*(u32*)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2u64(mem) (*(u64*)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psERs8(mem) (*(s8 *)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERs16(mem) (*(s16*)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERs32(mem) (*(s32*)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERs64(mem) (*(s64*)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERu8(mem) (*(u8 *)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERu16(mem) (*(u16*)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERu32(mem) (*(u32*)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERu64(mem) (*(u64*)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psSs8(mem) (*(s8 *)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSs16(mem) (*(s16*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSs32(mem) (*(s32*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSs64(mem) (*(s64*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSu8(mem) (*(u8 *)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSu16(mem) (*(u16*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSu32(mem) (*(u32*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSu64(mem) (*(u64*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define PSMs8(mem) (*(s8 *)PSM(mem))
#define PSMs16(mem) (*(s16*)PSM(mem))
#define PSMs32(mem) (*(s32*)PSM(mem))
#define PSMs64(mem) (*(s64*)PSM(mem))
#define PSMu8(mem) (*(u8 *)PSM(mem))
#define PSMu16(mem) (*(u16*)PSM(mem))
#define PSMu32(mem) (*(u32*)PSM(mem))
#define PSMu64(mem) (*(u64*)PSM(mem))
extern void memAlloc();
extern void memReset(); // clears PS2 ram and loads the bios. Throws Exception::FileNotFound on error.
extern void memShutdown();
extern void memSetKernelMode();
extern void memSetSupervisorMode();
extern void memSetUserMode();
extern void memSetPageAddr(u32 vaddr, u32 paddr);
extern void memClearPageAddr(u32 vaddr);
extern void memMapVUmicro();
#ifdef __LINUX__
void SysPageFaultExceptionFilter( int signal, siginfo_t *info, void * );
void __fastcall InstallLinuxExceptionHandler();
void __fastcall ReleaseLinuxExceptionHandler();
#else
int SysPageFaultExceptionFilter(EXCEPTION_POINTERS* eps);
#endif
#include "vtlb.h"
int mmap_GetRamPageInfo(void* ptr);
void mmap_MarkCountedRamPage(void* ptr,u32 vaddr);
void mmap_ResetBlockTracking();
extern void __fastcall memRead8(u32 mem, u8 *out);
extern void __fastcall memRead16(u32 mem, u16 *out);
extern void __fastcall memRead32(u32 mem, u32 *out);
#define memRead64 vtlb_memRead64
#define memRead128 vtlb_memRead128
#define memWrite8 vtlb_memWrite8
#define memWrite16 vtlb_memWrite16
#define memWrite32 vtlb_memWrite32
#define memWrite64 vtlb_memWrite64
#define memWrite128 vtlb_memWrite128
#define _eeReadConstMem8 0&&
#define _eeReadConstMem16 0&&
#define _eeReadConstMem32 0&&
#define _eeReadConstMem128 0&&
#define _eeWriteConstMem8 0&&
#define _eeWriteConstMem16 0&&
#define _eeWriteConstMem32 0&&
#define _eeWriteConstMem64 0&&
#define _eeWriteConstMem128 0&&
#define _eeMoveMMREGtoR 0&&
// extra ops
#define _eeWriteConstMem16OP 0&&
#define _eeWriteConstMem32OP 0&&
#define recMemConstRead8 0&&
#define recMemConstRead16 0&&
#define recMemConstRead32 0&&
#define recMemConstRead64 0&&
#define recMemConstRead128 0&&
#define recMemConstWrite8 0&&
#define recMemConstWrite16 0&&
#define recMemConstWrite32 0&&
#define recMemConstWrite64 0&&
#define recMemConstWrite128 0&&
extern void loadBiosRom( const char *ext, u8 *dest, long maxSize );
extern u16 ba0R16(u32 mem);
//////////////////////////////////////////////////////////////////////////
// The rest of this header contains the old VM version of the Memory.h API.
// Left in for references purposes.
#ifdef PCSX2_VIRTUAL_MEM
#define PS2MEM_BASE_ 0x15000000
@ -142,163 +299,6 @@ int recMemConstWrite16(u32 mem, int mmreg);
int recMemConstWrite32(u32 mem, int mmreg);
int recMemConstWrite64(u32 mem, int mmreg);
int recMemConstWrite128(u32 mem, int xmmreg);
#else
extern u8 *psM; //32mb Main Ram
extern u8 *psR; //4mb rom area
extern u8 *psR1; //256kb rom1 area (actually 196kb, but can't mask this)
extern u8 *psR2; // 0x00080000
extern u8 *psER; // 0x001C0000
extern u8 *psS; //0.015 mb, scratch pad
#define PS2MEM_BASE psM
#define PS2MEM_HW psH
#define PS2MEM_ROM psR
#define PS2MEM_ROM1 psR1
#define PS2MEM_ROM2 psR2
#define PS2MEM_EROM psER
#define PS2MEM_SCRATCH psS
extern u8 g_RealGSMem[0x2000];
#define PS2MEM_GS g_RealGSMem
//#define _PSM(mem) (memLUTR[(mem) >> 12] == 0 ? NULL : (void*)(memLUTR[(mem) >> 12] + ((mem) & 0xfff)))
#define PSM(mem) (vtlb_GetPhyPtr(mem&0x1fffffff)) //pcsx2 is a competition.The one with most hacks wins :D
#define FREE(ptr) _aligned_free(ptr)
#endif
#define psMs8(mem) (*(s8 *)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMs16(mem) (*(s16*)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMs32(mem) (*(s32*)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMs64(mem) (*(s64*)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMu8(mem) (*(u8 *)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMu16(mem) (*(u16*)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMu32(mem) (*(u32*)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psMu64(mem) (*(u64*)&PS2MEM_BASE[(mem) & 0x1ffffff])
#define psRs8(mem) (*(s8 *)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRs16(mem) (*(s16*)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRs32(mem) (*(s32*)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRs64(mem) (*(s64*)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRu8(mem) (*(u8 *)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRu16(mem) (*(u16*)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRu32(mem) (*(u32*)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psRu64(mem) (*(u64*)&PS2MEM_ROM[(mem) & 0x3fffff])
#define psR1s8(mem) (*(s8 *)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1s16(mem) (*(s16*)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1s32(mem) (*(s32*)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1s64(mem) (*(s64*)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1u8(mem) (*(u8 *)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1u16(mem) (*(u16*)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1u32(mem) (*(u32*)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR1u64(mem) (*(u64*)&PS2MEM_ROM1[(mem) & 0x3ffff])
#define psR2s8(mem) (*(s8 *)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2s16(mem) (*(s16*)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2s32(mem) (*(s32*)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2s64(mem) (*(s64*)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2u8(mem) (*(u8 *)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2u16(mem) (*(u16*)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2u32(mem) (*(u32*)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psR2u64(mem) (*(u64*)&PS2MEM_ROM2[(mem) & 0x3ffff])
#define psERs8(mem) (*(s8 *)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERs16(mem) (*(s16*)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERs32(mem) (*(s32*)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERs64(mem) (*(s64*)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERu8(mem) (*(u8 *)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERu16(mem) (*(u16*)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERu32(mem) (*(u32*)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psERu64(mem) (*(u64*)&PS2MEM_EROM[(mem) & 0x3ffff])
#define psSs8(mem) (*(s8 *)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSs16(mem) (*(s16*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSs32(mem) (*(s32*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSs64(mem) (*(s64*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSu8(mem) (*(u8 *)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSu16(mem) (*(u16*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSu32(mem) (*(u32*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define psSu64(mem) (*(u64*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
#define PSMs8(mem) (*(s8 *)PSM(mem))
#define PSMs16(mem) (*(s16*)PSM(mem))
#define PSMs32(mem) (*(s32*)PSM(mem))
#define PSMs64(mem) (*(s64*)PSM(mem))
#define PSMu8(mem) (*(u8 *)PSM(mem))
#define PSMu16(mem) (*(u16*)PSM(mem))
#define PSMu32(mem) (*(u32*)PSM(mem))
#define PSMu64(mem) (*(u64*)PSM(mem))
extern void memAlloc();
extern void memReset(); // clears PS2 ram and loads the bios. Throws Exception::FileNotFound on error.
extern void memShutdown();
extern void memSetKernelMode();
extern void memSetSupervisorMode();
extern void memSetUserMode();
extern void memSetPageAddr(u32 vaddr, u32 paddr);
extern void memClearPageAddr(u32 vaddr);
extern void memMapVUmicro();
#ifdef __LINUX__
void SysPageFaultExceptionFilter( int signal, siginfo_t *info, void * );
void __fastcall InstallLinuxExceptionHandler();
void __fastcall ReleaseLinuxExceptionHandler();
#else
int SysPageFaultExceptionFilter(EXCEPTION_POINTERS* eps);
#endif
#ifndef PCSX2_VIRTUAL_MEM
#include "vtlb.h"
int mmap_GetRamPageInfo(void* ptr);
void mmap_MarkCountedRamPage(void* ptr,u32 vaddr);
void mmap_ResetBlockTracking();
extern void __fastcall memRead8(u32 mem, u8 *out);
extern void __fastcall memRead16(u32 mem, u16 *out);
extern void __fastcall memRead32(u32 mem, u32 *out);
#define memRead64 vtlb_memRead64
#define memRead128 vtlb_memRead128
#define memWrite8 vtlb_memWrite8
#define memWrite16 vtlb_memWrite16
#define memWrite32 vtlb_memWrite32
#define memWrite64 vtlb_memWrite64
#define memWrite128 vtlb_memWrite128
#define _eeReadConstMem8 0&&
#define _eeReadConstMem16 0&&
#define _eeReadConstMem32 0&&
#define _eeReadConstMem128 0&&
#define _eeWriteConstMem8 0&&
#define _eeWriteConstMem16 0&&
#define _eeWriteConstMem32 0&&
#define _eeWriteConstMem64 0&&
#define _eeWriteConstMem128 0&&
#define _eeMoveMMREGtoR 0&&
// extra ops
#define _eeWriteConstMem16OP 0&&
#define _eeWriteConstMem32OP 0&&
#define recMemConstRead8 0&&
#define recMemConstRead16 0&&
#define recMemConstRead32 0&&
#define recMemConstRead64 0&&
#define recMemConstRead128 0&&
#define recMemConstWrite8 0&&
#define recMemConstWrite16 0&&
#define recMemConstWrite32 0&&
#define recMemConstWrite64 0&&
#define recMemConstWrite128 0&&
#endif
extern void loadBiosRom( const char *ext, u8 *dest, long maxSize );
extern u16 ba0R16(u32 mem);
#endif

2
pcsx2/R5900.h
View File

@ -146,9 +146,7 @@ struct tlbs
u32 VPN2;
u32 PFN0;
u32 PFN1;
#ifndef PCSX2_VIRTUAL_MEM
u32 S;
#endif
};
#ifndef _PC_

39
pcsx2/SaveState.cpp
View File

@ -44,28 +44,11 @@ extern void recResetIOP();
static void PreLoadPrep()
{
SysResetExecutionState();
#ifdef PCSX2_VIRTUAL_MEM
DWORD OldProtect;
// make sure can write
VirtualProtect(PS2MEM_ROM, 0x00400000, PAGE_READWRITE, &OldProtect);
VirtualProtect(PS2MEM_ROM1, 0x00040000, PAGE_READWRITE, &OldProtect);
VirtualProtect(PS2MEM_ROM2, 0x00080000, PAGE_READWRITE, &OldProtect);
VirtualProtect(PS2MEM_EROM, 0x001C0000, PAGE_READWRITE, &OldProtect);
#endif
}
static void PostLoadPrep()
{
#ifdef PCSX2_VIRTUAL_MEM
DWORD OldProtect;
VirtualProtect(PS2MEM_ROM, 0x00400000, PAGE_READONLY, &OldProtect);
VirtualProtect(PS2MEM_ROM1, 0x00040000, PAGE_READONLY, &OldProtect);
VirtualProtect(PS2MEM_ROM2, 0x00080000, PAGE_READONLY, &OldProtect);
VirtualProtect(PS2MEM_EROM, 0x001C0000, PAGE_READONLY, &OldProtect);
#endif
memset(pCache,0,sizeof(pCache));
memzero_obj(pCache);
// WriteCP0Status(cpuRegs.CP0.n.Status.val);
for(int i=0; i<48; i++) MapTLB(i);
}
@ -114,12 +97,6 @@ void SaveState::FreezeAll()
if( IsLoading() )
PreLoadPrep();
#ifdef PCSX2_VIRTUAL_MEM
// VM Builds require the exception handler during memInit/Reset operations and
// during the savestate load/save code.
PCSX2_MEM_PROTECT_BEGIN();
#endif
FreezeMem(PS2MEM_BASE, Ps2MemSize::Base); // 32 MB main memory
FreezeMem(PS2MEM_ROM, Ps2MemSize::Rom); // 4 mb rom memory
FreezeMem(PS2MEM_ROM1, Ps2MemSize::Rom1); // 256kb rom1 memory
@ -169,10 +146,6 @@ void SaveState::FreezeAll()
FreezePlugin( "DEV9", DEV9freeze );
FreezePlugin( "USB", USBfreeze );
#ifdef PCSX2_VIRTUAL_MEM
PCSX2_MEM_PROTECT_END();
#endif
if( IsLoading() )
PostLoadPrep();
}
@ -231,15 +204,6 @@ gzLoadingState::gzLoadingState( const string& filename ) :
if( m_version != g_SaveVersion )
{
#ifdef PCSX2_VIRTUAL_MEM
if( m_version >= 0x8b400000 )
{
throw Exception::UnsupportedStateVersion( m_version, "VM edition cannot safely load savestates created by the VTLB edition." );
}
// pcsx2 vm supports opening these formats
if( m_version < 0x7a30000d )
throw Exception::UnsupportedStateVersion( m_version );
#else
if( ( m_version >> 16 ) == 0x7a30 )
{
Console::Error(
@ -247,7 +211,6 @@ gzLoadingState::gzLoadingState( const string& filename ) :
"\tVTLB edition cannot safely load savestates created by the VM edition." );
throw Exception::UnsupportedStateVersion( m_version );
}
#endif
}
_testCdvdCrc();

8
pcsx2/SaveState.h
View File

@ -29,11 +29,7 @@
// Savestate Versioning!
// If you make changes to the savestate version, please increment the value below.
#ifdef PCSX2_VIRTUAL_MEM
static const u32 g_SaveVersion = 0x7a300012;
#else
static const u32 g_SaveVersion = 0x8b400002;
#endif
// this function is meant to be sued in the place of GSfreeze, and provides a safe layer
// between the GS saving function and the MTGS's needs. :)
@ -59,12 +55,8 @@ public:
// The version refers to the low 16 bits only (high 16 bits classifies Pcsx2 build types)
u32 GetVersion() const
{
#ifdef PCSX2_VIRTUAL_MEM
return m_version & 0xffff;
#else
// HACK! Matches the vTLB build versions with VM
return (m_version & 0xffff) + 0x10;
#endif
}
// Loads or saves the entire emulation state.

29
pcsx2/System.cpp
View File

@ -175,37 +175,8 @@ bool SysAllocateMem()
// completely non-functional. If the failure is in the VM build then we can try running
// the VTLB build instead. If it's the VTLB build then ... ouch.
#ifdef PCSX2_VIRTUAL_MEM
Console::Error( ex.cMessage() );
if( MessageBox(NULL,
"Failed to allocate enough physical memory to run pcsx2. Try closing\n"
"down background programs, restarting windows, or buying more memory.\n\n"
"Launch TLB version of pcsx2 (pcsx2t.exe)?", "Memory Allocation Error", MB_YESNO) == IDYES )
{
PROCESS_INFORMATION pi;
STARTUPINFO si;
MemoryAlloc<char> strdir( GetCurrentDirectory( 0, NULL )+2, "VTLB Launcher" );
string strexe;
GetCurrentDirectory(strdir.GetLength(), strdir.GetPtr());
Path::Combine( strexe, strdir.GetPtr(), "pcsx2-vtlb.exe" );
memset(&si, 0, sizeof(si));
if( !CreateProcess(strexe.c_str(), "", NULL, NULL, FALSE, DETACHED_PROCESS|CREATE_NEW_PROCESS_GROUP, NULL, strdir.GetPtr(), &si, &pi))
{
MessageBox(NULL, fmt_string( "Failed to launch %hs\n", &strexe ).c_str(), "Failure", MB_OK);
}
else
{
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
}
#else
// VTLB build must fail outright...
Msgbox::Alert( "Failed to allocate memory needed to run pcsx2.\n\nError: %s", params ex.cMessage() );
#endif
SysShutdownMem();
return false;

28
pcsx2/System.h
View File

@ -210,32 +210,4 @@ using Console::Color_White;
#endif
#ifdef PCSX2_VIRTUAL_MEM
struct PSMEMORYBLOCK
{
#ifdef _WIN32
int NumberPages;
uptr* aPFNs;
uptr* aVFNs; // virtual pages that own the physical pages
#else
int fd; // file descriptor
char* pname; // given name
int size; // size of allocated region
#endif
};
int SysPhysicalAlloc(u32 size, PSMEMORYBLOCK* pblock);
void SysPhysicalFree(PSMEMORYBLOCK* pblock);
int SysVirtualPhyAlloc(void* base, u32 size, PSMEMORYBLOCK* pblock);
void SysVirtualFree(void* lpMemReserved, u32 size);
// returns 1 if successful, 0 otherwise
int SysMapUserPhysicalPages(void* Addr, uptr NumPages, uptr* pblock, int pageoffset);
// call to enable physical page allocation
//BOOL SysLoggedSetLockPagesPrivilege ( HANDLE hProcess, BOOL bEnable);
#endif
#endif /* __SYSTEM_H__ */

4
pcsx2/VU1micro.cpp
View File

@ -32,10 +32,6 @@
VURegs* g_pVU1;
#ifdef PCSX2_VIRTUAL_MEM
extern PSMEMORYBLOCK s_psVuMem;
#endif
#ifdef _DEBUG
u32 vudump = 0;
#endif

71
pcsx2/VUmicroMem.cpp
View File

@ -26,11 +26,6 @@
#include "iVUzerorec.h"
#ifdef PCSX2_VIRTUAL_MEM
extern PSMEMORYBLOCK s_psVuMem;
extern PSMEMORYMAP *memLUT;
#endif
// The following CpuVU objects are value types instead of handles or pointers because they are
// modified on the fly to implement VU1 Skip.
@ -87,54 +82,6 @@ static const uint m_vuMemSize =
void vuMicroMemAlloc()
{
#ifdef PCSX2_VIRTUAL_MEM
jASSUME( memLUT != NULL ); // memAlloc() must always be called first, thanks.
// unmap all vu0 pages
SysMapUserPhysicalPages(PS2MEM_VU0MICRO, 16, NULL, 0);
// mirror 4 times
VU0.Micro = PS2MEM_VU0MICRO;
// since vuregisters are mapped in vumem0, go to diff addr, but mapping to same physical addr
//VirtualFree((void*)0x11000000, 0x10000, MEM_RELEASE); // free just in case
bool vu1_reassign = false;
if( VU0.Mem == NULL )
{
VU0.Mem = (u8*)VirtualAlloc((void*)0x11000000, 0x10000, MEM_RESERVE|MEM_PHYSICAL, PAGE_READWRITE);
vu1_reassign = true;
}
if( VU0.Mem != (void*)0x11000000 )
{
VU0.Mem = NULL;
throw Exception::OutOfMemory(
fmt_string( "Failed to alloc vu0mem 0x11000000 %d", GetLastError() )
);
}
memLUT[0x11004].aPFNs = &s_psVuMem.aPFNs[1]; memLUT[0x11004].aVFNs = &s_psVuMem.aVFNs[1];
memLUT[0x11005].aPFNs = &s_psVuMem.aPFNs[1]; memLUT[0x11005].aVFNs = &s_psVuMem.aVFNs[1];
memLUT[0x11006].aPFNs = &s_psVuMem.aPFNs[1]; memLUT[0x11006].aVFNs = &s_psVuMem.aVFNs[1];
memLUT[0x11007].aPFNs = &s_psVuMem.aPFNs[1]; memLUT[0x11007].aVFNs = &s_psVuMem.aVFNs[1];
// map only registers
SysMapUserPhysicalPages(VU0.Mem+0x4000, 1, s_psVuMem.aPFNs, 2);
if( vu1_reassign )
{
// Initialize VU1 memory using VU0's allocations:
// Important! VU1 is actually a macro to g_pVU1 (yes, awkward!) so we need to assign it first.
g_pVU1 = (VURegs*)(VU0.Mem + 0x4000);
VU1.Mem = PS2MEM_VU1MEM;
VU1.Micro = PS2MEM_VU1MICRO;
}
#else
// -- VTLB Memory Allocation --
if( m_vuAllMem == NULL )
m_vuAllMem = vtlb_malloc( m_vuMemSize, 16, 0x28000000 );
@ -149,33 +96,15 @@ void vuMicroMemAlloc()
VU0.Micro = curpos; curpos += 0x1000;
VU1.Mem = curpos; curpos += 0x4000;
VU1.Micro = curpos; //curpos += 0x4000;
#endif
}
void vuMicroMemShutdown()
{
#ifdef PCSX2_VIRTUAL_MEM
if( VU0.Mem != NULL )
{
if( !SysMapUserPhysicalPages(VU0.Mem, 16, NULL, 0) )
Console::Error("Error releasing vu0 memory %d", params GetLastError());
if( VirtualFree(VU0.Mem, 0, MEM_RELEASE) == 0 )
Console::Error("Error freeing vu0 memory %d", params GetLastError());
}
VU0.Mem = NULL;
VU0.Micro = NULL;
#else
// -- VTLB Memory Allocation --
vtlb_free( m_vuAllMem, m_vuMemSize );
m_vuAllMem = NULL;
g_pVU1 = NULL;
#endif
}
void vuMicroMemReset()

4
pcsx2/vtlb.cpp
View File

@ -33,8 +33,6 @@
#include "PrecompiledHeader.h"
#ifndef PCSX2_VIRTUAL_MEM
#include "Common.h"
#include "vtlb.h"
#include "COP0.h"
@ -591,5 +589,3 @@ void vtlb_free( void* pmem, uint size )
safe_aligned_free( pmem );
#endif
}
#endif // PCSX2_VIRTUAL_MEM

6
pcsx2/vtlb.h
View File

@ -1,10 +1,6 @@
#ifndef _VTLB_H_
#define _VTLB_H_
#include <xmmintrin.h>
#ifndef PCSX2_VIRTUAL_MEM
typedef u8 mem8_t;
typedef u16 mem16_t;
typedef u32 mem32_t;
@ -81,5 +77,3 @@ namespace vtlb_private
}
#endif
#endif

25
pcsx2/windows/WinMain.cpp
View File

@ -182,10 +182,6 @@ void WinClose()
SysShutdownDynarecs();
SysShutdownMem();
#ifdef PCSX2_VIRTUAL_MEM
VirtualFree(PS2MEM_BASE, 0, MEM_RELEASE);
#endif
}
BOOL SysLoggedSetLockPagesPrivilege ( HANDLE hProcess, BOOL bEnable);
@ -308,23 +304,6 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
CreateDirectory(LOGS_DIR, NULL);
#ifdef PCSX2_VIRTUAL_MEM
LPVOID lpMemReserved;
if( !SysLoggedSetLockPagesPrivilege( GetCurrentProcess(), TRUE ) )
return -1;
lpMemReserved = VirtualAlloc(PS2MEM_BASE, 0x40000000, MEM_RESERVE, PAGE_NOACCESS);
if( lpMemReserved == NULL || lpMemReserved!= PS2MEM_BASE ) {
char str[255];
sprintf(str, "Cannot allocate mem addresses %x-%x, err: %d", PS2MEM_BASE, PS2MEM_BASE+0x40000000, GetLastError());
MessageBox(NULL, str, "SysError", MB_OK);
return -1;
}
#endif
InitCommonControls();
pInstance=hInstance;
FirstShow=true; // this is used by cheats.cpp to search for stuff (broken?)
@ -1087,11 +1066,7 @@ void CreateMainWindow(int nCmdShow) {
GetObject(hbitmap_background, sizeof(bm), &bm);
{
#ifdef PCSX2_VIRTUAL_MEM
const char* pvm = "VM";
#else
const char* pvm = "VTLB";
#endif
#ifdef PCSX2_DEVBUILD
sprintf(buf, _("PCSX2 %s - %s Compile Date - %s %s"), PCSX2_VERSION, pvm, COMPILEDATE, COMPILER);

9
pcsx2/windows/cheats/cheats.cpp
View File

@ -69,11 +69,7 @@ char tn[100];
char to[100];
char tv[100];
#ifdef PCSX2_VIRTUAL_MEM
u8 *mptr[2]={PS2MEM_BASE,PS2MEM_PSX};
#else
u8 *mptr[2];
#endif
int msize[2]={0x02000000,0x00200000};
@ -437,13 +433,10 @@ BOOL CALLBACK FinderProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
case WM_PAINT:
INIT_CHECK(IDC_UNSIGNED,Unsigned);
return FALSE;
case WM_INITDIALOG:
#ifndef PCSX2_VIRTUAL_MEM
case WM_INITDIALOG:
mptr[0]=psM;
mptr[1]=psxM;
#endif
hWndFinder=hWnd;

4
pcsx2/x86/iGS.cpp
View File

@ -27,12 +27,8 @@
#include "GS.h"
#include "DebugTools/Debug.h"
#ifdef PCSX2_VIRTUAL_MEM
#define PS2GS_BASE(mem) ((PS2MEM_BASE+0x12000000)+(mem&0x13ff))
#else
extern u8 g_RealGSMem[0x2000];
#define PS2GS_BASE(mem) (g_RealGSMem+(mem&0x13ff))
#endif
// __thiscall -- Calling Convention Notes.

98
pcsx2/x86/iHw.cpp
View File

@ -33,10 +33,6 @@
#include "Sif.h"
#ifndef PCSX2_VIRTUAL_MEM
extern u8 *psH; // hw mem
#endif
extern int rdram_devices; // put 8 for TOOL and 2 for PS2 and PSX
extern int rdram_sdevid;
extern char sio_buffer[1024];
@ -192,65 +188,6 @@ int hwConstRead16(u32 x86reg, u32 mem, u32 sign)
}
}
#ifdef PCSX2_VIRTUAL_MEM
//
//#if defined(_MSC_VER)
//__declspec(naked) void recCheckF440()
//{
// __asm {
// add b440, 1
// mov eax, b440
// sub eax, 3
// mov edx, 31
//
// cmp eax, 27
// ja WriteVal
// shl eax, 2
// mov edx, dword ptr [eax+b440table]
//
//WriteVal:
// mov eax, PS2MEM_BASE_+0x1000f440
// mov dword ptr [eax], edx
// ret
// }
//}
//#else
//void recCheckF440();
//#endif
void iMemRead32Check()
{
// test if 0xf440
// if( bExecBIOS ) {
// u8* ptempptr[2];
// CMP32ItoR(ECX, 0x1000f440);
// ptempptr[0] = JNE8(0);
//
//// // increment and test
//// INC32M((uptr)&b440);
//// MOV32MtoR(EAX, (uptr)&b440);
//// SUB32ItoR(EAX, 3);
//// MOV32ItoR(EDX, 31);
////
//// CMP32ItoR(EAX, 27);
////
//// // look up table
//// ptempptr[1] = JA8(0);
//// SHL32ItoR(EAX, 2);
//// ADD32ItoR(EAX, (int)b440table);
//// MOV32RmtoR(EDX, EAX);
////
//// x86SetJ8( ptempptr[1] );
////
//// MOV32RtoM( (int)PS2MEM_HW+0xf440, EDX);
// CALLFunc((uptr)recCheckF440);
//
// x86SetJ8( ptempptr[0] );
// }
}
#endif
int hwContRead32_f440()
{
if ((psHu32(0xf430) >> 6) & 0xF)
@ -636,15 +573,7 @@ void hwConstWrite8(u32 mem, int mmreg)
case 0x1000f430:
break;
default:
#ifdef PCSX2_VIRTUAL_MEM
//NOTE: this might cause crashes, but is more correct
_eeWriteConstMem8((u32)PS2MEM_BASE + mem, mmreg);
#else
if (mem < 0x10010000)
{
_eeWriteConstMem8((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
}
#endif
_eeWriteConstMem8((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
}
break;
@ -793,15 +722,7 @@ void hwConstWrite16(u32 mem, int mmreg)
return;
}
#ifdef PCSX2_VIRTUAL_MEM
//NOTE: this might cause crashes, but is more correct
_eeWriteConstMem16((u32)PS2MEM_BASE + mem, mmreg);
#else
if (mem < 0x10010000)
{
_eeWriteConstMem16((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
}
#endif
}
}
@ -1087,15 +1008,7 @@ void hwConstWrite32(u32 mem, int mmreg)
return;
}
#ifdef PCSX2_VIRTUAL_MEM
//NOTE: this might cause crashes, but is more correct
_eeWriteConstMem32((u32)PS2MEM_BASE + mem, mmreg);
#else
if (mem < 0x10010000)
{
_eeWriteConstMem32((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
}
#endif
_eeWriteConstMem32((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
break;
}
}
@ -1234,12 +1147,7 @@ void hwConstWrite128(u32 mem, int mmreg)
default:
#ifdef PCSX2_VIRTUAL_MEM
_eeWriteConstMem128( PS2MEM_BASE_+mem, mmreg);
#else
if (mem < 0x10010000)
_eeWriteConstMem128((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
#endif
_eeWriteConstMem128((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
break;
}
}

20
pcsx2/x86/ix86-32/iR5900-32.cpp
View File

@ -555,10 +555,7 @@ void recResetEE( void )
if( s_pInstCache ) memset( s_pInstCache, 0, sizeof(EEINST)*s_nInstCacheSize );
ResetBaseBlockEx(0);
#ifndef PCSX2_VIRTUAL_MEM
mmap_ResetBlockTracking();
#endif
#ifdef _MSC_VER
__asm emms;
@ -668,19 +665,12 @@ static __naked void Dispatcher()
// calc PC_GETBLOCK
s_pDispatchBlock = PC_GETBLOCK(cpuRegs.pc);
__asm {
// check if startpc == cpuRegs.pc
mov eax, s_pDispatchBlock
mov ecx, cpuRegs.pc
cmp ecx, dword ptr [eax+BLOCKTYPE_STARTPC]
je CheckPtr
if( s_pDispatchBlock == NULL || s_pDispatchBlock->startpc != cpuRegs.pc )
recRecompile(cpuRegs.pc);
// recompile
push cpuRegs.pc // pc
call recRecompile
add esp, 4 // pop old param
__asm
{
mov eax, s_pDispatchBlock
CheckPtr:
mov eax, dword ptr [eax]
}
@ -1931,7 +1921,6 @@ StartRecomp:
MOV32ItoR(ECX,startpc);
MOV32ItoR(EDX,sz);
#ifndef PCSX2_VIRTUAL_MEM
while(inpage_sz)
{
int PageType=mmap_GetRamPageInfo((u32*)PSM(inpage_ptr));
@ -1968,7 +1957,6 @@ StartRecomp:
inpage_sz-=pgsz;
inpage_offs=inpage_ptr&0xFFF;
}
#endif
// finally recompile //
g_pCurInstInfo = s_pInstCache;