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

git-svn-id: https://localhost/svn/Project64/trunk@38 111125ac-702d-7242-af9c-5ba8ae61c1ef

This commit is contained in:
zilmar 2010-06-22 20:36:28 +00:00
parent a67155f8e4
commit 40df433273
37 changed files with 861 additions and 713 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/Project64/N64 System.h
View File

@ -19,7 +19,10 @@ class CNotification;
#include "N64 System/Mips/OpCode.h"
#include "N64 System/Mips/OpCode Analysis Class.h"
#include "N64 System/Recompiler/X86ops.h"
#include "N64 System/Mips/FlashRam.h"
#include "N64 System/Mips/Sram.h"
#include "N64 System/Mips/Eeprom.h"
#include "N64 System/Mips/Dma.h"
#include "N64 System/Mips/Pif Ram.h"
#include "N64 System/Mips/Register Class.h"
#include "N64 System/Mips/TranslateVaddr.h"
@ -34,7 +37,6 @@ class CNotification;
//C Core - to be upgrdaded and removed
#include "N64 System/C Core/CPU Log.h"
#include "N64 System/C Core/r4300i Commands.h"
#include "N64 System/C Core/Dma.h"
#include "N64 System/C Core/Win32Timer.h"
#include "N64 System/C Core/Logging.h"

12
Source/Project64/N64 System/C Core/C Core Interface.cpp
View File

@ -305,15 +305,3 @@ void SyncToPC (void) {
//FixRandomReg();
SyncSystem ();
}
BOOL ClearRecompCodeProtectMem ( DWORD Address, int length )
{
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (_Recompiler)
{
return _Recompiler->ClearRecompCode_Phys(Address,length,CRecompiler::Remove_ProtectedMem);
}
#endif
return false;
}

2
Source/Project64/N64 System/C Core/C Core Interface.h
View File

@ -57,8 +57,6 @@ void ResetX86Logs ( void );
void SyncToPC ( void );
void CloseSaveChips ( void );
BOOL ClearRecompCodeProtectMem ( DWORD PhysicalAddress, int length );
//Timer functions
void ResetTimer ( void );
void GenerateProfileLog ( void );

10
Source/Project64/N64 System/Debugger/Debugger - Memory Dump.cpp
View File

@ -79,7 +79,7 @@ LRESULT CDumpMemory::OnClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& b
GetDlgItemText(IDC_FILENAME,FileName,sizeof(FileName));
if (strlen(FileName) == 0)
{
Notify().DisplayError("Please Choose target file");
_Notify->DisplayError("Please Choose target file");
::SetFocus(GetDlgItem(IDC_FILENAME));
return false;
}
@ -255,7 +255,7 @@ LRESULT CDumpMemory::OnClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& b
// GetDlgItemText((HWND)hDlg,IDC_FILENAME,FileName,sizeof(FileName));
// if (strlen(FileName) == 0)
// {
// Notify().DisplayError("Please Choose target file");
// _Notify->DisplayError("Please Choose target file");
// SetFocus(GetDlgItem((HWND)hDlg,IDC_FILENAME));
// return false;
// }
@ -299,7 +299,7 @@ bool CDumpMemory::DumpMemory ( LPCSTR FileName,DumpFormat Format, DWORD StartPC,
CLog LogFile;
if (!LogFile.Open(FileName))
{
Notify().DisplayError("Failed to open\n%s",FileName);
_Notify->DisplayError("Failed to open\n%s",FileName);
return false;
}
LogFile.SetFlush(false);
@ -479,7 +479,7 @@ bool CDumpMemory::DumpMemory ( LPCSTR FileName,DumpFormat Format, DWORD StartPC,
//
// if (strlen(FileName) == 0)
// {
// Notify().DisplayError("Please Choose target file");
// _Notify->DisplayError("Please Choose target file");
// SetFocus(GetDlgItem((HWND)hDlg,IDC_FILENAME));
// return false;
// }
@ -524,7 +524,7 @@ bool CDumpMemory::DumpMemory ( LPCSTR FileName,DumpFormat Format, DWORD StartPC,
// CLog LogFile(FileName);
// if (!LogFile.IsOpen())
// {
// Notify().DisplayError("Failed to open\n%s",FileName);
// _Notify->DisplayError("Failed to open\n%s",FileName);
// return false;
// }
//

2
Source/Project64/N64 System/Interpreter/Interpreter CPU.cpp
View File

@ -324,7 +324,7 @@ void CInterpreterCPU::ExecuteOps ( int Cycles )
*_NextTimer -= m_CountPerOp;
m_R4300i_Opcode[ Opcode.op ]();
static DWORD TestAddress = 0x801AF8A0, TestValue = 0, CurrentValue = 0;
static DWORD TestAddress = 0x80077B0C, TestValue = 0, CurrentValue = 0;
if (_MMU->LW_VAddr(TestAddress, TestValue))
{
if (TestValue != CurrentValue)

35
Source/Project64/N64 System/Interpreter/Interpreter Ops 32.cpp
View File

@ -872,10 +872,12 @@ void R4300iOp32::LWL (void) {
Address = _GPR[m_Opcode.base].UW[0] + (short)m_Opcode.offset;
Offset = Address & 3;
if (!_MMU->LW_VAddr((Address & ~3),Value)) {
#ifndef EXTERNAL_RELEASE
DisplayError("LDL TLB: %X",Address);
#endif
if (!_MMU->LW_VAddr((Address & ~3),Value))
{
if (g_ShowTLBMisses)
{
DisplayError("LWL TLB: %X",Address);
}
return;
}
@ -935,10 +937,12 @@ void R4300iOp32::LWR (void) {
Address = _GPR[m_Opcode.base].UW[0] + (short)m_Opcode.offset;
Offset = Address & 3;
if (!_MMU->LW_VAddr((Address & ~3),Value)) {
#ifndef EXTERNAL_RELEASE
DisplayError("LDL TLB: %X",Address);
#endif
if (!_MMU->LW_VAddr((Address & ~3),Value))
{
if (g_ShowTLBMisses)
{
DisplayError("LWR TLB: %X",Address);
}
return;
}
@ -1015,9 +1019,10 @@ void R4300iOp32::SW (void) {
#endif
if (!_MMU->SW_VAddr(Address,_GPR[m_Opcode.rt].UW[0]))
{
#ifndef EXTERNAL_RELEASE
DisplayError("SW TLB: %X",Address);
#endif
if (g_ShowTLBMisses)
{
DisplayError("SW TLB: %X",Address);
}
}
}
@ -1088,8 +1093,12 @@ void R4300iOp32::SC (void) {
Log_SW((*_PROGRAM_COUNTER),Address,_GPR[m_Opcode.rt].UW[0]);
#endif
if ((*_LLBit) == 1) {
if (!_MMU->SW_VAddr(Address,_GPR[m_Opcode.rt].UW[0])) {
DisplayError("SW TLB: %X",Address);
if (!_MMU->SW_VAddr(Address,_GPR[m_Opcode.rt].UW[0]))
{
if (g_ShowTLBMisses)
{
DisplayError("SC TLB: %X",Address);
}
}
}
_GPR[m_Opcode.rt].UW[0] = (*_LLBit);

82
Source/Project64/N64 System/Interpreter/Interpreter Ops.cpp
View File

@ -957,10 +957,12 @@ void R4300iOp::LDL (void) {
Address = _GPR[m_Opcode.base].UW[0] + (short)m_Opcode.offset;
Offset = Address & 7;
if (!_MMU->LD_VAddr((Address & ~7),Value)) {
#ifndef EXTERNAL_RELEASE
DisplayError("LDL TLB: %X",Address);
#endif
if (!_MMU->LD_VAddr((Address & ~7),Value))
{
if (g_ShowTLBMisses)
{
DisplayError("LDL TLB: %X",Address);
}
return;
}
_GPR[m_Opcode.rt].DW = _GPR[m_Opcode.rt].DW & LDL_MASK[Offset];
@ -980,10 +982,12 @@ void R4300iOp::LDR (void) {
Address = _GPR[m_Opcode.base].UW[0] + (short)m_Opcode.offset;
Offset = Address & 7;
if (!_MMU->LD_VAddr((Address & ~7),Value)) {
#ifndef EXTERNAL_RELEASE
DisplayError("LDL TLB: %X",Address);
#endif
if (!_MMU->LD_VAddr((Address & ~7),Value))
{
if (g_ShowTLBMisses)
{
DisplayError("LDR TLB: %X",Address);
}
return;
}
@ -1026,10 +1030,12 @@ void R4300iOp::LWL (void) {
Address = _GPR[m_Opcode.base].UW[0] + (short)m_Opcode.offset;
Offset = Address & 3;
if (!_MMU->LW_VAddr((Address & ~3),Value)) {
#ifndef EXTERNAL_RELEASE
DisplayError("LDL TLB: %X",Address);
#endif
if (!_MMU->LW_VAddr((Address & ~3),Value))
{
if (g_ShowTLBMisses)
{
DisplayError("LWL TLB: %X",Address);
}
return;
}
@ -1106,10 +1112,12 @@ void R4300iOp::LWR (void) {
Address = _GPR[m_Opcode.base].UW[0] + (short)m_Opcode.offset;
Offset = Address & 3;
if (!_MMU->LW_VAddr((Address & ~3),Value)) {
#ifndef EXTERNAL_RELEASE
DisplayError("LDL TLB: %X",Address);
#endif
if (!_MMU->LW_VAddr((Address & ~3),Value))
{
if (g_ShowTLBMisses)
{
DisplayError("LDL TLB: %X",Address);
}
return;
}
@ -1199,10 +1207,12 @@ void R4300iOp::SW (void) {
}
#endif
if (!_MMU->SW_VAddr(Address,_GPR[m_Opcode.rt].UW[0])) {
#ifndef EXTERNAL_RELEASE
DisplayError("SW TLB: %X",Address);
#endif
if (!_MMU->SW_VAddr(Address,_GPR[m_Opcode.rt].UW[0]))
{
if (g_ShowTLBMisses)
{
DisplayError("SW TLB: %X",Address);
}
}
}
@ -1342,8 +1352,12 @@ void R4300iOp::SC (void) {
Log_SW((*_PROGRAM_COUNTER),Address,_GPR[m_Opcode.rt].UW[0]);
#endif
if ((*_LLBit) == 1) {
if (!_MMU->SW_VAddr(Address,_GPR[m_Opcode.rt].UW[0])) {
DisplayError("SW TLB: %X",Address);
if (!_MMU->SW_VAddr(Address,_GPR[m_Opcode.rt].UW[0]))
{
if (g_ShowTLBMisses)
{
DisplayError("SC TLB: %X",Address);
}
}
}
_GPR[m_Opcode.rt].UW[0] = (*_LLBit);
@ -1539,7 +1553,8 @@ void R4300iOp::SPECIAL_DMULT (void) {
_RegHI->UDW += (QWORD)Tmp[0].W[1] + (QWORD)Tmp[1].W[1] + Tmp[2].UW[1];
}
void R4300iOp::SPECIAL_DMULTU (void) {
void R4300iOp::SPECIAL_DMULTU (void)
{
MIPS_DWORD Tmp[3];
_RegLO->UDW = (QWORD)_GPR[m_Opcode.rs].UW[0] * (QWORD)_GPR[m_Opcode.rt].UW[0];
@ -2299,15 +2314,13 @@ void R4300iOp::COP1_L_CVT_D (void) {
}
/************************** Other functions **************************/
void R4300iOp::UnknownOpcode (void) {
#ifdef OLD_CODE
char Message[200];
void R4300iOp::UnknownOpcode (void)
{
DisplayError("%s: %08X\n%s\n\nStopping Emulation !", GS(MSG_UNHANDLED_OP), (*_PROGRAM_COUNTER),
R4300iOpcodeName(m_Opcode.Hex,(*_PROGRAM_COUNTER)));
_System->m_EndEmulation = true;
sprintf(Message,"%s: %08X\n%s\n\n", GS(MSG_UNHANDLED_OP), (*_PROGRAM_COUNTER),
R4300im_OpcodeName(m_Opcode.Hex,(*_PROGRAM_COUNTER)));
strcat(Message,"Stopping Emulation !");
#if (!defined(EXTERNAL_RELEASE))
#ifdef tofix
if (HaveDebugger && !inFullScreen) {
int response;
@ -2322,12 +2335,5 @@ void R4300iOp::UnknownOpcode (void) {
DisplayError(Message);
ExitThread(0);
}
#else
DisplayError(Message);
ExitThread(0);
#endif
#else
BreakPoint(__FILE__,__LINE__);
#endif
}

222
Source/Project64/N64 System/Mips/Dma.cpp Normal file
View File

@ -0,0 +1,222 @@
#include "stdafx.h"
CDMA::CDMA(CFlashram & FlashRam, CSram & Sram) :
m_FlashRam(FlashRam),
m_Sram(Sram)
{
}
void CDMA::OnFirstDMA (void) {
switch (_Rom->CicChipID()) {
case 1: *(DWORD *)&((_MMU->Rdram())[0x318]) = g_RdramSize; break;
case 2: *(DWORD *)&((_MMU->Rdram())[0x318]) = g_RdramSize; break;
case 3: *(DWORD *)&((_MMU->Rdram())[0x318]) = g_RdramSize; break;
case 5: *(DWORD *)&((_MMU->Rdram())[0x3F0]) = g_RdramSize; break;
case 6: *(DWORD *)&((_MMU->Rdram())[0x318]) = g_RdramSize; break;
default: DisplayError("Unhandled CicChip(%d) in first DMA",_Rom->CicChipID());
}
}
void CDMA::PI_DMA_READ (void) {
// PI_STATUS_REG |= PI_STATUS_DMA_BUSY;
if ( _Reg->PI_DRAM_ADDR_REG + _Reg->PI_RD_LEN_REG + 1 > g_RdramSize) {
#ifndef EXTERNAL_RELEASE
DisplayError("PI_DMA_READ not in Memory");
#endif
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
return;
}
if ( _Reg->PI_CART_ADDR_REG >= 0x08000000 && _Reg->PI_CART_ADDR_REG <= 0x08010000) {
if (g_SaveUsing == SaveChip_Auto) { g_SaveUsing = SaveChip_Sram; }
if (g_SaveUsing == SaveChip_Sram) {
m_Sram.DmaToSram(
_MMU->Rdram() + _Reg->PI_DRAM_ADDR_REG,
_Reg->PI_CART_ADDR_REG - 0x08000000,
_Reg->PI_RD_LEN_REG + 1
);
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
return;
}
if (g_SaveUsing == SaveChip_FlashRam) {
m_FlashRam.DmaToFlashram(
_MMU->Rdram()+_Reg->PI_DRAM_ADDR_REG,
_Reg->PI_CART_ADDR_REG - 0x08000000,
_Reg->PI_WR_LEN_REG + 1
);
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
return;
}
}
if (g_SaveUsing == SaveChip_FlashRam) {
#ifndef EXTERNAL_RELEASE
DisplayError("**** FLashRam DMA Read address %X *****",_Reg->PI_CART_ADDR_REG);
#endif
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
return;
}
#ifndef EXTERNAL_RELEASE
DisplayError("PI_DMA_READ where are you dmaing to ?");
#endif
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
return;
}
void CDMA::PI_DMA_WRITE (void) {
_Reg->PI_STATUS_REG |= PI_STATUS_DMA_BUSY;
if ( _Reg->PI_DRAM_ADDR_REG + _Reg->PI_WR_LEN_REG + 1 > g_RdramSize)
{
if (g_ShowUnhandledMemory) { DisplayError("PI_DMA_WRITE not in Memory"); }
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
return;
}
if ( _Reg->PI_CART_ADDR_REG >= 0x08000000 && _Reg->PI_CART_ADDR_REG <= 0x08010000) {
if (g_SaveUsing == SaveChip_Auto) { g_SaveUsing = SaveChip_Sram; }
if (g_SaveUsing == SaveChip_Sram) {
m_Sram.DmaFromSram(
_MMU->Rdram()+_Reg->PI_DRAM_ADDR_REG,
_Reg->PI_CART_ADDR_REG - 0x08000000,
_Reg->PI_WR_LEN_REG + 1
);
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
return;
}
if (g_SaveUsing == SaveChip_FlashRam) {
m_FlashRam.DmaFromFlashram(
_MMU->Rdram()+_Reg->PI_DRAM_ADDR_REG,
_Reg->PI_CART_ADDR_REG - 0x08000000,
_Reg->PI_WR_LEN_REG + 1
);
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
}
return;
}
if ( _Reg->PI_CART_ADDR_REG >= 0x10000000 && _Reg->PI_CART_ADDR_REG <= 0x1FBFFFFF) {
DWORD i;
#ifdef tofix
#ifdef ROM_IN_MAPSPACE
if (WrittenToRom) {
DWORD OldProtect;
VirtualProtect(ROM,g_RomFileSize,PAGE_READONLY, &OldProtect);
}
#endif
#endif
BYTE * ROM = _Rom->GetRomAddress();
BYTE * RDRAM = _MMU->Rdram();
_Reg->PI_CART_ADDR_REG -= 0x10000000;
if (_Reg->PI_CART_ADDR_REG + _Reg->PI_WR_LEN_REG + 1 < g_RomFileSize) {
for (i = 0; i < _Reg->PI_WR_LEN_REG + 1; i ++) {
*(RDRAM+((_Reg->PI_DRAM_ADDR_REG + i) ^ 3)) = *(ROM+((_Reg->PI_CART_ADDR_REG + i) ^ 3));
}
} else {
DWORD Len;
Len = g_RomFileSize - _Reg->PI_CART_ADDR_REG;
for (i = 0; i < Len; i ++) {
*(RDRAM+((_Reg->PI_DRAM_ADDR_REG + i) ^ 3)) = *(ROM+((_Reg->PI_CART_ADDR_REG + i) ^ 3));
}
for (i = Len; i < _Reg->PI_WR_LEN_REG + 1 - Len; i ++) {
*(RDRAM+((_Reg->PI_DRAM_ADDR_REG + i) ^ 3)) = 0;
}
}
_Reg->PI_CART_ADDR_REG += 0x10000000;
if (!_System->DmaUsed())
{
_System->SetDmaUsed(true);
OnFirstDMA();
}
if (_Recompiler && _Recompiler->bSMM_PIDMA())
{
_Recompiler->ClearRecompCode_Phys(_Reg->PI_DRAM_ADDR_REG, _Reg->PI_WR_LEN_REG,CRecompiler::Remove_DMA);
}
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
//ChangeTimer(PiTimer,(int)(PI_WR_LEN_REG * 8.9) + 50);
//ChangeTimer(PiTimer,(int)(PI_WR_LEN_REG * 8.9));
return;
}
if (g_ShowUnhandledMemory) { DisplayError("PI_DMA_WRITE not in ROM"); }
_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
_Reg->MI_INTR_REG |= MI_INTR_PI;
_Reg->CheckInterrupts();
}
void CDMA::SP_DMA_READ (void) {
_Reg->SP_DRAM_ADDR_REG &= 0x1FFFFFFF;
if (_Reg->SP_DRAM_ADDR_REG > g_RdramSize) {
#ifndef EXTERNAL_RELEASE
DisplayError("SP DMA\nSP_DRAM_ADDR_REG not in RDRam space");
#endif
_Reg->SP_DMA_BUSY_REG = 0;
_Reg->SP_STATUS_REG &= ~SP_STATUS_DMA_BUSY;
return;
}
if (_Reg->SP_RD_LEN_REG + 1 + (_Reg->SP_MEM_ADDR_REG & 0xFFF) > 0x1000) {
#ifndef EXTERNAL_RELEASE
DisplayError("SP DMA\ncould not fit copy in memory segement");
#endif
return;
}
if ((_Reg->SP_MEM_ADDR_REG & 3) != 0) { BreakPoint(__FILE__,__LINE__); }
if ((_Reg->SP_DRAM_ADDR_REG & 3) != 0) { BreakPoint(__FILE__,__LINE__); }
if (((_Reg->SP_RD_LEN_REG + 1) & 3) != 0) { BreakPoint(__FILE__,__LINE__); }
memcpy( _MMU->Dmem() + (_Reg->SP_MEM_ADDR_REG & 0x1FFF), _MMU->Rdram() + _Reg->SP_DRAM_ADDR_REG,
_Reg->SP_RD_LEN_REG + 1 );
_Reg->SP_DMA_BUSY_REG = 0;
_Reg->SP_STATUS_REG &= ~SP_STATUS_DMA_BUSY;
}
void CDMA::SP_DMA_WRITE (void) {
if (_Reg->SP_DRAM_ADDR_REG > g_RdramSize) {
#ifndef EXTERNAL_RELEASE
DisplayError("SP DMA WRITE\nSP_DRAM_ADDR_REG not in RDRam space");
#endif
return;
}
if (_Reg->SP_WR_LEN_REG + 1 + (_Reg->SP_MEM_ADDR_REG & 0xFFF) > 0x1000) {
#ifndef EXTERNAL_RELEASE
DisplayError("SP DMA WRITE\ncould not fit copy in memory segement");
#endif
return;
}
if ((_Reg->SP_MEM_ADDR_REG & 3) != 0) { BreakPoint(__FILE__,__LINE__); }
if ((_Reg->SP_DRAM_ADDR_REG & 3) != 0) { BreakPoint(__FILE__,__LINE__); }
if (((_Reg->SP_WR_LEN_REG + 1) & 3) != 0) { BreakPoint(__FILE__,__LINE__); }
memcpy( _MMU->Rdram() + _Reg->SP_DRAM_ADDR_REG, _MMU->Dmem() + (_Reg->SP_MEM_ADDR_REG & 0x1FFF),
_Reg->SP_WR_LEN_REG + 1);
_Reg->SP_DMA_BUSY_REG = 0;
_Reg->SP_STATUS_REG &= ~SP_STATUS_DMA_BUSY;
}

22
Source/Project64/N64 System/Mips/Dma.h Normal file
View File

@ -0,0 +1,22 @@
class CDMA
{
CDMA();
protected:
CDMA (CFlashram & FlashRam, CSram & Sram);
void PI_DMA_READ ( void );
void PI_DMA_WRITE ( void );
//void SI_DMA_READ ( void );
//void SI_DMA_WRITE ( void );
void SP_DMA_READ ( void );
void SP_DMA_WRITE ( void );
private:
CFlashram & m_FlashRam;
CSram & m_Sram;
void OnFirstDMA ( void );
};

221
Source/Project64/N64 System/Mips/FlashRam.cpp Normal file
View File

@ -0,0 +1,221 @@
#include "stdafx.h"
CFlashram::CFlashram (bool ReadOnly):
m_FlashFlag(FLASHRAM_MODE_NOPES),
m_FlashStatus(0),
m_FlashRamPointer(NULL),
m_FlashRAM_Offset(0),
m_ReadOnly(ReadOnly),
m_hFile(NULL)
{
}
CFlashram::~CFlashram (void) {
if (m_hFile) {
CloseHandle(m_hFile);
m_hFile = NULL;
}
}
void CFlashram::DmaFromFlashram ( BYTE * dest, int StartOffset, int len)
{
BYTE FlipBuffer[0x10000];
DWORD dwRead, count;
switch (m_FlashFlag) {
case FLASHRAM_MODE_READ:
if (m_hFile == NULL) {
if (!LoadFlashram()) { return; }
}
if (len > 0x10000) {
#ifndef EXTERNAL_RELEASE
DisplayError("DmaFromFlashram FlipBuffer to small (len: %d)",len);
#endif
len = 0x10000;
}
if ((len & 3) != 0) {
#ifndef EXTERNAL_RELEASE
DisplayError("Unaligned flash ram read ???");
#endif
return;
}
memset(FlipBuffer,0,sizeof(FlipBuffer));
StartOffset = StartOffset << 1;
SetFilePointer(m_hFile,StartOffset,NULL,FILE_BEGIN);
ReadFile(m_hFile,FlipBuffer,len,&dwRead,NULL);
for (count = dwRead; (int)count < len; count ++) {
FlipBuffer[count] = 0xFF;
}
_asm {
mov edi, dest
lea ecx, [FlipBuffer]
mov edx, 0
mov ebx, len
memcpyloop:
mov eax, dword ptr [ecx + edx]
;bswap eax
mov dword ptr [edi + edx],eax
add edx, 4
cmp edx, ebx
jb memcpyloop
}
break;
case FLASHRAM_MODE_STATUS:
if (StartOffset != 0 && len != 8) {
#ifndef EXTERNAL_RELEASE
DisplayError("Reading m_FlashStatus not being handled correctly\nStart: %X len: %X",StartOffset,len);
#endif
}
*((DWORD *)(dest)) = (DWORD)(m_FlashStatus >> 32);
*((DWORD *)(dest) + 1) = (DWORD)(m_FlashStatus);
break;
#ifndef EXTERNAL_RELEASE
default:
DisplayError("DmaFromFlashram Start: %X, Offset: %X len: %X",dest - _MMU->Rdram(),StartOffset,len);
#endif
}
}
void CFlashram::DmaToFlashram(BYTE * Source, int StartOffset, int len) {
switch (m_FlashFlag) {
case FLASHRAM_MODE_WRITE:
m_FlashRamPointer = Source;
break;
#ifndef EXTERNAL_RELEASE
default:
DisplayError("DmaToFlashram Start: %X, Offset: %X len: %X",Source - _MMU->Rdram(),StartOffset,len);
#endif
}
}
DWORD CFlashram::ReadFlashStatus (DWORD PAddr)
{
switch (PAddr) {
case 0x08000000: return (DWORD)(m_FlashStatus >> 32);
default:
#ifndef EXTERNAL_RELEASE
DisplayError("Reading from flash ram status (%X)",PAddr);
#endif
break;
}
return (DWORD)(m_FlashStatus >> 32);
}
bool CFlashram::LoadFlashram (void) {
CPath FileName;
FileName.SetDriveDirectory( _Settings->LoadString(Directory_NativeSave).c_str());
FileName.SetName(_Settings->LoadString(Game_GameName).c_str());
FileName.SetExtension("fla");
if (!FileName.DirectoryExists())
{
FileName.CreateDirectory();
}
m_hFile = CreateFile(FileName,m_ReadOnly ? GENERIC_READ : GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,NULL,OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);
if (m_hFile == INVALID_HANDLE_VALUE)
{
WriteTraceF(TraceError,"CFlashram::LoadFlashram: Failed to open (%s), ReadOnly = %d, LastError = %X",(LPCTSTR)FileName, m_ReadOnly, GetLastError());
DisplayError(GS(MSG_FAIL_OPEN_FLASH));
return false;
}
SetFilePointer(m_hFile,0,NULL,FILE_BEGIN);
return true;
}
void CFlashram::WriteToFlashCommand(DWORD FlashRAM_Command) {
BYTE EmptyBlock[128];
DWORD dwWritten;
switch (FlashRAM_Command & 0xFF000000) {
case 0xD2000000:
switch (m_FlashFlag) {
case FLASHRAM_MODE_NOPES: break;
case FLASHRAM_MODE_READ: break;
case FLASHRAM_MODE_STATUS: break;
case FLASHRAM_MODE_ERASE:
memset(EmptyBlock,0xFF,sizeof(EmptyBlock));
if (m_hFile == NULL) {
if (!LoadFlashram()) { return; }
}
SetFilePointer(m_hFile,m_FlashRAM_Offset,NULL,FILE_BEGIN);
WriteFile(m_hFile,EmptyBlock,128,&dwWritten,NULL);
break;
case FLASHRAM_MODE_WRITE:
if (m_hFile == NULL) {
if (!LoadFlashram()) { return; }
}
{
BYTE FlipBuffer[128];
DWORD dwWritten;
BYTE * FlashRamPointer = m_FlashRamPointer;
memset(FlipBuffer,0,sizeof(FlipBuffer));
_asm {
lea edi, [FlipBuffer]
mov ecx, FlashRamPointer
mov edx, 0
memcpyloop:
mov eax, dword ptr [ecx + edx]
;bswap eax
mov dword ptr [edi + edx],eax
add edx, 4
cmp edx, 128
jb memcpyloop
}
SetFilePointer(m_hFile,m_FlashRAM_Offset,NULL,FILE_BEGIN);
WriteFile(m_hFile,FlipBuffer,128,&dwWritten,NULL);
}
break;
default:
DisplayError("Writing %X to flash ram command register\nm_FlashFlag: %d",FlashRAM_Command,m_FlashFlag);
}
m_FlashFlag = FLASHRAM_MODE_NOPES;
break;
case 0xE1000000:
m_FlashFlag = FLASHRAM_MODE_STATUS;
m_FlashStatus = 0x1111800100C20000;
break;
case 0xF0000000:
m_FlashFlag = FLASHRAM_MODE_READ;
m_FlashStatus = 0x11118004F0000000;
break;
case 0x4B000000:
m_FlashRAM_Offset = (FlashRAM_Command & 0xffff) * 128;
break;
case 0x78000000:
m_FlashFlag = FLASHRAM_MODE_ERASE;
m_FlashStatus = 0x1111800800C20000;
break;
case 0xB4000000:
m_FlashFlag = FLASHRAM_MODE_WRITE; //????
break;
case 0xA5000000:
m_FlashRAM_Offset = (FlashRAM_Command & 0xffff) * 128;
m_FlashStatus = 0x1111800400C20000;
break;
#ifndef EXTERNAL_RELEASE
default:
DisplayError("Writing %X to flash ram command register",FlashRAM_Command);
#endif
}
}
DWORD CFlashram::ReadFromFlashStatus (DWORD PAddr)
{
switch (PAddr) {
case 0x08000000: return (DWORD)(m_FlashStatus >> 32);
default:
#ifndef EXTERNAL_RELEASE
DisplayError("Reading from flash ram status (%X)",PAddr);
#endif
break;
}
return (DWORD)(m_FlashStatus >> 32);
}

30
Source/Project64/N64 System/Mips/FlashRam.h Normal file
View File

@ -0,0 +1,30 @@
class CFlashram
{
enum Modes {
FLASHRAM_MODE_NOPES = 0,
FLASHRAM_MODE_ERASE = 1,
FLASHRAM_MODE_WRITE = 2,
FLASHRAM_MODE_READ = 3,
FLASHRAM_MODE_STATUS = 4,
};
public:
CFlashram ( bool ReadOnly );
~CFlashram ( void );
void DmaFromFlashram ( BYTE * dest, int StartOffset, int len );
void DmaToFlashram ( BYTE * Source, int StartOffset, int len );
DWORD ReadFromFlashStatus ( DWORD PAddr );
void WriteToFlashCommand ( DWORD Value );
private:
DWORD ReadFlashStatus ( DWORD PAddr );
bool LoadFlashram ( void );
BYTE * m_FlashRamPointer;
Modes m_FlashFlag;
QWORD m_FlashStatus;
DWORD m_FlashRAM_Offset;
bool m_ReadOnly;
HANDLE m_hFile;
};

181
Source/Project64/N64 System/Mips/Memory Virtual Mem.cpp
View File

@ -3,7 +3,11 @@
DWORD RegModValue;
CMipsMemoryVM::CMipsMemoryVM ( CMipsMemory_CallBack * CallBack, bool SavesReadOnly ) :
CPifRam(SavesReadOnly),
CFlashram(SavesReadOnly),
CSram(SavesReadOnly),
CDMA(*this,*this),
m_CBClass(CallBack),
m_TLB_ReadMap(NULL),
m_TLB_WriteMap(NULL),
@ -671,7 +675,8 @@ void CMipsMemoryVM::Compile_SW_Const ( DWORD Value, DWORD VAddr ) {
case 0x04040008:
MoveConstToVariable(Value,&_Reg->SP_RD_LEN_REG,"SP_RD_LEN_REG");
BeforeCallDirect(m_RegWorkingSet);
Call_Direct(&SP_DMA_READ,"SP_DMA_READ");
MoveConstToX86reg((ULONG)((CDMA *)this),x86_ECX);
Call_Direct(AddressOf(CDMA::SP_DMA_READ),"CDMA::SP_DMA_READ");
AfterCallDirect(m_RegWorkingSet);
break;
case 0x04040010:
@ -893,13 +898,15 @@ void CMipsMemoryVM::Compile_SW_Const ( DWORD Value, DWORD VAddr ) {
case 0x04600008:
MoveConstToVariable(Value,&_Reg->PI_RD_LEN_REG,"PI_RD_LEN_REG");
BeforeCallDirect(m_RegWorkingSet);
Call_Direct(&PI_DMA_READ,"PI_DMA_READ");
MoveConstToX86reg((ULONG)((CDMA *)this),x86_ECX);
Call_Direct(AddressOf(CDMA::PI_DMA_READ),"CDMA::PI_DMA_READ");
AfterCallDirect(m_RegWorkingSet);
break;
case 0x0460000C:
MoveConstToVariable(Value,&_Reg->PI_WR_LEN_REG,"PI_WR_LEN_REG");
BeforeCallDirect(m_RegWorkingSet);
Call_Direct(&PI_DMA_WRITE,"PI_DMA_WRITE");
MoveConstToX86reg((ULONG)((CDMA *)this),x86_ECX);
Call_Direct(AddressOf(CDMA::PI_DMA_WRITE),"CDMA::PI_DMA_WRITE");
AfterCallDirect(m_RegWorkingSet);
break;
case 0x04600010:
@ -994,13 +1001,15 @@ void CMipsMemoryVM::Compile_SW_Register (x86Reg Reg, DWORD VAddr )
case 0x04040008:
MoveX86regToVariable(Reg,&_Reg->SP_RD_LEN_REG,"SP_RD_LEN_REG");
BeforeCallDirect(m_RegWorkingSet);
Call_Direct(&SP_DMA_READ,"SP_DMA_READ");
MoveConstToX86reg((ULONG)((CDMA *)this),x86_ECX);
Call_Direct(AddressOf(CDMA::SP_DMA_READ),"CDMA::SP_DMA_READ");
AfterCallDirect(m_RegWorkingSet);
break;
case 0x0404000C:
MoveX86regToVariable(Reg,&_Reg->SP_WR_LEN_REG,"SP_WR_LEN_REG");
BeforeCallDirect(m_RegWorkingSet);
Call_Direct(&SP_DMA_WRITE,"SP_DMA_WRITE");
MoveConstToX86reg((ULONG)((CDMA *)this),x86_ECX);
Call_Direct(AddressOf(CDMA::SP_DMA_WRITE),"CDMA::SP_DMA_WRITE");
AfterCallDirect(m_RegWorkingSet);
break;
case 0x04040010:
@ -1149,13 +1158,15 @@ void CMipsMemoryVM::Compile_SW_Register (x86Reg Reg, DWORD VAddr )
case 0x04600008:
MoveX86regToVariable(Reg,&_Reg->PI_RD_LEN_REG,"PI_RD_LEN_REG");
BeforeCallDirect(m_RegWorkingSet);
Call_Direct(&PI_DMA_READ,"PI_DMA_READ");
MoveConstToX86reg((ULONG)((CDMA *)this),x86_ECX);
Call_Direct(AddressOf(CDMA::PI_DMA_READ),"CDMA::PI_DMA_READ");
AfterCallDirect(m_RegWorkingSet);
break;
case 0x0460000C:
MoveX86regToVariable(Reg,&_Reg->PI_WR_LEN_REG,"PI_WR_LEN_REG");
BeforeCallDirect(m_RegWorkingSet);
Call_Direct(&PI_DMA_WRITE,"PI_DMA_WRITE");
MoveConstToX86reg((ULONG)((CDMA *)this),x86_ECX);
Call_Direct(AddressOf(CDMA::PI_DMA_WRITE),"CDMA::PI_DMA_WRITE");
AfterCallDirect(m_RegWorkingSet);
break;
case 0x04600010:
@ -1302,53 +1313,19 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
return EXCEPTION_CONTINUE_EXECUTION;
}
#endif
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if ((int)End < RdramSize) {
for ( count = Start; count < End; count += 0x1000 ) {
BreakPoint(__FILE__,__LINE__);
if (N64_Blocks.NoOfRDRamBlocks[(count >> 12)] > 0) {
N64_Blocks.NoOfRDRamBlocks[(count >> 12)] = 0;
memset(JumpTable + ((count & 0x00FFFFF0) >> 2),0,0x1000);
*(DelaySlotTable + count) = NULL;
if (VirtualProtect(m_RDRAM + count, 4, PAGE_READWRITE, &OldProtect) == 0) {
#ifndef EXTERNAL_RELEASE
DisplayError("Failed to unprotect %X\n1", count);
#endif
}
}
if (End < RdramSize())
{
for (DWORD count = (Start & ~0xFFF); count < End; count += 0x1000 )
{
_Recompiler->ClearRecompCode_Phys(count,0x1000,CRecompiler::Remove_ProtectedMem);
}
return EXCEPTION_CONTINUE_EXECUTION;
}
if (Start >= 0x04000000 && End < 0x04001000) {
BreakPoint(__FILE__,__LINE__);
N64_Blocks.NoOfDMEMBlocks = 0;
memset(JumpTable + (0x04000000 >> 2),0,0x1000);
*(DelaySlotTable + (0x04000000 >> 12)) = NULL;
if (VirtualProtect(m_RDRAM + 0x04000000, 4, PAGE_READWRITE, &OldProtect) == 0) {
#ifndef EXTERNAL_RELEASE
DisplayError("Failed to unprotect %X\n7", 0x04000000);
#endif
}
if (Start >= 0x04000000 && End < 0x04002000) {
_Recompiler->ClearRecompCode_Phys(Start & ~0xFFF,0x1000,CRecompiler::Remove_ProtectedMem);
return EXCEPTION_CONTINUE_EXECUTION;
}
if (Start >= 0x04001000 && End < 0x04002000) {
BreakPoint(__FILE__,__LINE__);
N64_Blocks.NoOfIMEMBlocks = 0;
memset(JumpTable + (0x04001000 >> 2),0,0x1000);
*(DelaySlotTable + (0x04001000 >> 12)) = NULL;
if (VirtualProtect(m_RDRAM + 0x04001000, 4, PAGE_READWRITE, &OldProtect) == 0) {
#ifndef EXTERNAL_RELEASE
DisplayError("Failed to unprotect %X\n6", 0x04001000);
#endif
}
return EXCEPTION_CONTINUE_EXECUTION;
}
#ifndef EXTERNAL_RELEASE
DisplayError("hmmm.... where does this dma End ?\nstart: %X\nend:%X\nlocation %X",
Start,End,lpEP->ContextRecord->Eip);
#endif
#endif
DisplayError("hmmm.... where does this dma End ?\nstart: %X\nend:%X\nlocation %X", Start,End,lpEP->ContextRecord->Eip);
return EXCEPTION_CONTINUE_SEARCH;
}
@ -1403,6 +1380,7 @@ int CMipsMemoryVM::MemoryFilter( DWORD dwExptCode, void * lpExceptionPointer )
case 0x41: ReadPos += 2; break;
case 0x42: ReadPos += 2; break;
case 0x43: ReadPos += 2; break;
case 0x44: ReadPos += 3; break;
case 0x46: ReadPos += 2; break;
case 0x47: ReadPos += 2; break;
case 0x80: ReadPos += 5; break;
@ -1799,10 +1777,7 @@ int CMipsMemoryVM::LW_NonMemory ( DWORD PAddr, DWORD * Value ) {
*Value = (*Value << 16) | *Value;
return FALSE;
}
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
*Value = ReadFromFlashStatus(PAddr);
#endif
break;
case 0x1FC00000:
if (PAddr < 0x1FC007C0) {
@ -1864,18 +1839,8 @@ int CMipsMemoryVM::SB_NonMemory ( DWORD PAddr, BYTE Value ) {
}
#endif
if (PAddr < RdramSize()) {
bool ProtectMem = false;
DWORD Start = PAddr & ~0xFFF;
WriteTraceF(TraceDebug,"WriteToProtectedMemory Addres: %X Len: %d",PAddr,1);
if (!ClearRecompCodeProtectMem(Start,0xFFF)) { ProtectMem = true; }
DWORD OldProtect;
VirtualProtect((m_RDRAM + PAddr), 1, PAGE_READWRITE, &OldProtect);
_Recompiler->ClearRecompCode_Phys(PAddr & ~0xFFF,0x1000,CRecompiler::Remove_ProtectedMem);
*(BYTE *)(m_RDRAM+PAddr) = Value;
if (ProtectMem)
{
VirtualProtect((m_RDRAM + PAddr), 1, PAGE_READONLY, &OldProtect);
}
}
break;
default:
@ -1908,18 +1873,8 @@ int CMipsMemoryVM::SH_NonMemory ( DWORD PAddr, WORD Value ) {
}
#endif
if (PAddr < RdramSize()) {
bool ProtectMem = false;
DWORD Start = PAddr & ~0xFFF;
WriteTraceF(TraceDebug,"WriteToProtectedMemory Addres: %X Len: %d",PAddr,1);
if (!ClearRecompCodeProtectMem(Start,0xFFF)) { ProtectMem = true; }
DWORD OldProtect;
VirtualProtect((m_RDRAM + PAddr), 1, PAGE_READWRITE, &OldProtect);
_Recompiler->ClearRecompCode_Phys(PAddr & ~0xFFF,0x1000,CRecompiler::Remove_ProtectedMem);
*(WORD *)(m_RDRAM+PAddr) = Value;
if (ProtectMem)
{
VirtualProtect((m_RDRAM + PAddr), 1, PAGE_READONLY, &OldProtect);
}
}
break;
default:
@ -1968,19 +1923,8 @@ int CMipsMemoryVM::SW_NonMemory ( DWORD PAddr, DWORD Value ) {
}
#endif
if (PAddr < RdramSize()) {
bool ProtectMem = false;
DWORD Start = PAddr & ~0xFFF;
WriteTraceF(TraceDebug,"WriteToProtectedMemory Addres: %X Len: %d",PAddr,1);
if (!ClearRecompCodeProtectMem(Start,0xFFF)) { ProtectMem = true; }
DWORD OldProtect;
VirtualProtect((m_RDRAM + PAddr), 4, PAGE_READWRITE, &OldProtect);
_Recompiler->ClearRecompCode_Phys(PAddr & ~0xFFF,0x1000,CRecompiler::Remove_ProtectedMem);
*(DWORD *)(m_RDRAM+PAddr) = Value;
if (ProtectMem)
{
VirtualProtect((m_RDRAM + PAddr), 4, PAGE_READONLY, &OldProtect);
}
}
break;
case 0x03F00000:
@ -2007,19 +1951,8 @@ int CMipsMemoryVM::SW_NonMemory ( DWORD PAddr, DWORD Value ) {
break;
case 0x04000000:
if (PAddr < 0x04002000) {
bool ProtectMem = false;
DWORD Start = PAddr & ~0xFFF;
WriteTraceF(TraceDebug,"WriteToProtectedMemory Addres: %X Len: %d",PAddr,1);
if (!ClearRecompCodeProtectMem(Start,0xFFF)) { ProtectMem = true; }
DWORD OldProtect;
VirtualProtect((m_RDRAM + PAddr), 4, PAGE_READWRITE, &OldProtect);
_Recompiler->ClearRecompCode_Phys(PAddr & ~0xFFF,0xFFF,CRecompiler::Remove_ProtectedMem);
*(DWORD *)(m_RDRAM+PAddr) = Value;
if (ProtectMem)
{
VirtualProtect((m_RDRAM + PAddr), 4, PAGE_READONLY, &OldProtect);
}
} else {
switch (PAddr) {
case 0x04040000: _Reg->SP_MEM_ADDR_REG = Value; break;
@ -2296,13 +2229,10 @@ int CMipsMemoryVM::SW_NonMemory ( DWORD PAddr, DWORD Value ) {
}
break;
case 0x08000000:
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (PAddr != 0x08010000) { return FALSE; }
if (SaveUsing == SaveChip_Auto) { SaveUsing = SaveChip_FlashRam; }
if (SaveUsing != SaveChip_FlashRam) { return TRUE; }
if (g_SaveUsing == SaveChip_Auto) { g_SaveUsing = SaveChip_FlashRam; }
if (g_SaveUsing != SaveChip_FlashRam) { return TRUE; }
WriteToFlashCommand(Value);
#endif
return FALSE;
break;
case 0x1FC00000:
@ -2343,9 +2273,8 @@ void CMipsMemoryVM::UpdateHalfLine (void)
void CMipsMemoryVM::ProtectMemory( DWORD StartVaddr, DWORD EndVaddr )
{
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
if (!CTLB::ValidVaddr(StartVaddr) || !CTLB::ValidVaddr(EndVaddr)) { return; }
WriteTraceF(TraceError,"ProtectMemory: StartVaddr: %X EndVaddr: %X",StartVaddr,EndVaddr);
if (!ValidVaddr(StartVaddr) || !ValidVaddr(EndVaddr)) { return; }
//Get Physical Addresses passed
DWORD StartPAddr, EndPAddr;
@ -2353,24 +2282,21 @@ void CMipsMemoryVM::ProtectMemory( DWORD StartVaddr, DWORD EndVaddr )
if (!TranslateVaddr(EndVaddr,EndPAddr)) { _Notify->BreakPoint(__FILE__,__LINE__); }
//Get Length of memory being protected
int Length = (EndPAddr + 4) - StartPAddr;
int Length = ((EndPAddr + 3) - StartPAddr) & ~3;
if (Length < 0) { _Notify->BreakPoint(__FILE__,__LINE__); }
//Proect that memory address space
DWORD OldProtect;
void * MemLoc;
BYTE * MemLoc = Rdram() + StartPAddr;
WriteTraceF(TraceError,"ProtectMemory: Paddr: %X Length: %X",StartPAddr,Length);
if (!VAddrToRealAddr(StartVaddr,MemLoc)) { _Notify->BreakPoint(__FILE__,__LINE__); }
VirtualProtect(MemLoc, Length, PAGE_READONLY, &OldProtect);
#endif
}
void CMipsMemoryVM::UnProtectMemory( DWORD StartVaddr, DWORD EndVaddr )
{
// _Notify->BreakPoint(__FILE__,__LINE__);
WriteTraceF(TraceError,"CMipsMemoryVM::UnProtectMemory: Not implemented startVaddr: %X EndVaddr: %X",StartVaddr,EndVaddr);
#ifdef tofix
if (!CTLB::ValidVaddr(StartVaddr) || !CTLB::ValidVaddr(EndVaddr)) { return; }
WriteTraceF(TraceError,"UnProtectMemory: StartVaddr: %X EndVaddr: %X",StartVaddr,EndVaddr);
if (!ValidVaddr(StartVaddr) || !ValidVaddr(EndVaddr)) { return; }
//Get Physical Addresses passed
DWORD StartPAddr, EndPAddr;
@ -2378,19 +2304,16 @@ void CMipsMemoryVM::UnProtectMemory( DWORD StartVaddr, DWORD EndVaddr )
if (!TranslateVaddr(EndVaddr,EndPAddr)) { _Notify->BreakPoint(__FILE__,__LINE__); }
//Get Length of memory being protected
int Length = (EndPAddr + 4) - StartPAddr;
int Length = ((EndPAddr + 3) - StartPAddr) & ~3;
if (Length < 0) { _Notify->BreakPoint(__FILE__,__LINE__); }
//Proect that memory address space
DWORD OldProtect;
void * MemLoc;
BYTE * MemLoc = Rdram() + StartPAddr;
if (!VAddrToRealAddr(StartVaddr,MemLoc)) { _Notify->BreakPoint(__FILE__,__LINE__); }
VirtualProtect(MemLoc, Length, PAGE_READWRITE, &OldProtect);
#endif
}
void CMipsMemoryVM::Compile_LB (void)
{
OPCODE & Opcode = CRecompilerOps::m_Opcode;
@ -3060,31 +2983,27 @@ void CMipsMemoryVM::Compile_LDC1 (void)
void CMipsMemoryVM::Compile_LDL (void)
{
OPCODE & Opcode = CRecompilerOps::m_Opcode;
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(Opcode.Hex,m_CompilePC));
if (Opcode.base != 0) { UnMap_GPR(Opcode.base,TRUE); }
if (Opcode.rt != 0) { UnMap_GPR(Opcode.rt,TRUE); }
BeforeCallDirect(m_RegWorkingSet);
MoveConstToVariable(Opcode.Hex, &Opcode.Hex, "Opcode.Hex" );
MoveConstToVariable(Opcode.Hex, &R4300iOp::m_Opcode.Hex, "R4300iOp::m_Opcode.Hex");
Call_Direct(R4300iOp::LDL, "R4300iOp::LDL");
AfterCallDirect(m_RegWorkingSet);
#endif
}
void CMipsMemoryVM::Compile_LDR (void)
{
OPCODE & Opcode = CRecompilerOps::m_Opcode;
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(Opcode.Hex,m_CompilePC));
if (Opcode.base != 0) { UnMap_GPR(Opcode.base,TRUE); }
if (Opcode.rt != 0) { UnMap_GPR(Opcode.rt,TRUE); }
BeforeCallDirect(m_RegWorkingSet);
MoveConstToVariable(Opcode.Hex, &Opcode.Hex, "Opcode.Hex" );
MoveConstToVariable(Opcode.Hex, &R4300iOp::m_Opcode.Hex, "R4300iOp::m_Opcode.Hex");
Call_Direct(R4300iOp::LDR, "R4300iOp::LDR");
AfterCallDirect(m_RegWorkingSet);
#endif
}
void CMipsMemoryVM::Compile_SB (void)
@ -3762,13 +3681,15 @@ void CMipsMemoryVM::Compile_SDC1 (void)
}
void CMipsMemoryVM::Compile_SDL (void) {
OPCODE & Opcode = R4300iOp::m_Opcode;
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(Opcode.Hex,m_CompilePC));
if (Opcode.base != 0) { UnMap_GPR(Opcode.base,TRUE); }
if (Opcode.rt != 0) { UnMap_GPR(Opcode.rt,TRUE); }
BeforeCallDirect(m_RegWorkingSet);
MoveConstToVariable(Opcode.Hex, &Opcode.Hex, "Opcode.Hex" );
MoveConstToVariable(m_Opcode.Hex, &R4300iOp::m_Opcode.Hex, "R4300iOp::m_Opcode.Hex");
Call_Direct(R4300iOp::SDL, "R4300iOp::SDL");
AfterCallDirect(m_RegWorkingSet);
@ -3776,13 +3697,15 @@ void CMipsMemoryVM::Compile_SDL (void) {
}
void CMipsMemoryVM::Compile_SDR (void) {
OPCODE & Opcode = R4300iOp::m_Opcode;
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(Opcode.Hex,m_CompilePC));
if (Opcode.base != 0) { UnMap_GPR(Opcode.base,TRUE); }
if (Opcode.rt != 0) { UnMap_GPR(Opcode.rt,TRUE); }
BeforeCallDirect(m_RegWorkingSet);
MoveConstToVariable(Opcode.Hex, &Opcode.Hex, "Opcode.Hex" );
MoveConstToVariable(m_Opcode.Hex, &R4300iOp::m_Opcode.Hex, "R4300iOp::m_Opcode.Hex");
Call_Direct(R4300iOp::SDR, "R4300iOp::SDR");
AfterCallDirect(m_RegWorkingSet);
#endif

5
Source/Project64/N64 System/Mips/Memory Virtual Mem.h
View File

@ -3,7 +3,10 @@ class CMipsMemoryVM :
public CTransVaddr,
private CRecompilerOps,
private R4300iOp,
private CPifRam
private CPifRam,
private CFlashram,
private CSram,
private CDMA
{
CMipsMemory_CallBack * const m_CBClass;

4
Source/Project64/N64 System/Mips/OpCode Class.cpp
View File

@ -41,7 +41,7 @@ COpcode::COpcode ( DWORD VirtualAddress ):
//set up the details about the current opcode
m_opcode.VirtualAddress = VirtualAddress & ~3;
if (!SetPC(m_opcode.VirtualAddress)) {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -84,7 +84,7 @@ bool COpcode::Next (void) {
break;
default:
m_opcode.VirtualAddress += m_OpLen;
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
if (!_MMU->LW_VAddr(m_opcode.VirtualAddress,m_opcode.Hex)) {

3
Source/Project64/N64 System/Mips/TLB Class.h
View File

@ -110,6 +110,9 @@ public:
bool AddressDefined ( DWORD VAddr );
const TLB_ENTRY & TlbEntry ( int Entry) const { return m_tlb[Entry]; }
bool PAddrToVAddr ( DWORD PAddr, DWORD & VAddr, DWORD & Index );
//Change the Virtual address to a Phyiscal Address
/*inline bool TranslateVaddr ( DWORD VAddr, DWORD &PAddr) const
{

9
Source/Project64/N64 System/Mips/TLB class.cpp
View File

@ -204,13 +204,6 @@ void CTLB::SetupTLB_Entry (int index, bool Random) {
}
}
#ifdef tofix
bool CTLB::VAddrToRealAddr(DWORD VAddr, void * &RealAddress) {
if (TLB_ReadMap[VAddr >> 12] == 0) { return false; }
RealAddress = (BYTE *)(TLB_ReadMap[VAddr >> 12] + VAddr);
return true;
}
bool CTLB::PAddrToVAddr(DWORD PAddr, DWORD & VAddr, DWORD & Index )
{
for (int i = Index; i < 64; i++)
@ -226,5 +219,3 @@ bool CTLB::PAddrToVAddr(DWORD PAddr, DWORD & VAddr, DWORD & Index )
}
return false;
}
#endif

25
Source/Project64/N64 System/N64 Class.cpp
View File

@ -765,7 +765,6 @@ void CN64System::ExecuteCPU ( void )
_Notify->RefreshMenu();
g_RomFileSize = _Rom->GetRomSize();
g_CicChip = _Rom->CicChipID();
CC_Core C_Core;
C_Core.SetSettings();
@ -896,6 +895,8 @@ void CN64System::SyncCPU (CN64System * const SecondCPU) {
if (m_Reg.m_FPCR[0] != SecondCPU->m_Reg.m_FPCR[0]) { ErrorFound = true; }
if (m_Reg.m_FPCR[31] != SecondCPU->m_Reg.m_FPCR[31]) { ErrorFound = true; }
if (m_Reg.m_HI.DW != SecondCPU->m_Reg.m_HI.DW) { ErrorFound = true; }
if (m_Reg.m_LO.DW != SecondCPU->m_Reg.m_LO.DW) { ErrorFound = true; }
for (int z = 0; z < 0x100; z++)
{
@ -950,45 +951,51 @@ void CN64System::DumpSyncErrors (CN64System * SecondCPU) {
}
#endif
if (m_Reg.m_PROGRAM_COUNTER != SecondCPU->m_Reg.m_PROGRAM_COUNTER) {
Error.LogF("PROGRAM_COUNTER, 0x%X, 0x%X\r\n",m_Reg.m_PROGRAM_COUNTER,SecondCPU->m_Reg.m_PROGRAM_COUNTER);
Error.LogF("PROGRAM_COUNTER 0x%X, 0x%X\r\n",m_Reg.m_PROGRAM_COUNTER,SecondCPU->m_Reg.m_PROGRAM_COUNTER);
}
for (count = 0; count < 32; count ++) {
if (m_Reg.m_GPR[count].DW != SecondCPU->m_Reg.m_GPR[count].DW) {
Error.LogF("GPR[%s] Different,0x%08X%08X, 0x%08X%08X\r\n",CRegName::GPR[count],
Error.LogF("GPR[%s] 0x%08X%08X, 0x%08X%08X\r\n",CRegName::GPR[count],
m_Reg.m_GPR[count].W[1],m_Reg.m_GPR[count].W[0],
SecondCPU->m_Reg.m_GPR[count].W[1],SecondCPU->m_Reg.m_GPR[count].W[0]);
}
}
for (count = 0; count < 32; count ++) {
if (m_Reg.m_FPR[count].DW != SecondCPU->m_Reg.m_FPR[count].DW) {
Error.LogF("FPR[%s] Different,0x%08X%08X, 0x%08X%08X\r\n",CRegName::FPR[count],
Error.LogF("FPR[%s] 0x%08X%08X, 0x%08X%08X\r\n",CRegName::FPR[count],
m_Reg.m_FPR[count].W[1],m_Reg.m_FPR[count].W[0],
SecondCPU->m_Reg.m_FPR[count].W[1],SecondCPU->m_Reg.m_FPR[count].W[0]);
}
}
for (count = 0; count < 32; count ++) {
if (m_Reg.m_FPCR[count] != SecondCPU->m_Reg.m_FPCR[count]) {
Error.LogF("FPCR[%s] Different,0x%08X, 0x%08X\r\n",CRegName::FPR_Ctrl[count],
Error.LogF("FPCR[%s] 0x%08X, 0x%08X\r\n",CRegName::FPR_Ctrl[count],
m_Reg.m_FPCR[count], SecondCPU->m_Reg.m_FPCR[count]);
}
}
for (count = 0; count < 32; count ++) {
if (m_Reg.m_CP0[count] != SecondCPU->m_Reg.m_CP0[count]) {
Error.LogF("CP0[%s] Different,0x%08X, 0x%08X\r\n",CRegName::Cop0[count],
Error.LogF("CP0[%s] 0x%08X, 0x%08X\r\n",CRegName::Cop0[count],
m_Reg.m_CP0[count], SecondCPU->m_Reg.m_CP0[count]);
}
}
if (m_Reg.m_HI.DW != SecondCPU->m_Reg.m_HI.DW) {
Error.LogF("HI Reg 0x%08X%08X, 0x%08X%08X\r\n",m_Reg.m_HI.UW[1],m_Reg.m_HI.UW[0],SecondCPU->m_Reg.m_HI.UW[1],SecondCPU->m_Reg.m_HI.UW[0]);
}
if (m_Reg.m_LO.DW != SecondCPU->m_Reg.m_LO.DW) {
Error.LogF("LO Reg 0x%08X%08X, 0x%08X%08X\r\n",m_Reg.m_LO.UW[1],m_Reg.m_LO.UW[0], SecondCPU->m_Reg.m_LO.UW[1],SecondCPU->m_Reg.m_LO.UW[0]);
}
if (m_NextTimer != SecondCPU->m_NextTimer)
{
Error.LogF("Current Time is Different: %X %X\r\n",(DWORD)m_NextTimer,(DWORD)SecondCPU->m_NextTimer);
Error.LogF("Current Time: %X %X\r\n",(DWORD)m_NextTimer,(DWORD)SecondCPU->m_NextTimer);
}
if (m_SystemTimer.CurrentType() != SecondCPU->m_SystemTimer.CurrentType())
{
Error.LogF("Current Time Type is Different: %X %X\r\n",m_SystemTimer.CurrentType(),SecondCPU->m_SystemTimer.CurrentType());
Error.LogF("Current Time Type: %X %X\r\n",m_SystemTimer.CurrentType(),SecondCPU->m_SystemTimer.CurrentType());
}
if (m_Reg.m_RoundingModel != SecondCPU->m_Reg.m_RoundingModel)
{
Error.LogF("RoundingModel is Different: %X %X\r\n",m_Reg.m_RoundingModel,SecondCPU->m_Reg.m_RoundingModel);
Error.LogF("RoundingModel: %X %X\r\n",m_Reg.m_RoundingModel,SecondCPU->m_Reg.m_RoundingModel);
}
if (_Settings->LoadBool(Game_SPHack))
{

14
Source/Project64/N64 System/Recompiler/Code Section.cpp
View File

@ -150,7 +150,7 @@ void CCodeSection::CompileExit ( DWORD JumpPC, DWORD TargetPC, CRegInfo ExitRegS
}
if (_SyncSystem)
{
Call_Direct(SyncToPC, "SyncToPC");
Call_Direct(SyncSystem, "SyncSystem");
}
#ifdef LinkBlocks
if (bSMM_ValidFunc == false)
@ -243,7 +243,7 @@ void CCodeSection::CompileExit ( DWORD JumpPC, DWORD TargetPC, CRegInfo ExitRegS
case CExitInfo::DoCPU_Action:
MoveConstToX86reg((DWORD)_SystemEvents,x86_ECX);
Call_Direct(AddressOf(CSystemEvents::ExecuteEvents),"CSystemEvents::ExecuteEvents");
if (_SyncSystem) { Call_Direct(SyncToPC, "SyncToPC"); }
if (_SyncSystem) { Call_Direct(SyncSystem, "SyncSystem"); }
ExitCodeBlock();
break;
case CExitInfo::DoSysCall:
@ -252,7 +252,7 @@ void CCodeSection::CompileExit ( DWORD JumpPC, DWORD TargetPC, CRegInfo ExitRegS
PushImm32(bDelay ? "true" : "false", bDelay);
MoveConstToX86reg((DWORD)_Reg,x86_ECX);
Call_Direct(AddressOf(CRegisters::DoSysCallException), "CRegisters::DoSysCallException");
if (_SyncSystem) { Call_Direct(SyncToPC, "SyncToPC"); }
if (_SyncSystem) { Call_Direct(SyncSystem, "SyncSystem"); }
ExitCodeBlock();
}
break;
@ -263,7 +263,7 @@ void CCodeSection::CompileExit ( DWORD JumpPC, DWORD TargetPC, CRegInfo ExitRegS
PushImm32(bDelay ? "true" : "false", bDelay);
MoveConstToX86reg((DWORD)_Reg,x86_ECX);
Call_Direct(AddressOf(CRegisters::DoCopUnusableException), "CRegisters::DoCopUnusableException");
if (_SyncSystem) { Call_Direct(SyncToPC, "SyncToPC"); }
if (_SyncSystem) { Call_Direct(SyncSystem, "SyncSystem"); }
ExitCodeBlock();
}
break;
@ -273,7 +273,7 @@ void CCodeSection::CompileExit ( DWORD JumpPC, DWORD TargetPC, CRegInfo ExitRegS
if (NextInstruction == JUMP || NextInstruction == DELAY_SLOT) {
X86BreakPoint(__FILE__,__LINE__);
}
if (_SyncSystem) { Call_Direct(SyncToPC, "SyncToPC"); }
if (_SyncSystem) { Call_Direct(SyncSystem, "SyncSystem"); }
X86BreakPoint(__FILE__,__LINE__);
MoveVariableToX86reg(this,"this",x86_ECX);
Call_Direct(AddressOf(ResetRecompCode), "ResetRecompCode");
@ -286,7 +286,7 @@ void CCodeSection::CompileExit ( DWORD JumpPC, DWORD TargetPC, CRegInfo ExitRegS
MoveConstToX86reg(NextInstruction == JUMP || NextInstruction == DELAY_SLOT,x86_ECX);
MoveVariableToX86reg(&TLBLoadAddress,"TLBLoadAddress",x86_EDX);
Call_Direct(DoTLBMiss,"DoTLBMiss");
if (_SyncSystem) { Call_Direct(SyncToPC, "SyncToPC"); }
if (_SyncSystem) { Call_Direct(SyncSystem, "SyncSystem"); }
Ret();
#endif
break;
@ -372,7 +372,7 @@ void CCodeSection::GenerateSectionLinkage (void)
m_RegWorkingSet.WriteBackRegisters();
UpdateCounters(m_RegWorkingSet,false,true);
// WriteBackRegisters(Section);
// if (_SyncSystem) { Call_Direct(SyncToPC, "SyncToPC"); }
// if (_SyncSystem) { Call_Direct(SyncSystem, "SyncSystem"); }
// MoveConstToVariable(DELAY_SLOT,&NextInstruction,"NextInstruction");
PushImm32(stdstr_f("0x%08X",CRecompilerOps::CompilePC() + 4).c_str(),CRecompilerOps::CompilePC() + 4);

115
Source/Project64/N64 System/Recompiler/Function Info.cpp
View File

@ -10,118 +10,3 @@ CCompiledFunc::CCompiledFunc( const CCodeBlock & CodeBlock ) :
{
}
#ifdef tofix
CCompiledFunc::CCompiledFunc(DWORD StartAddress, DWORD PhysicalStartAddress) :
m_VEnterPC(StartAddress),
m_PEnterPC(PhysicalStartAddress),
m_VMinPC(StartAddress),
m_VMaxPC(StartAddress),
m_Function(NULL),
Next(NULL)
{
for (int i = 0; i < (sizeof(MemContents) / sizeof(MemContents[0])); i++ )
{
MemContents[i] = 0;
MemLocation[i] = NULL;
}
}
bool CCompiledFunc::CompilerCodeBlock(void)
{
DWORD StartTime = timeGetTime();
WriteTraceF(TraceRecompiler,"Compile Block-Start: VEnterPC: %X PEnterPC",m_VEnterPC,m_PEnterPC);
//if (bProfiling()) { m_Profile.StartTimer(Timer_GetBlockInfo); }
CBlockInfo BlockInfo(*_PROGRAM_COUNTER, RecompPos);
//if (bProfiling()) { m_Profile.StartTimer(Timer_AnalyseBlock); }
#ifdef tofix
if (bProfiling()) { m_Profile.StartTimer(Timer_CompileBlock); }
_Notify->BreakPoint(__FILE__,__LINE__);
DWORD StartAddress;
if (!_TLB->TranslateVaddr(BlockInfo.StartVAddr,StartAddress))
{
DisplayError("Ummm... Where does this block go\n%X",BlockInfo.StartVAddr);
return false;
}
MarkCodeBlock(StartAddress);
if (StartAddress < RdramSize()) {
CPU_Message("====== RDRAM: block (%X:%d) ======", StartAddress>>12,N64_Blocks.NoOfRDRamBlocks[StartAddress>>12]);
} else if (StartAddress >= 0x04000000 && StartAddress <= 0x04000FFC) {
CPU_Message("====== DMEM: block (%d) ======", N64_Blocks.NoOfDMEMBlocks);
} else if (StartAddress >= 0x04001000 && StartAddress <= 0x04001FFC) {
CPU_Message("====== IMEM: block (%d) ======", N64_Blocks.NoOfIMEMBlocks);
} else if (StartAddress >= 0x1FC00000 && StartAddress <= 0x1FC00800) {
CPU_Message("====== PIF ROM: block ======");
} else {
#ifndef ROM_IN_MAPSPACE
#ifndef EXTERNAL_RELEASE
DisplayError("Ummm... Where does this block go");
#endif
ExitThread(0);
#endif
}
#endif
CPU_Message("====== Code block ======");
CPU_Message("VAddress: %X",BlockInfo.StartVAddr );
CPU_Message("x86 code at: %X",BlockInfo.CompiledLocation);
CPU_Message("No of Sections: %d",BlockInfo.NoOfSections );
CPU_Message("====== recompiled code ======");
/*if (bLinkBlocks()) {
for (int count = 0; count < BlockInfo.NoOfSections; count ++) {
DisplaySectionInformation(&BlockInfo.ParentSection,count + 1,CBlockSection::GetNewTestValue());
}
}
if (m_SyncSystem) {
//if ((DWORD)BlockInfo.CompiledLocation == 0x60A7B73B) { X86BreakPoint(__FILE__,__LINE__); }
//MoveConstToVariable((DWORD)BlockInfo.CompiledLocation,&CurrentBlock,"CurrentBlock");
}
BlockInfo.ParentSection.RegStart.Initilize();
BlockInfo.ParentSection.RegWorking = BlockInfo.ParentSection.RegStart;
if (bLinkBlocks()) {
while (GenerateX86Code(BlockInfo,&BlockInfo.ParentSection,CBlockSection::GetNewTestValue()));
} else {
GenerateX86Code(BlockInfo,&BlockInfo.ParentSection,CBlockSection::GetNewTestValue());
}
CompileExitCode(BlockInfo);
CPU_Message("====== End of recompiled code ======");
if (bProfiling()) { m_Profile.StartTimer(Timer_CompileDone); }
info->SetVEndPC(BlockInfo.EndVAddr);
// info->SetFunctionAddr(BlockInfo.CompiledLocation);
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
_TLB->VAddrToRealAddr(info->VStartPC(),*(reinterpret_cast<void **>(&info->MemLocation[0])));
info->MemLocation[1] = info->MemLocation[0] + 1;
info->MemContents[0] = *info->MemLocation[0];
info->MemContents[1] = *info->MemLocation[1];
if (bSMM_Protect())
{
_MMU->ProtectMemory(info->VStartPC(),info->VEndPC());
}
NextInstruction = NORMAL;
if (bShowRecompMemSize())
{
DWORD Size = RecompPos - RecompCode;
DWORD MB = Size / 0x100000;
Size -= MB * 0x100000;
DWORD KB = Size / 1024;
Size -= KB * 1024;
DWORD TotalAvaliable = _MMU->GetRecompBufferSize() / 0x100000;
DisplayMessage(0,"Memory used: %d mb %-3d kb %-3d bytes Total Available: %d mb",MB,KB,Size, TotalAvaliable);
}
if (bProfiling()) { m_Profile.StopTimer(); }
#endif
DWORD TimeTaken = timeGetTime() - StartTime;
WriteTraceF(TraceRecompiler,"Compile Block-Done: %X-%X - Taken: %d",info->VStartPC(),info->VEndPC(),TimeTaken);*/
return true;
}
#endif

8
Source/Project64/N64 System/Recompiler/Function Map Class.cpp
View File

@ -17,6 +17,7 @@ bool CFunctionMap::AllocateMemory()
{
m_FunctionTable = (PCCompiledFunc_TABLE *)VirtualAlloc(NULL,0xFFFFF * sizeof(CCompiledFunc *),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
if (m_FunctionTable == NULL) {
WriteTrace(TraceError,"CFunctionMap::AllocateMemory: failed to allocate function table");
_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
return false;
}
@ -26,6 +27,7 @@ bool CFunctionMap::AllocateMemory()
{
m_DelaySlotTable = (BYTE **)VirtualAlloc(NULL,0xFFFFF * sizeof(BYTE *),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
if (m_DelaySlotTable == NULL) {
WriteTrace(TraceError,"CFunctionMap::AllocateMemory: failed to allocate delay slot table");
_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
return false;
}
@ -159,7 +161,7 @@ void CFunctionMap::Reset( bool AllocateMemory )
{
m_FunctionTable = (CCompiledFunc *)VirtualAlloc(NULL,0xFFFFF * sizeof(CCompiledFunc *),MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
if (m_FunctionTable == NULL) {
Notify().FatalError(MSG_MEM_ALLOC_ERROR);
_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
}
}
memset(m_FunctionTable,0,0xFFFFF * sizeof(DWORD));
@ -175,7 +177,7 @@ CCompiledFunc * CFunctionMap::AddFunctionInfo( DWORD vAddr, DWORD pAddr )
table = new PCCompiledFunc[(0x1000 >> 2)];
if (table == NULL)
{
Notify().FatalError(MSG_MEM_ALLOC_ERROR);
_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
}
memset(table,0,sizeof(PCCompiledFunc) * (0x1000 >> 2));
}
@ -213,7 +215,7 @@ void CFunctionMap::Remove(CCompiledFunc * info)
delete info;
table[(vAddr & 0xFFF) >> 2] = NULL;
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
}
*/

80
Source/Project64/N64 System/Recompiler/Recompiler Class.cpp
View File

@ -9,10 +9,7 @@ CRecompiler::CRecompiler(CProfiling & Profile, bool & EndEmulation ) :
CRecompiler::~CRecompiler()
{
for (int i = 0, n = m_Functions.size(); i < n; i++)
{
delete m_Functions[i];
}
ResetRecompCode();
}
void CRecompiler::Run()
@ -60,7 +57,7 @@ void CRecompiler::Run()
}
__except( _MMU->MemoryFilter( GetExceptionCode(), GetExceptionInformation()) )
{
Notify().DisplayError(MSG_UNKNOWN_MEM_ACTION);
_Notify->DisplayError(MSG_UNKNOWN_MEM_ACTION);
}
}
@ -101,9 +98,15 @@ void CRecompiler::RecompilerMain_VirtualTable ( void )
table = new PCCompiledFunc[(0x1000 >> 2)];
if (table == NULL)
{
Notify().FatalError(MSG_MEM_ALLOC_ERROR);
WriteTrace(TraceError,"CRecompiler::RecompilerMain_VirtualTable: failed to allocate PCCompiledFunc");
_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
}
memset(table,0,sizeof(PCCompiledFunc) * (0x1000 >> 2));
if (bSMM_Protect())
{
WriteTraceF(TraceError,"Create Table (%X): Index = %d",table, PROGRAM_COUNTER >> 0xC);
_MMU->ProtectMemory(PROGRAM_COUNTER & ~0xFFF,PROGRAM_COUNTER | 0xFFF);
}
}
table[TableEntry] = info;
@ -445,6 +448,19 @@ void CRecompiler::ResetRecompCode()
{
CRecompMemory::Reset();
CFunctionMap::Reset();
for (CCompiledFuncList::iterator iter = m_Functions.begin(); iter != m_Functions.end(); iter++)
{
CCompiledFunc * Func = iter->second;
while (Func != NULL)
{
CCompiledFunc * CurrentFunc = Func;
Func = Func->Next();
delete CurrentFunc;
}
}
m_Functions.clear();
}
BYTE * CRecompiler::CompileDelaySlot(DWORD PC)
@ -1744,7 +1760,7 @@ void CRecompiler::RecompilerMain_ChangeMemory ( void )
CCompiledFunc * CRecompiler::CompilerCode ( void )
{
DWORD pAddr;
DWORD pAddr = 0;
if (!_TransVaddr->TranslateVaddr(*_PROGRAM_COUNTER,pAddr))
{
WriteTraceF(TraceError,"CRecompiler::CompilerCode: Failed to translate %X",*_PROGRAM_COUNTER);
@ -1756,13 +1772,15 @@ CCompiledFunc * CRecompiler::CompilerCode ( void )
{
for (CCompiledFunc * Func = iter->second; Func != NULL; Func = Func->Next())
{
MD5Digest Hash;
DWORD PAddr;
_TransVaddr->TranslateVaddr(Func->MinPC(),PAddr);
MD5(_MMU->Rdram() + PAddr,(Func->MaxPC() - Func->MinPC())+ 4).get_digest(Hash);
if (memcmp(Hash.digest,Func->Hash().digest,sizeof(Hash.digest)) == 0)
if (_TransVaddr->TranslateVaddr(Func->MinPC(),PAddr))
{
return Func;
MD5Digest Hash;
MD5(_MMU->Rdram() + PAddr,(Func->MaxPC() - Func->MinPC())+ 4).get_digest(Hash);
if (memcmp(Hash.digest,Func->Hash().digest,sizeof(Hash.digest)) == 0)
{
return Func;
}
}
}
}
@ -1772,7 +1790,6 @@ CCompiledFunc * CRecompiler::CompilerCode ( void )
DWORD StartTime = timeGetTime();
WriteTraceF(TraceRecompiler,"Compile Block-Start: Program Counter: %X pAddr: %X",*_PROGRAM_COUNTER,pAddr);
CCodeBlock CodeBlock(*_PROGRAM_COUNTER, RecompPos(),false);
if (!CodeBlock.Compile())
{
@ -1796,37 +1813,31 @@ CCompiledFunc * CRecompiler::CompilerCode ( void )
}
bool CRecompiler::ClearRecompCode_Phys(DWORD Address, int length, REMOVE_REASON Reason ) {
void CRecompiler::ClearRecompCode_Phys(DWORD Address, int length, REMOVE_REASON Reason ) {
WriteTraceF(TraceError,"CRecompiler::ClearRecompCode_Phys Not Implemented (Address: %X, Length: %d Reason: %d)",Address,length,Reason);
bool Result = true;
#ifdef tofix
if (!ClearRecompCode_Virt(Address + 0x80000000,length,Reason)) { Result = false; }
if (!ClearRecompCode_Virt(Address + 0xA0000000,length,Reason)) { Result = false; }
if (g_UseTlb)
if (LookUpMode() == FuncFind_VirtualLookup)
{
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
DWORD VAddr, Index = 0;
while (_TLB->PAddrToVAddr(Address,VAddr,Index))
ClearRecompCode_Virt(Address + 0x80000000,length,Reason);
ClearRecompCode_Virt(Address + 0xA0000000,length,Reason);
if (g_UseTlb)
{
WriteTraceF(TraceRecompiler,"ClearRecompCode Vaddr %X len: %d",VAddr,length);
if (!ClearRecompCode_Virt(VAddr,length,Reason))
DWORD VAddr, Index = 0;
while (_TLB->PAddrToVAddr(Address,VAddr,Index))
{
Result = false;
WriteTraceF(TraceRecompiler,"ClearRecompCode Vaddr %X len: %d",VAddr,length);
ClearRecompCode_Virt(VAddr,length,Reason);
}
}
#endif
}
if (LookUpMode() == FuncFind_PhysicalLookup)
#ifdef tofix
else if (LookUpMode() == FuncFind_PhysicalLookup)
{
WriteTraceF(TraceRecompiler,"Reseting Jump Table, Addr: %X len: %d",Address,((length + 3) & ~3));
memset((BYTE *)JumpTable + Address,0,((length + 3) & ~3));
}
#endif
return Result;
}
void CRecompiler::ClearRecompCode_Virt(DWORD Address, int length,REMOVE_REASON Reason )
@ -1837,6 +1848,7 @@ void CRecompiler::ClearRecompCode_Virt(DWORD Address, int length,REMOVE_REASON R
{
DWORD AddressIndex = Address >> 0xC;
DWORD WriteStart = (Address & 0xFFC);
bool bUnProtect = false;
length = ((length + 3) & ~0x3);
BYTE ** DelaySlotFuncs = DelaySlotTable();
@ -1844,6 +1856,7 @@ void CRecompiler::ClearRecompCode_Virt(DWORD Address, int length,REMOVE_REASON R
if (WriteStart == 0 && DelaySlotFuncs[AddressIndex] != NULL)
{
DelaySlotFuncs[AddressIndex] = NULL;
_MMU->UnProtectMemory(Address,Address+ 4);
}
DWORD DataInBlock = 0x1000 - WriteStart;
@ -1853,7 +1866,10 @@ void CRecompiler::ClearRecompCode_Virt(DWORD Address, int length,REMOVE_REASON R
PCCompiledFunc_TABLE & table = FunctionTable()[AddressIndex];
if (table)
{
memset(((BYTE *)&table[0]) + WriteStart,0,DataToWrite);
WriteTraceF(TraceError,"Delete Table (%X): Index = %d",table, AddressIndex);
delete table;
table = NULL;
_MMU->UnProtectMemory(Address,Address + length);
}
if (DataLeft > 0)

2
Source/Project64/N64 System/Recompiler/Recompiler Class.h
View File

@ -30,7 +30,7 @@ public:
//Self modifying code methods
void ClearRecompCode_Virt ( DWORD VirtualAddress, int length, REMOVE_REASON Reason );
bool ClearRecompCode_Phys ( DWORD PhysicalAddress, int length, REMOVE_REASON Reason );
void ClearRecompCode_Phys ( DWORD PhysicalAddress, int length, REMOVE_REASON Reason );
private:
CCompiledFuncList m_Functions;

7
Source/Project64/N64 System/Recompiler/Recompiler Memory.cpp
View File

@ -22,6 +22,7 @@ bool CRecompMemory::AllocateMemory()
BYTE * RecompCodeBase = (BYTE *)VirtualAlloc( NULL, MaxCompileBufferSize + 4, MEM_RESERVE|MEM_TOP_DOWN, PAGE_EXECUTE_READWRITE);
if (RecompCodeBase==NULL)
{
WriteTrace(TraceError,"CRecompMemory::AllocateMemory: failed to allocate RecompCodeBase");
_Notify->DisplayError(MSG_MEM_ALLOC_ERROR);
return FALSE;
}
@ -29,6 +30,7 @@ bool CRecompMemory::AllocateMemory()
m_RecompCode = (BYTE *)VirtualAlloc( RecompCodeBase, InitialCompileBufferSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (m_RecompCode==NULL)
{
WriteTrace(TraceError,"CRecompMemory::AllocateMemory: failed to commit initial buffer");
VirtualFree( RecompCodeBase, 0 , MEM_RELEASE);
_Notify->DisplayError(MSG_MEM_ALLOC_ERROR);
return FALSE;
@ -51,12 +53,13 @@ void CRecompMemory::CheckRecompMem ( void )
return;
}
LPVOID MemAddr = VirtualAlloc( m_RecompCode + m_RecompSize , IncreaseCompileBufferSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
m_RecompSize += IncreaseCompileBufferSize;
if (MemAddr == NULL)
{
WriteTrace(TraceError,"CRecompMemory::CheckRecompMem: failed to increase buffer");
_Notify->FatalError(MSG_MEM_ALLOC_ERROR);
}
m_RecompSize += IncreaseCompileBufferSize;
}
void CRecompMemory::Reset()

106
Source/Project64/N64 System/Recompiler/Recompiler Ops.cpp
View File

@ -1768,7 +1768,8 @@ void CRecompilerOps::SPECIAL_JR (void) {
m_Section->CompileExit(m_CompilePC,(DWORD)-1,m_RegWorkingSet,CExitInfo::Normal,TRUE,NULL);
} else {
if (IsConst(m_Opcode.rs)) {
memcpy(&m_Section->m_Jump.RegSet,&m_RegWorkingSet,sizeof(CRegInfo));
UpdateCounters(m_RegWorkingSet,true,true);
m_Section->m_Jump.RegSet = m_RegWorkingSet;
m_Section->GenerateSectionLinkage();
} else {
if (IsMapped(m_Opcode.rs)) {
@ -1918,8 +1919,6 @@ void CRecompilerOps::SPECIAL_MTHI (void) {
}
void CRecompilerOps::SPECIAL_DSLLV (void) {
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
BYTE * Jump[2];
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(m_Opcode.Hex,m_CompilePC));
@ -1936,8 +1935,8 @@ void CRecompilerOps::SPECIAL_DSLLV (void) {
CompConstToX86reg(x86_ECX,0x20);
JaeLabel8("MORE32", 0);
Jump[0] = m_RecompPos - 1;
ShiftLeftDouble(MipsRegHi(m_Opcode.rd),cMipsRegLo(m_Opcode.rd));
ShiftLeftSign(cMipsRegLo(m_Opcode.rd));
ShiftLeftDouble(cMipsRegMapHi(m_Opcode.rd),cMipsRegMapLo(m_Opcode.rd));
ShiftLeftSign(cMipsRegMapLo(m_Opcode.rd));
JmpLabel8("continue", 0);
Jump[1] = m_RecompPos - 1;
@ -1945,16 +1944,15 @@ void CRecompilerOps::SPECIAL_DSLLV (void) {
CPU_Message("");
CPU_Message(" MORE32:");
*((BYTE *)(Jump[0]))=(BYTE)(m_RecompPos - Jump[0] - 1);
MoveX86RegToX86Reg(cMipsRegLo(m_Opcode.rd),MipsRegHi(m_Opcode.rd));
XorX86RegToX86Reg(cMipsRegLo(m_Opcode.rd),cMipsRegLo(m_Opcode.rd));
MoveX86RegToX86Reg(cMipsRegMapLo(m_Opcode.rd),cMipsRegMapHi(m_Opcode.rd));
XorX86RegToX86Reg(cMipsRegMapLo(m_Opcode.rd),cMipsRegMapLo(m_Opcode.rd));
AndConstToX86Reg(x86_ECX,0x1F);
ShiftLeftSign(MipsRegHi(m_Opcode.rd));
ShiftLeftSign(cMipsRegMapHi(m_Opcode.rd));
//continue:
CPU_Message("");
CPU_Message(" continue:");
*((BYTE *)(Jump[1]))=(BYTE)(m_RecompPos - Jump[1] - 1);
#endif
}
void CRecompilerOps::SPECIAL_DSRLV (void) {
@ -2222,23 +2220,29 @@ void CRecompilerOps::SPECIAL_DIVU ( void) {
}
}
void CRecompilerOps::SPECIAL_DMULT (void) {
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
void CRecompilerOps::SPECIAL_DMULT (void)
{
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(m_Opcode.Hex,m_CompilePC));
if (m_Opcode.rs != 0) { UnMap_GPR(m_Opcode.rs,TRUE); }
if (m_Opcode.rs != 0) { UnMap_GPR(m_Opcode.rt,TRUE); }
BeforeCallDirect();
BeforeCallDirect(m_RegWorkingSet);
MoveConstToVariable(m_Opcode.Hex, &R4300iOp::m_Opcode.Hex, "R4300iOp::m_Opcode.Hex");
Call_Direct(R4300iOp::SPECIAL_DMULT, "R4300iOp::SPECIAL_DMULT");
AfterCallDirect();
#endif
AfterCallDirect(m_RegWorkingSet);
}
void CRecompilerOps::SPECIAL_DMULTU (void) {
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(m_Opcode.Hex,m_CompilePC));
UnMap_GPR(m_Opcode.rs,TRUE);
UnMap_GPR(m_Opcode.rt,TRUE);
BeforeCallDirect(m_RegWorkingSet);
MoveConstToVariable(m_Opcode.Hex, &R4300iOp::m_Opcode.Hex, "R4300iOp::m_Opcode.Hex");
Call_Direct(R4300iOp::SPECIAL_DMULTU, "R4300iOp::SPECIAL_DMULTU");
AfterCallDirect(m_RegWorkingSet);
#ifdef toremove
/* _RegLO->UDW = (uint64)_GPR[m_Opcode.rs].UW[0] * (uint64)_GPR[m_Opcode.rt].UW[0]; */
X86Protected(x86_EDX) = TRUE;
Map_TempReg(x86_EAX,m_Opcode.rs,FALSE);
@ -2303,6 +2307,7 @@ void CRecompilerOps::SPECIAL_DMULTU (void) {
AddX86regToVariable(x86_EDX, &_RegHI->UW[0], "_RegHI->UW[0]");
AdcConstToVariable(&_RegHI->UW[1], "_RegHI->UW[1]", 0);
#endif
}
void CRecompilerOps::SPECIAL_DDIV (void) {
@ -3232,8 +3237,6 @@ void CRecompilerOps::SPECIAL_SLTU (void) {
}
void CRecompilerOps::SPECIAL_DADD (void) {
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(m_Opcode.Hex,m_CompilePC));
if (m_Opcode.rd == 0) { return; }
@ -3255,24 +3258,21 @@ void CRecompilerOps::SPECIAL_DADD (void) {
Map_GPR_64bit(m_Opcode.rd,source1);
if (IsConst(source2)) {
AddConstToX86Reg(cMipsRegLo(m_Opcode.rd),cMipsRegLo(source2));
AddConstToX86Reg(MipsRegHi(m_Opcode.rd),MipsRegHi(source2));
AddConstToX86Reg(cMipsRegMapLo(m_Opcode.rd),cMipsRegLo(source2));
AddConstToX86Reg(cMipsRegMapHi(m_Opcode.rd),MipsRegHi(source2));
} else if (IsMapped(source2)) {
x86Reg HiReg = Is64Bit(source2)?MipsRegMapHi(source2):Map_TempReg(x86_Any,source2,TRUE);
ProtectGPR(source2);
AddX86RegToX86Reg(cMipsRegMapLo(m_Opcode.rd),cMipsRegMapLo(source2));
AdcX86RegToX86Reg(cMipsRegMapHi(m_Opcode.rd),HiReg);
} else {
AddVariableToX86reg(cMipsRegLo(m_Opcode.rd),&_GPR[source2].W[0],CRegName::GPR_Lo[source2]);
AdcVariableToX86reg(MipsRegHi(m_Opcode.rd),&_GPR[source2].W[1],CRegName::GPR_Hi[source2]);
AddVariableToX86reg(cMipsRegMapLo(m_Opcode.rd),&_GPR[source2].W[0],CRegName::GPR_Lo[source2]);
AdcVariableToX86reg(cMipsRegMapHi(m_Opcode.rd),&_GPR[source2].W[1],CRegName::GPR_Hi[source2]);
}
}
#endif
}
void CRecompilerOps::SPECIAL_DADDU (void) {
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(m_Opcode.Hex,m_CompilePC));
if (m_Opcode.rd == 0) { return; }
@ -3294,24 +3294,21 @@ void CRecompilerOps::SPECIAL_DADDU (void) {
Map_GPR_64bit(m_Opcode.rd,source1);
if (IsConst(source2)) {
AddConstToX86Reg(cMipsRegLo(m_Opcode.rd),cMipsRegLo(source2));
AddConstToX86Reg(MipsRegHi(m_Opcode.rd),MipsRegHi(source2));
AddConstToX86Reg(cMipsRegMapLo(m_Opcode.rd),cMipsRegLo(source2));
AddConstToX86Reg(cMipsRegMapHi(m_Opcode.rd),MipsRegHi(source2));
} else if (IsMapped(source2)) {
x86Reg HiReg = Is64Bit(source2)?MipsRegMapHi(source2):Map_TempReg(x86_Any,source2,TRUE);
ProtectGPR(source2);
AddX86RegToX86Reg(cMipsRegMapLo(m_Opcode.rd),cMipsRegMapLo(source2));
AdcX86RegToX86Reg(cMipsRegMapHi(m_Opcode.rd),HiReg);
} else {
AddVariableToX86reg(cMipsRegLo(m_Opcode.rd),&_GPR[source2].W[0],CRegName::GPR_Lo[source2]);
AdcVariableToX86reg(MipsRegHi(m_Opcode.rd),&_GPR[source2].W[1],CRegName::GPR_Hi[source2]);
AddVariableToX86reg(cMipsRegMapLo(m_Opcode.rd),&_GPR[source2].W[0],CRegName::GPR_Lo[source2]);
AdcVariableToX86reg(cMipsRegMapHi(m_Opcode.rd),&_GPR[source2].W[1],CRegName::GPR_Hi[source2]);
}
}
#endif
}
void CRecompilerOps::SPECIAL_DSUB (void) {
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(m_Opcode.Hex,m_CompilePC));
if (m_Opcode.rd == 0) { return; }
@ -3332,25 +3329,24 @@ void CRecompilerOps::SPECIAL_DSUB (void) {
x86Reg HiReg = Map_TempReg(x86_Any,m_Opcode.rt,TRUE);
x86Reg LoReg = Map_TempReg(x86_Any,m_Opcode.rt,FALSE);
Map_GPR_64bit(m_Opcode.rd,m_Opcode.rs);
SubX86RegToX86Reg(cMipsRegLo(m_Opcode.rd),LoReg);
SubX86RegToX86Reg(cMipsRegMapLo(m_Opcode.rd),LoReg);
SbbX86RegToX86Reg(cMipsRegMapHi(m_Opcode.rd),HiReg);
return;
}
Map_GPR_64bit(m_Opcode.rd,m_Opcode.rs);
if (IsConst(m_Opcode.rt)) {
SubConstFromX86Reg(cMipsRegLo(m_Opcode.rd),cMipsRegLo(m_Opcode.rt));
SbbConstFromX86Reg(MipsRegHi(m_Opcode.rd),MipsRegHi(m_Opcode.rt));
SubConstFromX86Reg(cMipsRegMapLo(m_Opcode.rd),cMipsRegLo(m_Opcode.rt));
SbbConstFromX86Reg(cMipsRegMapHi(m_Opcode.rd),MipsRegHi(m_Opcode.rt));
} else if (IsMapped(m_Opcode.rt)) {
x86Reg HiReg = Is64Bit(m_Opcode.rt)?cMipsRegMapHi(m_Opcode.rt):Map_TempReg(x86_Any,m_Opcode.rt,TRUE);
ProtectGPR(m_Opcode.rt);
SubX86RegToX86Reg(cMipsRegLo(m_Opcode.rd),cMipsRegLo(m_Opcode.rt));
SubX86RegToX86Reg(cMipsRegMapLo(m_Opcode.rd),cMipsRegMapLo(m_Opcode.rt));
SbbX86RegToX86Reg(cMipsRegMapHi(m_Opcode.rd),HiReg);
} else {
SubVariableFromX86reg(cMipsRegLo(m_Opcode.rd),&_GPR[m_Opcode.rt].W[0],CRegName::GPR_Lo[m_Opcode.rt]);
SbbVariableFromX86reg(MipsRegHi(m_Opcode.rd),&_GPR[m_Opcode.rt].W[1],CRegName::GPR_Hi[m_Opcode.rt]);
SubVariableFromX86reg(cMipsRegMapLo(m_Opcode.rd),&_GPR[m_Opcode.rt].W[0],CRegName::GPR_Lo[m_Opcode.rt]);
SbbVariableFromX86reg(cMipsRegMapHi(m_Opcode.rd),&_GPR[m_Opcode.rt].W[1],CRegName::GPR_Hi[m_Opcode.rt]);
}
}
#endif
}
void CRecompilerOps::SPECIAL_DSUBU (void) {
@ -4232,7 +4228,7 @@ void CRecompilerOps::COP1_S_CMP (void) {
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(m_Opcode.Hex,m_CompilePC));
m_Section->CompileCop1Test();
if ((m_Opcode.funct & 1) != 0) { CRecompilerOps::UnknownOpcode(); }
if ((m_Opcode.funct & 7) == 0) { CRecompilerOps::UnknownOpcode(); }
if ((m_Opcode.funct & 2) != 0) { cmp |= 0x4000; }
if ((m_Opcode.funct & 4) != 0) { cmp |= 0x0100; }
@ -4392,12 +4388,9 @@ void CRecompilerOps::COP1_D_DIV (void) {
}
void CRecompilerOps::COP1_D_ABS (void) {
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(m_Opcode.Hex,m_CompilePC));
Load_FPR_ToTop(m_Opcode.fd,m_Opcode.fs,CRegInfo::FPU_Double);
fpuAbs();
#endif
}
void CRecompilerOps::COP1_D_NEG (void) {
@ -4407,12 +4400,9 @@ void CRecompilerOps::COP1_D_NEG (void) {
}
void CRecompilerOps::COP1_D_SQRT (void) {
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
CPU_Message(" %X %s",m_CompilePC,R4300iOpcodeName(m_Opcode.Hex,m_CompilePC));
Load_FPR_ToTop(m_Opcode.fd,m_Opcode.fs,CRegInfo::FPU_Double);
fpuSqrt();
#endif
}
void CRecompilerOps::COP1_D_MOV (void) {
@ -4675,23 +4665,19 @@ void CRecompilerOps::COP1_L_CVT_D (void) {
/************************** Other functions **************************/
void CRecompilerOps::UnknownOpcode (void) {
_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
CPU_Message(" %X Unhandled Opcode: %s",m_CompilePC, R4300iOpcodeName(Opcode.Hex,m_CompilePC));
CPU_Message(" %X Unhandled Opcode: %s",m_CompilePC, R4300iOpcodeName(m_Opcode.Hex,m_CompilePC));
// FreeSection(m_Section->m_ContinueSection,m_Section);
// FreeSection(m_Section->m_JumpSection,m_Section);
m_RegWorkingSet.BlockCycleCount() -= CountPerOp;
m_RegWorkingSet.BlockRandomModifier() -= 1;
MoveConstToVariable(m_CompilePC,_PROGRAM_COUNTER,"PROGRAM_COUNTER");
m_RegWorkingSet.WriteBackRegisters();
UpdateCounters(&m_RegWorkingSet.BlockCycleCount(),&m_RegWorkingSet.BlockRandomModifier(),FALSE);
if (CPU_Type == CPU_SyncCores) { Call_Direct(SyncToPC, "SyncToPC"); }
MoveConstToVariable(Opcode.Hex,&Opcode.Hex,"Opcode.Hex");
UpdateCounters(m_RegWorkingSet,false,true);
MoveConstToVariable(m_CompilePC,&_Reg->m_PROGRAM_COUNTER,"PROGRAM_COUNTER");
if (_SyncSystem) { Call_Direct(SyncSystem, "SyncSystem"); }
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_CountPerOp);
MoveConstToVariable(m_Opcode.Hex, &R4300iOp::m_Opcode.Hex, "R4300iOp::m_Opcode.Hex");
Call_Direct(R4300iOp::UnknownOpcode, "R4300iOp::UnknownOpcode");
Ret();
if (m_NextInstruction == NORMAL) { m_NextInstruction = END_BLOCK; }
#endif
}
void CRecompilerOps::BeforeCallDirect ( CRegInfo & RegSet )
@ -4710,6 +4696,9 @@ void CRecompilerOps::EnterCodeBlock ( void )
{
#ifdef _DEBUG
Push(x86_ESI);
#else
Push(x86_ESI);
Push(x86_EBX);
#endif
}
@ -4717,6 +4706,9 @@ void CRecompilerOps::ExitCodeBlock ( void )
{
#ifdef _DEBUG
Pop(x86_ESI);
#else
Pop(x86_EBX);
Pop(x86_ESI);
#endif
Ret();
}

10
Source/Project64/N64 System/Recompiler/Section Info.cpp
View File

@ -151,7 +151,7 @@ void CCodeSection::UnlinkParent( CCodeSection * Parent, bool AllowDelete, bool C
// {
// if (!ContinueSection && Parent->ContinueSection == this)
// {
// Notify().BreakPoint(__FILE__,__LINE__);
// _Notify->BreakPoint(__FILE__,__LINE__);
// }
// }
if (ContinueSection && Parent->ContinueSection == this)
@ -162,7 +162,7 @@ void CCodeSection::UnlinkParent( CCodeSection * Parent, bool AllowDelete, bool C
// {
// if (ContinueSection && Parent->JumpSection == this)
// {
// Notify().BreakPoint(__FILE__,__LINE__);
// _Notify->BreakPoint(__FILE__,__LINE__);
// }
// }
if (!ContinueSection && Parent->JumpSection == this)
@ -201,7 +201,7 @@ CCodeSection::~CCodeSection ( void )
ContinueSection->UnlinkParent(this, true, true);
if (ContinueSection)
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
ContinueSection = NULL;
}
@ -210,7 +210,7 @@ CCodeSection::~CCodeSection ( void )
JumpSection->UnlinkParent(this, true, false);
if (JumpSection)
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
JumpSection = NULL;
}
@ -274,7 +274,7 @@ void CCodeSection::AddParent(CCodeSection * Parent )
} else if (Parent->JumpSection == this) {
RegStart = Parent->Jump.RegSet;
} else {
Notify().DisplayError("How are these sections joined?????");
_Notify->DisplayError("How are these sections joined?????");
}
RegWorking = RegStart;
} else {

2
Source/Project64/N64 System/Recompiler/X86ops.cpp
View File

@ -51,7 +51,7 @@ void CX86Ops::AdcConstToX86Reg (x86Reg reg, DWORD Const) {
void CX86Ops::AdcVariableToX86reg(x86Reg reg, void * Variable, const char * VariableName) {
CPU_Message(" adc %s, dword ptr [%s]",x86_Name(reg),VariableName);
PUTDST16(m_RecompPos,0x0513 + (reg * 0x100));
PUTDST16(m_RecompPos,0x0513 + (reg * 0x800));
PUTDST32(m_RecompPos,Variable);
}

2
Source/Project64/Plugins/Plugin Class.cpp
View File

@ -59,7 +59,7 @@ void CPlugins::CreatePlugins( void ) {
if (_Settings->LoadBool(Debugger_Enabled))
{
Notify().RefreshMenu();
_Notify->RefreshMenu();
}
}

52
Source/Project64/Project64.dsp
View File

@ -354,10 +354,18 @@ SOURCE="N64 System\Mips\Audio.cpp"
# End Source File
# Begin Source File
SOURCE=".\N64 System\Mips\Dma.cpp"
# End Source File
# Begin Source File
SOURCE=".\N64 System\Mips\Eeprom.cpp"
# End Source File
# Begin Source File
SOURCE=".\N64 System\Mips\FlashRam.cpp"
# End Source File
# Begin Source File
SOURCE="N64 System\Mips\Memory Labels Class.cpp"
# End Source File
# Begin Source File
@ -386,6 +394,10 @@ SOURCE="N64 System\Mips\Register Class.cpp"
# End Source File
# Begin Source File
SOURCE=".\N64 System\Mips\Sram.cpp"
# End Source File
# Begin Source File
SOURCE=".\N64 System\Mips\System Events.cpp"
# End Source File
# Begin Source File
@ -418,14 +430,6 @@ SOURCE=".\N64 System\C Core\CPU Log.cpp"
# End Source File
# Begin Source File
SOURCE="N64 System\C Core\Dma.cpp"
# End Source File
# Begin Source File
SOURCE=".\N64 System\C Core\FlashRam.cpp"
# End Source File
# Begin Source File
SOURCE=".\N64 System\C Core\Logging.cpp"
# End Source File
# Begin Source File
@ -434,10 +438,6 @@ SOURCE=".\N64 System\C Core\Mempak.cpp"
# End Source File
# Begin Source File
SOURCE=".\N64 System\C Core\Pif.cpp"
# End Source File
# Begin Source File
SOURCE=".\N64 System\C Core\r4300i Commands.cpp"
# End Source File
# Begin Source File
@ -446,10 +446,6 @@ SOURCE=".\N64 System\C Core\r4300i Registers.cpp"
# End Source File
# Begin Source File
SOURCE=".\N64 System\C Core\Sram.cpp"
# End Source File
# Begin Source File
SOURCE=".\N64 System\C Core\Win32Timer.cpp"
# End Source File
# End Group
@ -975,6 +971,10 @@ SOURCE="N64 System\Mips\Audio.h"
# End Source File
# Begin Source File
SOURCE=".\N64 System\Mips\Dma.h"
# End Source File
# Begin Source File
SOURCE=".\N64 System\Mips\Eeprom.h"
# End Source File
# Begin Source File
@ -983,6 +983,10 @@ SOURCE=".\N64 System\Mips\Exception.h"
# End Source File
# Begin Source File
SOURCE=".\N64 System\Mips\FlashRam.h"
# End Source File
# Begin Source File
SOURCE="N64 System\Mips\Memory Class.h"
# End Source File
# Begin Source File
@ -1015,6 +1019,10 @@ SOURCE="N64 System\Mips\Register Class.h"
# End Source File
# Begin Source File
SOURCE=".\N64 System\Mips\Sram.h"
# End Source File
# Begin Source File
SOURCE=".\N64 System\Mips\System Events.h"
# End Source File
# Begin Source File
@ -1059,10 +1067,6 @@ SOURCE="N64 System\C Core\Debugger.h"
# End Source File
# Begin Source File
SOURCE="N64 System\C Core\Dma.h"
# End Source File
# Begin Source File
SOURCE="N64 System\C Core\Eeprom.h"
# End Source File
# Begin Source File
@ -1083,10 +1087,6 @@ SOURCE="N64 System\C Core\MEMPAK.H"
# End Source File
# Begin Source File
SOURCE="N64 System\C Core\Pif.h"
# End Source File
# Begin Source File
SOURCE="N64 System\C Core\r4300i Commands.h"
# End Source File
# Begin Source File
@ -1099,10 +1099,6 @@ SOURCE="N64 System\C Core\r4300i Registers.h"
# End Source File
# Begin Source File
SOURCE="N64 System\C Core\Sram.h"
# End Source File
# Begin Source File
SOURCE="N64 System\C Core\Win32Timer.h"
# End Source File
# End Group

170
Source/Project64/Settings.h
View File

@ -232,176 +232,6 @@ enum SettingID {
FirstAudioSettings, LastAudioSettings = FirstAudioSettings + MaxPluginSetting,
FirstCtrlDefaultSet, LastCtrlDefaultSet = FirstCtrlDefaultSet + MaxPluginSetting,
FirstCtrlSettings, LastCtrlSettings = FirstCtrlSettings + MaxPluginSetting,
/* No_Default, Default_False, Default_True, Default_Language, Default_RdramSize,
Default_RomStatus,Default_RomBrowserWidth,Default_RomBrowserHeight,
Default_RememberedRomFiles, Default_RememberedRomDirs, Default_CheatExt,
Default_SelfModCheck, Default_BlockLinking, Default_SaveSlot, Default_FunctionLookup,
Default_LogLevel, Default_FrameDisplayType,
//Settings
UseSettingFromRegistry,
//Language
CurrentLanguage,
//Gui Settings
MainWindowTop, MainWindowLeft, RomBrowser, RomBrowserRecursive,
RomBrowserSortFieldIndex, RomBrowserSortAscendingIndex,
RomBrowserWidth, RomBrowserHeight,RomBrowserTop, RomBrowserLeft, RomBrowserMaximized,
RomBrowserPosIndex, RomBrowserWidthIndex, TLBWindowTop, TLBWindowLeft,
//Beta Settings
IsBetaVersion, BetaUserName, BetaUserNameMD5, BetaEmailAddress, BetaEmailAddressMD5, BetaVersion,
IsValidExe,
//General Settings
AutoSleep, AutoFullScreen, AutoStart, AutoZip, BasicMode, RememberCheats,
DisableScrSaver, ShowCPUPer, LogFunctionCalls, ProfileCode, GenerateLogFiles,
LimitFPS, AlwaysOnTop, GenerateDebugLog, UseHighLevelGfx, UseHighLevelAudio,
DisableGameFixes, AppLogLevel, AppLogFlush, DisplayFrameRate, FrameDisplayType,
//Debugger
Debugger, ShowUnhandledMemory, ShowPifErrors, ShowDListAListCount, ShowCheckOpUsageErrors,
ShowRecompMemSize, ShowPifRamErrors,
//Recent Files and Directories
RememberedRomFilesCount, RecentRomFileIndex, RememberedRomDirCount, RecentRomDirIndex,
//Directories
InitialPluginDirectory, PluginDirectory, SelectedPluginDirectory, UsePluginDirSelected,
InitialRomDirectory, RomDirectory, SelectedRomDir, UseRomDirSelected,
InitialSaveDirectory, SaveDirectory, SelectedSaveDirectory, UseSaveDirSelected,
InitialInstantSaveDirectory, InstantSaveDirectory, SelectedInstantSaveDirectory, UseInstantDirSelected,
InitialSnapShotDir, SnapShotDir, SelectedSnapShotDir, UseSnapShotDirSelected,
SyncPluginDir, LastSaveDir, InitialTextureDir, TextureDir,
//Support Files
RomDatabaseFile, CheatIniName, SettingsIniName, NotesIniName, ExtIniName, ShortCutFile,
RomListCache, ZipCacheIniName,
//Plugins
DefaultRSP_Plugin, DefaultGFX_Plugin, DefaultAUDIO_Plugin, DefaultCONT_Plugin,
CurrentRSP_Plugin, CurrentGFX_Plugin, CurrentAUDIO_Plugin, CurrentCONT_Plugin,
CurVerRSP_Plugin, CurVerGFX_Plugin, CurVerAUDIO_Plugin, CurVerCONT_Plugin,
RSP_PluginChanged, GFX_PluginChanged, AUDIO_PluginChanged, CONT_PluginChanged,
FirstRSPDefaultSet, LastRSPDefaultSet = FirstRSPDefaultSet + MaxPluginSetting,
FirstRSPSettings, LastRSPSettings = FirstRSPSettings + MaxPluginSetting,
FirstGfxDefaultSet, LastGfxDefaultSet = FirstGfxDefaultSet + MaxPluginSetting,
FirstGfxSettings, LastGfxSettings = FirstGfxSettings + MaxPluginSetting,
FirstAudioDefaultSet, LastAudioDefaultSet = FirstAudioDefaultSet + MaxPluginSetting,
FirstAudioSettings, LastAudioSettings = FirstAudioSettings + MaxPluginSetting,
FirstCtrlDefaultSet, LastCtrlDefaultSet = FirstCtrlDefaultSet + MaxPluginSetting,
FirstCtrlSettings, LastCtrlSettings = FirstCtrlSettings + MaxPluginSetting,
//Cheats
CheatEntry, LastCheatEntry = CheatEntry + MaxCheats,
CheatPermEntry, LastPermCheatEntry = CheatPermEntry + MaxCheats,
CheatOptions, LastCheatOptions = CheatOptions + MaxCheats,
CheatRange, LastCheatRange = CheatRange + MaxCheats,
CheatRangeNotes,LastCheatRangeNotes= CheatRangeNotes+ MaxCheats,
CheatNotes, LastCheatNotes = CheatNotes + MaxCheats,
CheatActive, LastCheatActive = CheatActive + MaxCheats,
CheatExtension, LastCheatExtension = CheatExtension + MaxCheats,
//Individual Game Settings
Game_SaveChip,
Game_LastSaveSlot,
//RDB Settings
Rdb_SaveChip,
//Default Values
System_SaveChip,
//Rom Settings
Default_CPUType,
Default_CFactor,
ROM_IniKey,
ROM_NAME,
ROM_GoodName,
ROM_MD5, ROM_LastMD5 = ROM_MD5 + MaxMD5_Per_Rom,
ROM_InternalName,
ROM_Default,
ROM_CPUType,
ROM_RomInMemory,
ROM_FunctionLookup,
ROM_RamSize,
ROM_Status,
ROM_CoreNotes,
ROM_PluginNotes,
ROM_CounterFactor,
ROM_CustomSMM,
ROM_SMM_Cache,
ROM_SMM_PIDMA,
ROM_SMM_TLB,
ROM_SMM_Protect,
ROM_SMM_ValidFunc,
ROM_SyncAudio,
ROM_UseTlb,
ROM_RegCache,
ROM_BlockLinking,
ROM_UseJumpTable,
ROM_DelayDlists,
ROM_DelaySI,
ROM_AudioSignal,
ROM_SPHack,
ROM_FixedAudio,
//Rom TLB Settings
ROM_TLB_VAddrStart,
ROM_TLB_VAddrLen,
ROM_TLB_PAddrStart,
//System Settings
SYSTEM_CPUType,
SYSTEM_RDRamSize,
SYSTEM_SelfModMethod,
SYSTEM_BlockLinking,
SYSTEM_FunctionLookup,
SYSTEM_SMM_Cache, //DWORD - Self mod method (clear code on clearing instruction cache)
SYSTEM_SMM_PIDMA, //DWORD - Self mod method (clear code on PI DMA blocks)
SYSTEM_SMM_ValidFunc, //DWORD - Self mod method (Compare memory contents of function on finding)
SYSTEM_SMM_Protect, //DWORD - Self mod method (Protect Memory from any write to the code pages)
SYSTEM_SMM_TLB, //DWORD - Self mod method (clear code on TLB unmapping)
//Currrent Running Information
RamSize, //DWORD - Size of RDRAM
CPUType, //DWORD - Current CPU
CPU_Paused, //bool - Is CPU Paused
CPU_Paused_type, //DWORD - What type of pause is it
SMM_ChangeMemory,
SMM_CheckMemory2,
SMM_CheckMemoryCache,
BlockLinking,
FuncLookupMode,
DelayDlists, //DWORD - Delay when interrupt is set for DLIST
DelaySI,
CounterFactor, //DWORD - how many cycles each Opcode takes, 0 for variable
UseTLB,
UseJumpTable,
RomInMemory,
SyncViaAudio,
AudioSignal,
//Temporay Keys
ApplicationName, //String
LoadingRom, //bool
CPU_Running, //bool
FirstDMA, //bool
CurrentSaveState,//DWORD
ScreenHertz, //DWORD
InstantSaveFile, //String
InFullScreen, //bool
SMM_Cache, //bool - Self mod method (clear code on clearing instruction cache)
SMM_PIDMA, //bool - Self mod method (clear code on PI DMA blocks)
SMM_ValidFunc, //bool - Self mod method (Compare memory contents of function on finding)
SMM_Protect, //bool - Self mod method (Protect Memory from any write to the code pages)
SMM_TLB, //bool - Self mod method (clear code on TLB unmapping)
*/
};
#include "Support.h"

16
Source/Project64/Settings/SettingType/SettingsType-Application.cpp
View File

@ -96,7 +96,7 @@ bool CSettingTypeApplication::Load ( int Index, bool & Value ) const
Value = dwValue != 0;
}
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
if (!bRes && m_DefaultSetting != Default_None)
@ -118,7 +118,7 @@ bool CSettingTypeApplication::Load ( int Index, ULONG & Value ) const
{
bRes = m_SettingsIniFile->GetNumber(SectionName(),m_KeyNameIdex.c_str(),Value,Value);
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
if (!bRes && m_DefaultSetting != Default_None)
{
@ -149,7 +149,7 @@ bool CSettingTypeApplication::Load ( int Index, stdstr & Value ) const
bRes = false;
}
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
if (!bRes)
{
@ -205,7 +205,7 @@ void CSettingTypeApplication::Save ( int Index, bool Value )
{
m_SettingsIniFile->SaveNumber(SectionName(),m_KeyNameIdex.c_str(),Value);
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -215,7 +215,7 @@ void CSettingTypeApplication::Save ( int Index, ULONG Value )
{
m_SettingsIniFile->SaveNumber(SectionName(),m_KeyNameIdex.c_str(),Value);
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -225,7 +225,7 @@ void CSettingTypeApplication::Save ( int Index, const stdstr & Value )
{
m_SettingsIniFile->SaveString(SectionName(),m_KeyNameIdex.c_str(),Value.c_str());
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -235,7 +235,7 @@ void CSettingTypeApplication::Save ( int Index, const char * Value )
{
m_SettingsIniFile->SaveString(SectionName(),m_KeyNameIdex.c_str(),Value);
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -260,6 +260,6 @@ void CSettingTypeApplication::Delete( int Index )
{
m_SettingsIniFile->SaveString(SectionName(),m_KeyNameIdex.c_str(),NULL);
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
}

16
Source/Project64/Settings/SettingType/SettingsType-Cheats.cpp
View File

@ -53,18 +53,18 @@ LPCSTR CSettingTypeCheats::SectionName ( void ) const
void CSettingTypeCheats::UpdateSettings ( void * )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}*/
bool CSettingTypeCheats::Load ( int Index, bool & Value ) const
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
bool CSettingTypeCheats::Load ( int Index, ULONG & Value ) const
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
@ -81,28 +81,28 @@ bool CSettingTypeCheats::Load ( int Index, stdstr & Value ) const
//return the default values
void CSettingTypeCheats::LoadDefault ( int Index, bool & Value ) const
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeCheats::LoadDefault ( int Index, ULONG & Value ) const
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeCheats::LoadDefault ( int Index, stdstr & Value ) const
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
//Update the settings
void CSettingTypeCheats::Save ( int Index, bool Value )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeCheats::Save ( int Index, ULONG Value )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeCheats::Save ( int Index, const stdstr & Value )

12
Source/Project64/Settings/SettingType/SettingsType-RDBYesNo.cpp
View File

@ -44,13 +44,13 @@ bool CSettingTypeRDBYesNo::Load ( int Index, bool & Value ) const
bool CSettingTypeRDBYesNo::Load ( int Index, ULONG & Value ) const
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
bool CSettingTypeRDBYesNo::Load ( int Index, stdstr & Value ) const
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
@ -70,12 +70,12 @@ void CSettingTypeRDBYesNo::LoadDefault ( int Index, bool & Value ) const
void CSettingTypeRDBYesNo::LoadDefault ( int Index, ULONG & Value ) const
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeRDBYesNo::LoadDefault ( int Index, stdstr & Value ) const
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
@ -92,12 +92,12 @@ void CSettingTypeRDBYesNo::Save ( int Index, ULONG Value )
void CSettingTypeRDBYesNo::Save ( int Index, const stdstr & Value )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeRDBYesNo::Save ( int Index, const char * Value )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettingTypeRDBYesNo::Delete( int Index )

70
Source/Project64/Settings/Settings Class.cpp
View File

@ -341,7 +341,7 @@ void CSettings::RegisterSetting ( CSettings * _this, SettingID ID, SettingID Def
case SettingType_ConstValue:
if (DataType != Data_DWORD)
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
return;
}
_this->AddHandler(ID,new CSettingTypeTempNumber(Value));
@ -349,7 +349,7 @@ void CSettings::RegisterSetting ( CSettings * _this, SettingID ID, SettingID Def
case SettingType_ConstString:
if (DataType != Data_String)
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
return;
}
_this->AddHandler(ID,new CSettingTypeTempString(DefaultStr));
@ -375,7 +375,7 @@ void CSettings::RegisterSetting ( CSettings * _this, SettingID ID, SettingID Def
}
break;
default:
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
break;
case SettingType_GameSetting:
@ -400,7 +400,7 @@ void CSettings::RegisterSetting ( CSettings * _this, SettingID ID, SettingID Def
}
break;
default:
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
}
break;
@ -424,11 +424,11 @@ void CSettings::RegisterSetting ( CSettings * _this, SettingID ID, SettingID Def
}
break;
default:
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
break;
default:
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
}
@ -462,7 +462,7 @@ bool CSettings::LoadBool ( SettingID Type, bool & Value )
}
if (FindInfo->second->IndexBasedSetting())
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
} else {
return FindInfo->second->Load(0,Value);
}
@ -489,7 +489,7 @@ bool CSettings::LoadBoolIndex( SettingID Type, int index , bool & Value )
{
return FindInfo->second->Load(index,Value);
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
return false;
}
@ -512,7 +512,7 @@ bool CSettings::LoadDword ( SettingID Type, DWORD & Value)
}
if (FindInfo->second->IndexBasedSetting())
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
} else {
return FindInfo->second->Load(0,Value);
}
@ -539,7 +539,7 @@ bool CSettings::LoadDwordIndex( SettingID Type, int index, DWORD & Value)
{
return FindInfo->second->Load(index,Value);
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
return false;
}
@ -562,7 +562,7 @@ bool CSettings::LoadString ( SettingID Type, stdstr & Value )
}
if (FindInfo->second->IndexBasedSetting())
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
} else {
return FindInfo->second->Load(0,Value);
}
@ -581,7 +581,7 @@ bool CSettings::LoadString ( SettingID Type, char * Buffer, int BufferSize )
bool bRes = false;
if (FindInfo->second->IndexBasedSetting())
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
} else {
stdstr Value;
bRes = FindInfo->second->Load(0,Value);
@ -615,14 +615,14 @@ bool CSettings::LoadStringIndex ( SettingID Type, int index, stdstr & Value )
{
return FindInfo->second->Load(index,Value);
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
return false;
}
bool CSettings::LoadStringIndex ( SettingID Type, int index, char * Buffer, int BufferSize )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
@ -644,7 +644,7 @@ void CSettings::LoadDefaultBool ( SettingID Type, bool & Value )
} else {
if (FindInfo->second->IndexBasedSetting())
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->LoadDefault(0,Value);
}
@ -653,13 +653,13 @@ void CSettings::LoadDefaultBool ( SettingID Type, bool & Value )
bool CSettings::LoadDefaultBoolIndex ( SettingID Type, int index )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
void CSettings::LoadDefaultBoolIndex ( SettingID Type, int index , bool & Value )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
DWORD CSettings::LoadDefaultDword ( SettingID Type )
@ -679,7 +679,7 @@ void CSettings::LoadDefaultDword ( SettingID Type, DWORD & Value)
} else {
if (FindInfo->second->IndexBasedSetting())
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->LoadDefault(0,Value);
}
@ -688,13 +688,13 @@ void CSettings::LoadDefaultDword ( SettingID Type, DWORD & Value)
DWORD CSettings::LoadDefaultDwordIndex ( SettingID Type, int index )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
void CSettings::LoadDefaultDwordIndex ( SettingID Type, int index, DWORD & Value)
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
stdstr CSettings::LoadDefaultString ( SettingID Type )
@ -714,7 +714,7 @@ void CSettings::LoadDefaultString ( SettingID Type, stdstr & Value )
} else {
if (FindInfo->second->IndexBasedSetting())
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->LoadDefault(0,Value);
}
@ -723,23 +723,23 @@ void CSettings::LoadDefaultString ( SettingID Type, stdstr & Value )
void CSettings::LoadDefaultString ( SettingID Type, char * Buffer, int BufferSize )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
stdstr CSettings::LoadDefaultStringIndex ( SettingID Type, int index )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
void CSettings::LoadDefaultStringIndex ( SettingID Type, int index, stdstr & Value )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettings::LoadDefaultStringIndex ( SettingID Type, int index, char * Buffer, int BufferSize )
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
void CSettings::SaveBool ( SettingID Type, bool Value )
@ -753,7 +753,7 @@ void CSettings::SaveBool ( SettingID Type, bool Value )
}
if (FindInfo->second->IndexBasedSetting())
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->Save(0,Value);
}
@ -773,7 +773,7 @@ void CSettings::SaveBoolIndex( SettingID Type, int index, bool Value )
{
FindInfo->second->Save(index,Value);
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
NotifyCallBacks(Type);
}
@ -789,7 +789,7 @@ void CSettings::SaveDword ( SettingID Type, DWORD Value )
}
if (FindInfo->second->IndexBasedSetting())
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->Save(0,Value);
}
@ -809,7 +809,7 @@ void CSettings::SaveDwordIndex ( SettingID Type, int index, DWORD Value )
{
FindInfo->second->Save(index,Value);
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
NotifyCallBacks(Type);
}
@ -825,7 +825,7 @@ void CSettings::SaveString ( SettingID Type, const stdstr & Value )
}
if (FindInfo->second->IndexBasedSetting())
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->Save(0,Value);
}
@ -842,7 +842,7 @@ void CSettings::SaveString ( SettingID Type, const char * Buffer )
}
if (FindInfo->second->IndexBasedSetting())
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->Save(0,Buffer);
}
@ -861,7 +861,7 @@ void CSettings::SaveStringIndex( SettingID Type, int index, const char * Buffer
{
FindInfo->second->Save(index,Buffer);
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
NotifyCallBacks(Type);
}
@ -881,7 +881,7 @@ void CSettings::DeleteSetting( SettingID Type )
}
if (FindInfo->second->IndexBasedSetting())
{
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
} else {
FindInfo->second->Delete(0);
}
@ -900,7 +900,7 @@ void CSettings::DeleteSettingIndex( SettingID Type, int index )
{
FindInfo->second->Delete(index);
} else {
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
NotifyCallBacks(Type);
}
@ -945,7 +945,7 @@ void CSettings::SettingTypeChanged( SettingType Type )
void CSettings::UnknownSetting (SettingID Type)
{
#ifdef _DEBUG
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
#endif
}

1
Source/Project64/User Interface/Settings Config.cpp
View File

@ -200,6 +200,7 @@ void CSettingConfig::ApplySettings( bool UpdateScreen )
::EnableWindow(GetDlgItem(IDAPPLY),false);
::EnableWindow(GetDlgItem(IDC_RESET_PAGE), m_CurrentPage->EnableReset());
}
}
LRESULT CSettingConfig::OnPageListItemChanged(NMHDR* phdr)

14
Source/Project64/User Interface/Settings/Settings Page - Keyboard Shortcuts.cpp
View File

@ -120,13 +120,13 @@ void COptionsShortCutsPage::OnRemoveClicked ( UINT Code, int id, HWND ctl )
HTREEITEM hSelectedItem = m_MenuItems.GetSelectedItem();
if (hSelectedItem == NULL)
{
Notify().DisplayError(GS(MSG_NO_SEL_SHORTCUT));
_Notify->DisplayError(GS(MSG_NO_SEL_SHORTCUT));
return;
}
HTREEITEM hParent = m_MenuItems.GetParentItem(hSelectedItem);
if (hParent == NULL)
{
Notify().DisplayError(GS(MSG_NO_SEL_SHORTCUT));
_Notify->DisplayError(GS(MSG_NO_SEL_SHORTCUT));
return;
}
@ -138,7 +138,7 @@ void COptionsShortCutsPage::OnRemoveClicked ( UINT Code, int id, HWND ctl )
int index = m_CurrentKeys.GetCurSel();
if (index < 0)
{
Notify().DisplayError(GS(MSG_NO_SEL_SHORTCUT));
_Notify->DisplayError(GS(MSG_NO_SEL_SHORTCUT));
return;
}
ShortCut->RemoveItem((CMenuShortCutKey *)m_CurrentKeys.GetItemData(index));
@ -161,7 +161,7 @@ void COptionsShortCutsPage::OnAssignClicked ( UINT Code, int id, HWND ctl )
int index = m_VirtualKeyList.GetCurSel();
if (index < 0)
{
Notify().DisplayError(GS(MSG_NO_SHORTCUT_SEL));
_Notify->DisplayError(GS(MSG_NO_SHORTCUT_SEL));
return;
}
@ -176,13 +176,13 @@ void COptionsShortCutsPage::OnAssignClicked ( UINT Code, int id, HWND ctl )
HTREEITEM hSelectedItem = m_MenuItems.GetSelectedItem();
if (hSelectedItem == NULL)
{
Notify().DisplayError(GS(MSG_NO_MENUITEM_SEL));
_Notify->DisplayError(GS(MSG_NO_MENUITEM_SEL));
return;
}
HTREEITEM hParent = m_MenuItems.GetParentItem(hSelectedItem);
if (hParent == NULL)
{
Notify().DisplayError(GS(MSG_NO_MENUITEM_SEL));
_Notify->DisplayError(GS(MSG_NO_MENUITEM_SEL));
return;
}
@ -191,7 +191,7 @@ void COptionsShortCutsPage::OnAssignClicked ( UINT Code, int id, HWND ctl )
LanguageStringID strid = m_ShortCuts.GetMenuItemName(key,bCtrl,bAlt,bShift,AccessLevel);
if (strid != EMPTY_STRING)
{
Notify().DisplayError(GS(MSG_MENUITEM_ASSIGNED));
_Notify->DisplayError(GS(MSG_MENUITEM_ASSIGNED));
return;
}
ShortCut->AddShortCut(key,bCtrl,bAlt,bShift,AccessLevel,true,false);

2
Source/Project64/User Interface/Settings/Settings Page - Plugin.cpp
View File

@ -244,7 +244,7 @@ void COptionPluginPage::ApplyComboBoxes ( void )
case PLUGIN_TYPE_AUDIO: _Settings->SaveBool(Plugin_AUDIO_Changed,true); break;
case PLUGIN_TYPE_CONTROLLER: _Settings->SaveBool(Plugin_CONT_Changed,true); break;
default:
Notify().BreakPoint(__FILE__,__LINE__);
_Notify->BreakPoint(__FILE__,__LINE__);
}
}
if (ComboBox->IsReset())

2
Source/Project64/stdafx.h
View File

@ -13,9 +13,7 @@
#include <Aclapi.h>
#include "N64 System/C Core/CPU Log.h"
#include "N64 System/C Core/Dma.h"
#include "N64 System/C Core/C Core Interface.h"
#include "N64 System/C Core/Pif.h"
#include "3rd Party/Zip.h"
#include "3rd Party/7zip.h"