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

Add the memory search functionality back in

This commit is contained in:
Nicholas 2015-01-22 16:50:20 +11:00
parent a201d219ea
commit 0bd9a467a1
8 changed files with 500 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

335
Source/Project64/N64 System/Debugger/Debugger - Memory Search.cpp
View File

@ -12,26 +12,29 @@
#include "Debugger UI.h"
CDebugMemorySearch::CDebugMemorySearch(CDebugger * debugger) :
CDebugDialog<CDebugMemorySearch>(debugger)
CDebugDialog<CDebugMemorySearch>(debugger),
m_MemoryState(NULL),
m_MemoryStateSize(0)
{
}
CDebugMemorySearch::~CDebugMemorySearch()
{
if (m_MemoryState)
{
delete m_MemoryState;
}
}
void CDebugMemorySearch::AddAlignmentOptions (CComboBox & ctrl)
{
/*int Index =*/ ctrl.AddString("32 bits (aligned)");
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
int Index = ctrl.AddString("32 bits (aligned)");
ctrl.SetItemData(Index,_32Bit);
Index = ctrl.AddString("16bits (aligned)");
ctrl.SetItemData(Index,_16Bit);
Index = ctrl.AddString("8bits");
ctrl.SetCurSel(Index);
ctrl.SetItemData(Index,_8Bit);
#endif
}
LRESULT CDebugMemorySearch::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
@ -136,23 +139,23 @@ LRESULT CDebugMemorySearch::OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND hWndC
case IDC_BTN_SEARCH:
if (SendMessage(GetDlgItem(IDC_RADIO_UNKNOWN),BM_GETSTATE, 0,0) == BST_CHECKED)
{
m_System->ExternalEvent(SysEvent_PauseCPU_SearchMemory);
g_BaseSystem->ExternalEvent(SysEvent_PauseCPU_SearchMemory);
SearchForUnknown();
m_System->ExternalEvent(SysEvent_ResumeCPU_SearchMemory);
g_BaseSystem->ExternalEvent(SysEvent_ResumeCPU_SearchMemory);
break;
}
if (SendMessage(GetDlgItem(IDC_RADIO_VALUE),BM_GETSTATE, 0,0) == BST_CHECKED)
{
m_System->ExternalEvent(SysEvent_PauseCPU_SearchMemory);
g_BaseSystem->ExternalEvent(SysEvent_PauseCPU_SearchMemory);
SearchForValue();
m_System->ExternalEvent(SysEvent_ResumeCPU_SearchMemory);
g_BaseSystem->ExternalEvent(SysEvent_ResumeCPU_SearchMemory);
break;
}
if (SendMessage(GetDlgItem(IDC_RADIO_TEXT),BM_GETSTATE, 0,0) == BST_CHECKED)
{
m_System->ExternalEvent(SysEvent_PauseCPU_SearchMemory);
g_BaseSystem->ExternalEvent(SysEvent_PauseCPU_SearchMemory);
SearchForText();
m_System->ExternalEvent(SysEvent_ResumeCPU_SearchMemory);
g_BaseSystem->ExternalEvent(SysEvent_ResumeCPU_SearchMemory);
break;
}
case IDC_RESET_BUTTON:
@ -235,8 +238,6 @@ void CDebugMemorySearch::EnableUnknownOptions( bool Enable )
void CDebugMemorySearch::SearchForValue( void )
{
g_Notify->BreakPoint(__FILE__,__LINE__);
#ifdef tofix
MemorySize Size = (MemorySize)m_ValueSize.GetItemData(m_ValueSize.GetCurSel());
DWORD Value = m_SearchValue.GetValue();
DWORD StartAddress = m_PAddrStart.GetValue();
@ -259,7 +260,7 @@ void CDebugMemorySearch::SearchForValue( void )
m_SearchResults.DeleteAllItems();
DWORD ItemsAdded = 0;
/*while (g_MMU->SearchForValue(Value,Size,StartAddress,Len))
while (SearchForValue(Value,Size,StartAddress,Len))
{
SearchResultItem Result;
Result.PAddr = StartAddress;
@ -283,7 +284,7 @@ void CDebugMemorySearch::SearchForValue( void )
{
break;
}
}*/
}
::SetWindowText(GetDlgItem(IDC_BTN_SEARCH),"Search Results");
::ShowWindow(GetDlgItem(IDC_RESET_BUTTON),SW_SHOW);
::EnableWindow(GetDlgItem(IDC_VALUE_ALIGN),false);
@ -294,8 +295,30 @@ void CDebugMemorySearch::SearchForValue( void )
int ItemId = m_SearchResults.GetItemData(i);
SearchResultItem & Result = m_SearchResult[ItemId];
DWORD NewValue;
/*g_MMU->LoadPhysical32(Result.PAddr,NewValue,Size,false);
DWORD NewValue = 0;
BOOL valid = false;
switch (Size) {
case _8Bit:
{
BYTE mem = 0;
valid = g_MMU->LB_PAddr(Result.PAddr, mem);
NewValue = mem;
}
break;
case _16Bit:
{
WORD mem = 0;
valid = g_MMU->LH_PAddr(Result.PAddr, mem);
NewValue = mem;
}
break;
case _32Bit:
valid = g_MMU->LW_PAddr(Result.PAddr, NewValue);
break;
default:
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (Value == NewValue)
{
@ -307,20 +330,19 @@ void CDebugMemorySearch::SearchForValue( void )
Result.Value = NewValue;
} else {
m_SearchResults.DeleteItem(i);
}*/
}
}
}
::SetWindowText(GetDlgItem(IDC_BORDER_RESULTS),stdstr_f("Results (%d)",m_SearchResults.GetItemCount()).c_str());
#endif
}
void CDebugMemorySearch::SearchForUnknown()
{
/*CMipsMemory::SearchMemChangeState Option = (CMipsMemory::SearchMemChangeState)m_UnknownOptions.GetItemData(m_UnknownOptions.GetCurSel());
if (Option == CMipsMemory::SearchChangeState_Reset)
SearchMemChangeState Option = (SearchMemChangeState)m_UnknownOptions.GetItemData(m_UnknownOptions.GetCurSel());
if (Option == SearchChangeState_Reset)
{
m_SearchResults.DeleteAllItems();
//g_MMU->SearchSetBaseForChanges();
SearchSetBaseForChanges();
FixUnknownOptions(false);
::ShowWindow(GetDlgItem(IDC_RESET_BUTTON),SW_SHOW);
::EnableWindow(GetDlgItem(IDC_UNKNOWN_ALIGN),true );
@ -359,7 +381,7 @@ void CDebugMemorySearch::SearchForUnknown()
m_SearchResults.DeleteAllItems();
DWORD ItemsAdded = 0, OldValue, NewValue;
while (g_MMU->SearchForChanges(Option,Size,StartAddress,Len,OldValue,NewValue))
while (SearchForChanges(Option,Size,StartAddress,Len,OldValue,NewValue))
{
SearchResultItem Result;
Result.PAddr = StartAddress;
@ -397,36 +419,59 @@ void CDebugMemorySearch::SearchForUnknown()
SearchResultItem & Result = m_SearchResult[ItemId];
bool UpdateResult = false;
DWORD NewValue;
g_MMU->LoadPhysical32(Result.PAddr,NewValue,Size,false);
DWORD NewValue = 0;
BOOL valid = false;
switch (Size) {
case _8Bit:
{
BYTE mem = 0;
valid = g_MMU->LB_PAddr(Result.PAddr, mem);
NewValue = mem;
}
break;
case _16Bit:
{
WORD mem = 0;
valid = g_MMU->LH_PAddr(Result.PAddr, mem);
NewValue = mem;
}
break;
case _32Bit:
valid = g_MMU->LW_PAddr(Result.PAddr, NewValue);
break;
default:
g_Notify->BreakPoint(__FILE__,__LINE__);
}
switch (Option)
{
case CMipsMemory::SearchChangeState_Changed:
case SearchChangeState_Changed:
if (Result.Value != NewValue)
{
UpdateResult = true;
}
break;
case CMipsMemory::SearchChangeState_Unchanged:
case SearchChangeState_Unchanged:
if (Result.Value == NewValue)
{
UpdateResult = true;
}
break;
case CMipsMemory::SearchChangeState_Greater:
case SearchChangeState_Greater:
if (NewValue > Result.Value)
{
UpdateResult = true;
}
break;
case CMipsMemory::SearchChangeState_Lessthan:
case SearchChangeState_Lessthan:
if (NewValue < Result.Value)
{
UpdateResult = true;
}
break;
default:
Notify().BreakPoint(__FILE__,__LINE__);
g_Notify->BreakPoint(__FILE__,__LINE__);
}
if (UpdateResult)
@ -443,12 +488,11 @@ void CDebugMemorySearch::SearchForUnknown()
}
}
::SetWindowText(GetDlgItem(IDC_BORDER_RESULTS),stdstr_f("Results (%d)",m_SearchResults.GetItemCount()).c_str());
*/
}
void CDebugMemorySearch::SearchForText()
{
//
g_Notify->BreakPoint(__FILE__,__LINE__);
}
void CDebugMemorySearch::Reset ( void )
@ -482,9 +526,9 @@ void CDebugMemorySearch::Reset ( void )
FixUnknownOptions(true);
}
void CDebugMemorySearch::FixUnknownOptions ( bool /*Reset*/ )
void CDebugMemorySearch::FixUnknownOptions ( bool Reset )
{
/* CComboBox & cb = m_UnknownOptions ;
CComboBox & cb = m_UnknownOptions ;
if (!Reset && cb.GetCount() > 1)
{
@ -493,15 +537,224 @@ void CDebugMemorySearch::FixUnknownOptions ( bool /*Reset*/ )
cb.ResetContent();
if (Reset)
{
cb.SetItemData(cb.AddString("Create compare base"),CMipsMemory::SearchChangeState_Reset);
cb.SetItemData(cb.AddString("Create compare base"),SearchChangeState_Reset);
cb.SetCurSel(0);
return;
}
cb.SetItemData(cb.AddString("memory changed"),CMipsMemory::SearchChangeState_Changed);
cb.SetItemData(cb.AddString("memory unchanged"),CMipsMemory::SearchChangeState_Unchanged);
cb.SetItemData(cb.AddString("Value has increased"),CMipsMemory::SearchChangeState_Greater);
cb.SetItemData(cb.AddString("Value has descreased"),CMipsMemory::SearchChangeState_Lessthan);
cb.SetItemData(cb.AddString("memory changed"),SearchChangeState_Changed);
cb.SetItemData(cb.AddString("memory unchanged"),SearchChangeState_Unchanged);
cb.SetItemData(cb.AddString("Value has increased"),SearchChangeState_Greater);
cb.SetItemData(cb.AddString("Value has descreased"),SearchChangeState_Lessthan);
cb.SetCurSel(1);
::SetWindowText(GetDlgItem(IDC_BTN_SEARCH),"Search");*/
::SetWindowText(GetDlgItem(IDC_BTN_SEARCH),"Search");
}
bool CDebugMemorySearch::SearchSetBaseForChanges ( void )
{
if (m_MemoryState != NULL)
{
delete [] m_MemoryState;
}
m_MemoryStateSize = g_MMU->RdramSize();
m_MemoryState = new BYTE[m_MemoryStateSize];
memcpy(m_MemoryState,g_MMU->Rdram(),m_MemoryStateSize);
return true;
}
bool CDebugMemorySearch::SearchForChanges(SearchMemChangeState SearchType, MemorySize Size,
DWORD &StartAddress, DWORD &Len,
DWORD &OldValue, DWORD &NewValue)
{
if (g_MMU == NULL)
{
return false;
}
if (SearchType == SearchChangeState_Reset)
{
Notify().BreakPoint(__FILE__,__LINE__);
}
if (Size == _32Bit) { StartAddress = ((StartAddress + 3) & ~3); }
if (Size == _16Bit) { StartAddress = ((StartAddress + 1) & ~1); }
//search memory
if (StartAddress < g_MMU->RdramSize())
{
DWORD EndMemSearchAddr = StartAddress + Len;
if (EndMemSearchAddr > g_MMU->RdramSize())
{
EndMemSearchAddr = g_MMU->RdramSize();
}
DWORD pos;
switch (Size)
{
case _32Bit:
for (pos = StartAddress; pos < EndMemSearchAddr; pos += 4)
{
OldValue = *(DWORD *)(m_MemoryState + pos);
NewValue = *(DWORD *)(g_MMU->Rdram() + pos);
if ((SearchType == SearchChangeState_Changed && NewValue != OldValue) ||
(SearchType == SearchChangeState_Unchanged && NewValue == OldValue) ||
(SearchType == SearchChangeState_Greater && NewValue > OldValue) ||
(SearchType == SearchChangeState_Lessthan && NewValue < OldValue))
{
*(DWORD *)(m_MemoryState + pos) = NewValue;
Len -= pos - StartAddress;
StartAddress = pos;
return true;
}
}
break;
case _16Bit:
for (pos = StartAddress; pos < EndMemSearchAddr; pos += 2)
{
OldValue = *(WORD *)(m_MemoryState + (pos ^ 2));
NewValue = *(WORD *)(g_MMU->Rdram() + (pos ^ 2));
if ((SearchType == SearchChangeState_Changed && NewValue != OldValue) ||
(SearchType == SearchChangeState_Unchanged && NewValue == OldValue) ||
(SearchType == SearchChangeState_Greater && NewValue > OldValue) ||
(SearchType == SearchChangeState_Lessthan && NewValue < OldValue))
{
Len -= pos - StartAddress;
StartAddress = pos;
return true;
}
}
break;
case _8Bit:
for (pos = StartAddress; pos < EndMemSearchAddr; pos ++)
{
OldValue = *(BYTE *)(m_MemoryState + (pos ^ 3));
NewValue = *(BYTE *)(g_MMU->Rdram() + (pos ^ 3));
if ((SearchType == SearchChangeState_Changed && NewValue != OldValue) ||
(SearchType == SearchChangeState_Unchanged && NewValue == OldValue) ||
(SearchType == SearchChangeState_Greater && NewValue > OldValue) ||
(SearchType == SearchChangeState_Lessthan && NewValue < OldValue))
{
Len -= pos - StartAddress;
StartAddress = pos;
return true;
}
}
break;
default:
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
return false;
}
bool CDebugMemorySearch::SearchForValue (DWORD Value, MemorySize Size, DWORD &StartAddress, DWORD &Len )
{
if (g_MMU == NULL || g_Rom == NULL)
{
return false;
}
if (Size == _32Bit) { StartAddress = ((StartAddress + 3) & ~3); }
if (Size == _16Bit) { StartAddress = ((StartAddress + 1) & ~1); }
//search memory
if (StartAddress < g_MMU->RdramSize())
{
DWORD EndMemSearchAddr = StartAddress + Len;
if (EndMemSearchAddr > g_MMU->RdramSize())
{
EndMemSearchAddr = g_MMU->RdramSize();
}
DWORD pos;
BYTE * RDRAM = g_MMU->Rdram();
switch (Size)
{
case _32Bit:
for (pos = StartAddress; pos < EndMemSearchAddr; pos += 4)
{
if (*(DWORD *)(RDRAM + pos) == Value)
{
Len -= pos - StartAddress;
StartAddress = pos;
return true;
}
}
break;
case _16Bit:
for (pos = StartAddress; pos < EndMemSearchAddr; pos += 2)
{
if (*(WORD *)(RDRAM + (pos ^ 2)) == (WORD)Value)
{
Len -= pos - StartAddress;
StartAddress = pos;
return true;
}
}
break;
case _8Bit:
for (pos = StartAddress; pos < EndMemSearchAddr; pos ++)
{
if (*(BYTE *)(RDRAM + (pos ^ 3)) == (BYTE)Value)
{
Len -= pos - StartAddress;
StartAddress = pos;
return true;
}
}
break;
default:
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
if (StartAddress >= 0x10000000)
{
DWORD EndMemSearchAddr = StartAddress + Len - 0x10000000;
if (EndMemSearchAddr > g_Rom->GetRomSize())
{
EndMemSearchAddr = g_Rom->GetRomSize();
}
StartAddress -= 0x10000000;
DWORD pos;
BYTE * ROM = g_Rom->GetRomAddress();
switch (Size)
{
case _32Bit:
for (pos = StartAddress; pos < EndMemSearchAddr; pos += 4)
{
if (*(DWORD *)(ROM + pos) == Value)
{
Len -= pos - StartAddress;
StartAddress = pos + 0x10000000;
return true;
}
}
break;
case _16Bit:
for (pos = StartAddress; pos < EndMemSearchAddr; pos += 2)
{
if (*(WORD *)(ROM + (pos ^ 2)) == (WORD)Value)
{
Len -= pos - StartAddress;
StartAddress = pos + 0x10000000;
return true;
}
}
break;
case _8Bit:
for (pos = StartAddress; pos < EndMemSearchAddr; pos ++)
{
if (*(BYTE *)(ROM + (pos ^ 3)) == (BYTE)Value)
{
Len -= pos - StartAddress;
StartAddress = pos + 0x10000000;
return true;
}
}
break;
default:
g_Notify->BreakPoint(__FILE__,__LINE__);
}
}
return false;
}

25
Source/Project64/N64 System/Debugger/Debugger - Memory Search.h
View File

@ -24,6 +24,23 @@ private:
CDebugMemorySearch(const CDebugMemorySearch&); // Disable copy constructor
CDebugMemorySearch& operator=(const CDebugMemorySearch&); // Disable assignment
enum MemorySize
{
_8Bit,
_16Bit,
_32Bit,
};
//Searching for value
enum SearchMemChangeState
{
SearchChangeState_Reset,
SearchChangeState_Changed,
SearchChangeState_Unchanged,
SearchChangeState_Greater,
SearchChangeState_Lessthan,
};
typedef struct {
DWORD PAddr;
DWORD Value;
@ -52,11 +69,17 @@ private:
CListViewCtrl m_SearchResults;
SearchResult m_SearchResult;
bool m_HaveResults;
CN64System * m_System;
//Searching memory
BYTE * m_MemoryState;
DWORD m_MemoryStateSize;
void FixUnknownOptions ( bool Reset );
void SearchForUnknown ( void );
void SearchForValue ( void );
void SearchForText ( void );
void Reset ( void );
bool SearchSetBaseForChanges ( void );
bool SearchForChanges ( SearchMemChangeState SearchType, MemorySize Size, DWORD &StartAddress, DWORD &Len, DWORD &OldValue, DWORD &NewValue );
bool SearchForValue ( DWORD Value, MemorySize Size, DWORD &StartAddress, DWORD &Len );
};

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

@ -83,6 +83,27 @@ LRESULT CDebugMemoryView::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM
m_MemoryList->AddColumn( _T( "Memory Ascii" ), 140 );
::SetWindowLongPtr(m_MemoryList->m_hWnd, GWL_EXSTYLE, WS_EX_CLIENTEDGE);
RefreshMemory(false);
int height = m_MemoryList->GetTotalHeight();
RECT MemoryListRect = {0};
::GetClientRect(GetDlgItem( IDC_MEM_DETAILS ), &MemoryListRect);
if (height > MemoryListRect.bottom)
{
RECT MemoryListWindow = {0};
GetWindowRect(&MemoryListWindow);
SetWindowPos(NULL,0,0,MemoryListWindow.right - MemoryListWindow.left,(MemoryListWindow.bottom - MemoryListWindow.top) + (height - MemoryListRect.bottom), SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOZORDER);
RECT DlgItemRect = {0};
::GetWindowRect(GetDlgItem( IDC_BORDER ), &DlgItemRect);
::SetWindowPos(GetDlgItem( IDC_BORDER ), NULL,0,0,DlgItemRect.right - DlgItemRect.left,(DlgItemRect.bottom - DlgItemRect.top) + (height - MemoryListRect.bottom), SWP_NOMOVE);
::GetWindowRect(GetDlgItem( IDC_MEM_DETAILS ), &DlgItemRect);
::SetWindowPos(GetDlgItem( IDC_MEM_DETAILS ), NULL,0,0,DlgItemRect.right - DlgItemRect.left,(DlgItemRect.bottom - DlgItemRect.top) + (height - MemoryListRect.bottom), SWP_NOMOVE);
::GetWindowRect(GetDlgItem( IDC_SCRL_BAR ), &DlgItemRect);
::SetWindowPos(GetDlgItem( IDC_SCRL_BAR ), NULL,0,0,DlgItemRect.right - DlgItemRect.left,(DlgItemRect.bottom - DlgItemRect.top) + (height - MemoryListRect.bottom), SWP_NOMOVE);
}
WindowCreated();
return TRUE;
}
@ -186,10 +207,10 @@ LRESULT CDebugMemoryView::OnMemoryModified ( LPNMHDR lpNMHDR )
WriteTraceF(TraceError,__FUNCTION__ ": failed to store at %X",m_DataStartLoc + Pos);
}
} else {
/*if (!g_MMU->SD_VAddr(m_DataStartLoc+ Pos,Value,_8Bit))
if (!g_MMU->SB_PAddr(m_DataStartLoc + Pos,(BYTE)Value))
{
WriteTraceF(TraceError,__FUNCTION__ ": failed to store at %X",m_DataStartLoc + Pos);
}*/
}
}
Insert_MemoryLineDump(LineNumber);
@ -373,10 +394,10 @@ void CDebugMemoryView::RefreshMemory ( bool ResetCompare )
ValidData = false;
}
} else {
/*if (!g_MMU->LoadPhysical32(m_DataStartLoc & ~3, word.UW, _32Bit,false))
if (!g_MMU->LW_PAddr(m_DataStartLoc & ~3, word.UW))
{
ValidData = false;
}*/
}
}
int Offset = (m_DataStartLoc & 3);
@ -408,10 +429,10 @@ void CDebugMemoryView::RefreshMemory ( bool ResetCompare )
ValidData = false;
}
} else {
/*if (!g_MMU->LoadPhysical32(Pos, word.UW, _32Bit,false))
if (!g_MMU->LW_PAddr(Pos, word.UW))
{
ValidData = false;
}*/
}
}
for (int i = 0; i < 4; i++)

10
Source/Project64/N64 System/Mips/Memory Class.h
View File

@ -30,11 +30,21 @@ public:
virtual BOOL LW_VAddr ( DWORD VAddr, DWORD & Value ) = 0;
virtual BOOL LD_VAddr ( DWORD VAddr, QWORD & Value ) = 0;
virtual BOOL LB_PAddr ( DWORD PAddr, BYTE & Value ) = 0;
virtual BOOL LH_PAddr ( DWORD PAddr, WORD & Value ) = 0;
virtual BOOL LW_PAddr ( DWORD PAddr, DWORD & Value ) = 0;
virtual BOOL LD_PAddr ( DWORD PAddr, QWORD & Value ) = 0;
virtual BOOL SB_VAddr ( DWORD VAddr, BYTE Value ) = 0;
virtual BOOL SH_VAddr ( DWORD VAddr, WORD Value ) = 0;
virtual BOOL SW_VAddr ( DWORD VAddr, DWORD Value ) = 0;
virtual BOOL SD_VAddr ( DWORD VAddr, QWORD Value ) = 0;
virtual BOOL SB_PAddr ( DWORD PAddr, BYTE Value ) = 0;
virtual BOOL SH_PAddr ( DWORD PAddr, WORD Value ) = 0;
virtual BOOL SW_PAddr ( DWORD PAddr, DWORD Value ) = 0;
virtual BOOL SD_PAddr ( DWORD PAddr, QWORD Value ) = 0;
virtual bool ValidVaddr ( DWORD VAddr ) const = 0;
virtual int MemoryFilter ( DWORD dwExptCode, void * lpExceptionPointer ) = 0;

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

@ -260,8 +260,7 @@ BOOL CMipsMemoryVM::LW_VAddr ( DWORD VAddr, DWORD & Value )
// Command.Hex = OrigMem[(Command.Hex & 0xFFFF)].OriginalValue;
// }
// }
return TRUE;
return false;
return true;
}
BOOL CMipsMemoryVM::LD_VAddr ( DWORD VAddr, QWORD & Value )
@ -272,6 +271,67 @@ BOOL CMipsMemoryVM::LD_VAddr ( DWORD VAddr, QWORD & Value )
return TRUE;
}
BOOL CMipsMemoryVM::LB_PAddr ( DWORD PAddr, BYTE & Value )
{
if (PAddr < RdramSize())
{
Value = *(BYTE *)(m_RDRAM + (PAddr ^ 3));
return true;
}
if (PAddr > 0x18000000)
{
return false;
}
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
BOOL CMipsMemoryVM::LH_PAddr ( DWORD PAddr, WORD & Value )
{
if (PAddr < RdramSize())
{
Value = *(WORD *)(m_RDRAM + (PAddr ^ 2));
return true;
}
if (PAddr > 0x18000000)
{
return false;
}
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
BOOL CMipsMemoryVM::LW_PAddr ( DWORD PAddr, DWORD & Value )
{
if (PAddr < RdramSize())
{
Value = *(DWORD *)(m_RDRAM + PAddr);
return true;
}
if (PAddr > 0x18000000)
{
return false;
}
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
BOOL CMipsMemoryVM::LD_PAddr ( DWORD PAddr, QWORD & Value )
{
if (PAddr < RdramSize())
{
*((DWORD *)(&Value) + 1) = *(DWORD *)(m_RDRAM + PAddr);
*((DWORD *)(&Value)) = *(DWORD *)(m_RDRAM + PAddr + 4);
return true;
}
if (PAddr > 0x18000000)
{
return false;
}
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
BOOL CMipsMemoryVM::SB_VAddr ( DWORD VAddr, BYTE Value )
{
if (m_TLB_WriteMap[VAddr >> 12] == 0) { return FALSE; }
@ -311,6 +371,68 @@ BOOL CMipsMemoryVM::SD_VAddr ( DWORD VAddr, QWORD Value )
return TRUE;
}
BOOL CMipsMemoryVM::SB_PAddr ( DWORD PAddr, BYTE Value )
{
if (PAddr < RdramSize())
{
*(BYTE *)(m_RDRAM + (PAddr ^ 3)) = Value;
return true;
}
if (PAddr > 0x18000000)
{
return false;
}
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
BOOL CMipsMemoryVM::SH_PAddr ( DWORD PAddr, WORD Value )
{
if (PAddr < RdramSize())
{
*(WORD *)(m_RDRAM + (PAddr ^ 2)) = Value;
return true;
}
if (PAddr > 0x18000000)
{
return false;
}
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
BOOL CMipsMemoryVM::SW_PAddr ( DWORD PAddr, DWORD Value )
{
if (PAddr < RdramSize())
{
*(DWORD *)(m_RDRAM + PAddr) = Value;
return true;
}
if (PAddr > 0x18000000)
{
return false;
}
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
BOOL CMipsMemoryVM::SD_PAddr ( DWORD PAddr, QWORD Value )
{
if (PAddr < RdramSize())
{
*(DWORD *)(m_RDRAM + PAddr) = *((DWORD *)(&Value) + 1);
*(DWORD *)(m_RDRAM + PAddr + 4) = *((DWORD *)(&Value));
return true;
}
if (PAddr > 0x18000000)
{
return false;
}
g_Notify->BreakPoint(__FILE__,__LINE__);
return false;
}
bool CMipsMemoryVM::ValidVaddr ( DWORD VAddr ) const
{
return m_TLB_ReadMap[VAddr >> 12] != 0;

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

@ -41,11 +41,21 @@ public:
BOOL LW_VAddr ( DWORD VAddr, DWORD & Value );
BOOL LD_VAddr ( DWORD VAddr, QWORD & Value );
BOOL LB_PAddr ( DWORD PAddr, BYTE & Value );
BOOL LH_PAddr ( DWORD PAddr, WORD & Value );
BOOL LW_PAddr ( DWORD PAddr, DWORD & Value );
BOOL LD_PAddr ( DWORD PAddr, QWORD & Value );
BOOL SB_VAddr ( DWORD VAddr, BYTE Value );
BOOL SH_VAddr ( DWORD VAddr, WORD Value );
BOOL SW_VAddr ( DWORD VAddr, DWORD Value );
BOOL SD_VAddr ( DWORD VAddr, QWORD Value );
BOOL SB_PAddr ( DWORD PAddr, BYTE Value );
BOOL SH_PAddr ( DWORD PAddr, WORD Value );
BOOL SW_PAddr ( DWORD PAddr, DWORD Value );
BOOL SD_PAddr ( DWORD PAddr, QWORD Value );
int MemoryFilter ( DWORD dwExptCode, void * lpExceptionPointer );
//Protect the Memory from being written to

2
Source/Project64/User Interface/UI Resources.rc
View File

@ -501,7 +501,7 @@ FONT 8, "MS Sans Serif", 0, 0, 0x1
BEGIN
EDITTEXT IDC_ADDR_EDIT,38,13,66,12
LTEXT "Address:",IDC_STATIC,7,14,29,11
GROUPBOX "",IDC_STATIC,2,3,440,187,0,WS_EX_DLGMODALFRAME
GROUPBOX "",IDC_BORDER,2,3,440,187,0,WS_EX_DLGMODALFRAME
CONTROL "Is VAddr?",IDC_CHK_VADDR,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,108,15,46,8
PUSHBUTTON "Dump",IDC_DUMP_MEM,264,12,54,13
PUSHBUTTON "Search",IDC_SEARCH_MEM,322,12,54,13

3
Source/Project64/User Interface/resource.h
View File

@ -240,6 +240,7 @@
#define IDC_AUDIO_NAME 1099
#define IDC_ROM_REGCACHE 1099
#define IDC_COUNTPERBYTE_TEXT 1099
#define IDC_BORDER 1099
#define IDC_CONT_NAME 1100
#define IDC_COUNTPERBYTE 1100
#define IDC_DIR_FRAME1 1101
@ -349,7 +350,7 @@
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 150
#define _APS_NEXT_COMMAND_VALUE 40008
#define _APS_NEXT_CONTROL_VALUE 1099
#define _APS_NEXT_CONTROL_VALUE 1100
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif