791 lines
26 KiB
C++
791 lines
26 KiB
C++
/****************************************************************************
|
|
* *
|
|
* Project64 - A Nintendo 64 emulator. *
|
|
* http://www.pj64-emu.com/ *
|
|
* Copyright (C) 2012 Project64. All rights reserved. *
|
|
* *
|
|
* License: *
|
|
* GNU/GPLv2 http://www.gnu.org/licenses/gpl-2.0.html *
|
|
* *
|
|
****************************************************************************/
|
|
#include "stdafx.h"
|
|
|
|
#include "Debugger UI.h"
|
|
|
|
CDebugMemorySearch::CDebugMemorySearch(CDebuggerUI * 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)");
|
|
ctrl.SetItemData(Index, _32Bit);
|
|
Index = ctrl.AddString("16bits (aligned)");
|
|
ctrl.SetItemData(Index, _16Bit);
|
|
Index = ctrl.AddString("8bits");
|
|
ctrl.SetCurSel(Index);
|
|
ctrl.SetItemData(Index, _8Bit);
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
{
|
|
m_PAddrStart.Attach(GetDlgItem(IDC_PADDR_START));
|
|
m_PAddrStart.SetDisplayType(CEditNumber::DisplayHex);
|
|
m_SearchLen.Attach(GetDlgItem(IDC_ADDR_END));
|
|
m_SearchLen.SetDisplayType(CEditNumber::DisplayHex);
|
|
m_SearchValue.Attach(GetDlgItem(IDC_SEARCH_VALUE));
|
|
m_SearchValue.SetDisplayType(CEditNumber::DisplayDec);
|
|
m_SearchValue.SetValue(0);
|
|
m_MaxSearch.Attach(GetDlgItem(IDC_MAX_SEARCH));
|
|
m_MaxSearch.SetDisplayType(CEditNumber::DisplayDec);
|
|
m_MaxSearch.SetValue(50000);
|
|
m_UnknownSize.Attach(GetDlgItem(IDC_UNKNOWN_ALIGN));
|
|
AddAlignmentOptions(m_UnknownSize);
|
|
m_ValueSize.Attach(GetDlgItem(IDC_VALUE_ALIGN));
|
|
AddAlignmentOptions(m_ValueSize);
|
|
m_SearchResults.Attach(GetDlgItem(IDC_LST_RESULTS));
|
|
m_SearchResults.AddColumn("ID", 0);
|
|
m_SearchResults.AddColumn("PAddr", 1);
|
|
m_SearchResults.AddColumn("Value", 2);
|
|
m_SearchResults.SetColumnWidth(0, 50);
|
|
m_SearchResults.SetColumnWidth(1, 75);
|
|
m_SearchResults.SetColumnWidth(2, 75);
|
|
m_SearchResults.SetExtendedListViewStyle(LVS_EX_FULLROWSELECT);
|
|
m_UnknownOptions.Attach(GetDlgItem(IDC_CMB_UNKNOWN));
|
|
m_HaveResults = false;
|
|
FixUnknownOptions(true);
|
|
|
|
SendMessage(GetDlgItem(IDC_RADIO_VALUE), BM_SETCHECK, BST_CHECKED, 0);
|
|
|
|
BOOL bHandled;
|
|
OnClicked(0, IDC_BTN_RDRAM, NULL, bHandled);
|
|
OnClicked(0, IDC_RADIO_VALUE, NULL, bHandled);
|
|
WindowCreated();
|
|
return TRUE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND hWndCtl, BOOL& /*bHandled*/)
|
|
{
|
|
switch (wID)
|
|
{
|
|
case IDCANCEL:
|
|
EndDialog(0);
|
|
break;
|
|
case IDC_BTN_RDRAM:
|
|
m_PAddrStart.SetValue(0, true, true);
|
|
m_SearchLen.SetValue(g_MMU->RdramSize(), true, true);
|
|
break;
|
|
case IDC_BTN_ROM:
|
|
m_PAddrStart.SetValue(0x10000000, true, true);
|
|
m_SearchLen.SetValue(g_Rom->GetRomSize(), true, true);
|
|
break;
|
|
case IDC_BTN_SPMEM:
|
|
m_PAddrStart.SetValue(0x04000000, true, true);
|
|
m_SearchLen.SetValue(0x2000, true, true);
|
|
break;
|
|
case IDC_SEARCH_HEX:
|
|
{
|
|
bool bChecked = (SendMessage(hWndCtl, BM_GETSTATE, 0, 0) & BST_CHECKED) != 0;
|
|
m_SearchValue.SetDisplayType(bChecked ? CEditNumber::DisplayHex : CEditNumber::DisplayDec);
|
|
}
|
|
break;
|
|
case ID_POPUP_SHOWINMEMORYVIEWER:
|
|
{
|
|
LONG iItem = m_SearchResults.GetNextItem(-1, LVNI_SELECTED);
|
|
if (iItem == -1)
|
|
{
|
|
break;
|
|
}
|
|
|
|
int ItemId = m_SearchResults.GetItemData(iItem);
|
|
SearchResultItem & Result = m_SearchResult[ItemId];
|
|
m_Debugger->Debug_ShowMemoryLocation(Result.PAddr, false);
|
|
}
|
|
break;
|
|
case IDC_RADIO_UNKNOWN:
|
|
EnableUnknownOptions(true);
|
|
EnableValueOptions(false);
|
|
EnableTextOptions(false);
|
|
EnableJalOptions(false);
|
|
break;
|
|
case IDC_RADIO_VALUE:
|
|
EnableUnknownOptions(false);
|
|
EnableValueOptions(true);
|
|
EnableTextOptions(false);
|
|
EnableJalOptions(false);
|
|
break;
|
|
case IDC_RADIO_TEXT:
|
|
EnableUnknownOptions(false);
|
|
EnableValueOptions(false);
|
|
EnableTextOptions(true);
|
|
EnableJalOptions(false);
|
|
break;
|
|
case IDC_RADIO_JAL:
|
|
EnableUnknownOptions(false);
|
|
EnableValueOptions(false);
|
|
EnableTextOptions(false);
|
|
EnableJalOptions(true);
|
|
break;
|
|
case IDC_BTN_SEARCH:
|
|
if (SendMessage(GetDlgItem(IDC_RADIO_UNKNOWN), BM_GETSTATE, 0, 0) == BST_CHECKED)
|
|
{
|
|
g_BaseSystem->ExternalEvent(SysEvent_PauseCPU_SearchMemory);
|
|
SearchForUnknown();
|
|
g_BaseSystem->ExternalEvent(SysEvent_ResumeCPU_SearchMemory);
|
|
break;
|
|
}
|
|
if (SendMessage(GetDlgItem(IDC_RADIO_VALUE), BM_GETSTATE, 0, 0) == BST_CHECKED)
|
|
{
|
|
g_BaseSystem->ExternalEvent(SysEvent_PauseCPU_SearchMemory);
|
|
SearchForValue();
|
|
g_BaseSystem->ExternalEvent(SysEvent_ResumeCPU_SearchMemory);
|
|
break;
|
|
}
|
|
if (SendMessage(GetDlgItem(IDC_RADIO_TEXT), BM_GETSTATE, 0, 0) == BST_CHECKED)
|
|
{
|
|
g_BaseSystem->ExternalEvent(SysEvent_PauseCPU_SearchMemory);
|
|
SearchForText();
|
|
g_BaseSystem->ExternalEvent(SysEvent_ResumeCPU_SearchMemory);
|
|
break;
|
|
}
|
|
case IDC_RESET_BUTTON:
|
|
Reset();
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CDebugMemorySearch::OnResultRClick(LPNMHDR /*lpnmh*/)
|
|
{
|
|
LONG iItem = m_SearchResults.GetNextItem(-1, LVNI_SELECTED);
|
|
if (iItem == -1)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//Load the menu
|
|
HMENU hMenu = LoadMenu(GetModuleHandle(NULL), MAKEINTRESOURCE(IDR_MEM_SEARCH));
|
|
HMENU hPopupMenu = GetSubMenu(hMenu, 0);
|
|
|
|
//Get the current Mouse location
|
|
POINT Mouse;
|
|
GetCursorPos(&Mouse);
|
|
|
|
//Show the menu
|
|
TrackPopupMenu(hPopupMenu, 0, Mouse.x, Mouse.y, 0, m_hWnd, NULL);
|
|
DestroyMenu(hMenu);
|
|
return true;
|
|
}
|
|
|
|
void CDebugMemorySearch::EnableValueOptions(bool Enable)
|
|
{
|
|
if (Enable)
|
|
{
|
|
::SetWindowText(GetDlgItem(IDC_BTN_SEARCH), m_HaveResults ? "Search Results" : "Search");
|
|
}
|
|
::EnableWindow(GetDlgItem(IDC_SEARCH_VALUE), Enable);
|
|
::EnableWindow(GetDlgItem(IDC_SEARCH_HEX), Enable);
|
|
::EnableWindow(GetDlgItem(IDC_VALUE_ALIGN), m_HaveResults ? false : Enable);
|
|
}
|
|
|
|
void CDebugMemorySearch::EnableTextOptions(bool Enable)
|
|
{
|
|
if (Enable)
|
|
{
|
|
::SetWindowText(GetDlgItem(IDC_BTN_SEARCH), m_HaveResults ? "Search Results" : "Search");
|
|
}
|
|
::EnableWindow(GetDlgItem(IDC_SEARCH_TEXT), Enable);
|
|
::EnableWindow(GetDlgItem(IDC_CASE_SENSITIVE), Enable);
|
|
}
|
|
|
|
void CDebugMemorySearch::EnableJalOptions(bool Enable)
|
|
{
|
|
if (Enable)
|
|
{
|
|
::SetWindowText(GetDlgItem(IDC_BTN_SEARCH), m_HaveResults ? "Search Results" : "Search");
|
|
}
|
|
::EnableWindow(GetDlgItem(IDC_JAL_ADDR), Enable);
|
|
}
|
|
|
|
void CDebugMemorySearch::EnableUnknownOptions(bool Enable)
|
|
{
|
|
if (m_UnknownOptions.GetCount() > 1)
|
|
{
|
|
::EnableWindow(GetDlgItem(IDC_UNKNOWN_ALIGN), m_HaveResults ? false : Enable);
|
|
if (Enable)
|
|
{
|
|
::SetWindowText(GetDlgItem(IDC_BTN_SEARCH), m_HaveResults ? "Search Results" : "Search");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
::EnableWindow(GetDlgItem(IDC_UNKNOWN_ALIGN), false);
|
|
if (Enable)
|
|
{
|
|
::SetWindowText(GetDlgItem(IDC_BTN_SEARCH), "Create");
|
|
}
|
|
}
|
|
::EnableWindow(GetDlgItem(IDC_CMB_UNKNOWN), Enable);
|
|
}
|
|
|
|
void CDebugMemorySearch::SearchForValue(void)
|
|
{
|
|
MemorySize Size = (MemorySize)m_ValueSize.GetItemData(m_ValueSize.GetCurSel());
|
|
DWORD Value = m_SearchValue.GetValue();
|
|
DWORD StartAddress = m_PAddrStart.GetValue();
|
|
DWORD Len = m_SearchLen.GetValue();
|
|
DWORD MaxSearch = m_MaxSearch.GetValue();
|
|
|
|
DWORD MoveSize = (Size == _32Bit ? 4 : (Size == _16Bit ? 2 : 1));
|
|
|
|
m_UnknownSize.SetCurSel(m_ValueSize.GetCurSel());
|
|
|
|
LPCTSTR DisplayStr = "0x%08X";
|
|
if (Size == _16Bit)
|
|
{
|
|
DisplayStr = "0x%04X";
|
|
}
|
|
else if (Size == _8Bit)
|
|
{
|
|
DisplayStr = "0x%04X";
|
|
}
|
|
|
|
if (!m_HaveResults)
|
|
{
|
|
m_HaveResults = true;
|
|
|
|
FixUnknownOptions(false);
|
|
m_SearchResults.DeleteAllItems();
|
|
DWORD ItemsAdded = 0;
|
|
|
|
while (SearchForValue(Value, Size, StartAddress, Len))
|
|
{
|
|
SearchResultItem Result;
|
|
Result.PAddr = StartAddress;
|
|
Result.Value = Value;
|
|
|
|
char LocationStr[20];
|
|
sprintf(LocationStr, "%d", ItemsAdded + 1);
|
|
int Index = m_SearchResults.AddItem(ItemsAdded, 0, LocationStr);
|
|
m_SearchResults.SetItemData(Index, m_SearchResult.size());
|
|
m_SearchResult.push_back(Result);
|
|
sprintf(LocationStr, "0x%08X", StartAddress);
|
|
m_SearchResults.SetItemText(Index, 1, LocationStr);
|
|
sprintf(LocationStr, DisplayStr, Value);
|
|
m_SearchResults.SetItemText(Index, 2, LocationStr);
|
|
sprintf(LocationStr, DisplayStr, Value);
|
|
m_SearchResults.SetItemText(Index, 3, LocationStr);
|
|
StartAddress += MoveSize;
|
|
Len -= MoveSize;
|
|
ItemsAdded += 1;
|
|
if (ItemsAdded >= MaxSearch)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
::SetWindowText(GetDlgItem(IDC_BTN_SEARCH), "Search Results");
|
|
::ShowWindow(GetDlgItem(IDC_RESET_BUTTON), SW_SHOW);
|
|
::EnableWindow(GetDlgItem(IDC_VALUE_ALIGN), false);
|
|
}
|
|
else
|
|
{
|
|
int ItemCount = m_SearchResults.GetItemCount();
|
|
for (int i = ItemCount - 1; i >= 0; i--)
|
|
{
|
|
int ItemId = m_SearchResults.GetItemData(i);
|
|
SearchResultItem & Result = m_SearchResult[ItemId];
|
|
|
|
uint32_t 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(__FILEW__, __LINE__);
|
|
}
|
|
|
|
if (Value == NewValue)
|
|
{
|
|
char LocationStr[20];
|
|
sprintf(LocationStr, DisplayStr, NewValue);
|
|
m_SearchResults.SetItemText(i, 2, LocationStr);
|
|
sprintf(LocationStr, DisplayStr, Result.Value);
|
|
m_SearchResults.SetItemText(i, 3, LocationStr);
|
|
Result.Value = NewValue;
|
|
}
|
|
else
|
|
{
|
|
m_SearchResults.DeleteItem(i);
|
|
}
|
|
}
|
|
}
|
|
::SetWindowText(GetDlgItem(IDC_BORDER_RESULTS), stdstr_f("Results (%d)", m_SearchResults.GetItemCount()).c_str());
|
|
}
|
|
|
|
void CDebugMemorySearch::SearchForUnknown()
|
|
{
|
|
SearchMemChangeState Option = (SearchMemChangeState)m_UnknownOptions.GetItemData(m_UnknownOptions.GetCurSel());
|
|
if (Option == SearchChangeState_Reset)
|
|
{
|
|
m_SearchResults.DeleteAllItems();
|
|
SearchSetBaseForChanges();
|
|
FixUnknownOptions(false);
|
|
::ShowWindow(GetDlgItem(IDC_RESET_BUTTON), SW_SHOW);
|
|
::EnableWindow(GetDlgItem(IDC_UNKNOWN_ALIGN), true);
|
|
return;
|
|
}
|
|
MemorySize Size = (MemorySize)m_UnknownSize.GetItemData(m_UnknownSize.GetCurSel());
|
|
m_ValueSize.SetCurSel(m_UnknownSize.GetCurSel());
|
|
LPCTSTR DisplayStr = "0x%08X";
|
|
if (Size == _16Bit)
|
|
{
|
|
DisplayStr = "0x%04X";
|
|
}
|
|
else if (Size == _8Bit)
|
|
{
|
|
DisplayStr = "0x%04X";
|
|
}
|
|
if (!m_HaveResults)
|
|
{
|
|
m_HaveResults = true;
|
|
|
|
::EnableWindow(GetDlgItem(IDC_UNKNOWN_ALIGN), false);
|
|
DWORD StartAddress = m_PAddrStart.GetValue();
|
|
DWORD Len = m_SearchLen.GetValue();
|
|
DWORD MaxSearch = m_MaxSearch.GetValue();
|
|
|
|
DWORD MoveSize = (Size == _32Bit ? 4 : (Size == _16Bit ? 2 : 1));
|
|
|
|
for (int i = 2; i < 10; i++)
|
|
{
|
|
if (!m_SearchResults.DeleteColumn(i))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
m_SearchResults.AddColumn("New Value", 2);
|
|
m_SearchResults.AddColumn("Old Value", 3);
|
|
m_SearchResults.SetColumnWidth(0, 50);
|
|
m_SearchResults.SetColumnWidth(1, 75);
|
|
m_SearchResults.SetColumnWidth(2, 75);
|
|
m_SearchResults.SetColumnWidth(3, 75);
|
|
|
|
m_SearchResults.DeleteAllItems();
|
|
DWORD ItemsAdded = 0, OldValue, NewValue;
|
|
|
|
while (SearchForChanges(Option, Size, StartAddress, Len, OldValue, NewValue))
|
|
{
|
|
SearchResultItem Result;
|
|
Result.PAddr = StartAddress;
|
|
Result.Value = NewValue;
|
|
|
|
//if list size > max, then break
|
|
char LocationStr[20];
|
|
sprintf(LocationStr, "%d", ItemsAdded + 1);
|
|
int Index = m_SearchResults.AddItem(ItemsAdded, 0, LocationStr);
|
|
m_SearchResults.SetItemData(Index, m_SearchResult.size());
|
|
m_SearchResult.push_back(Result);
|
|
sprintf(LocationStr, "0x%08X", StartAddress);
|
|
m_SearchResults.SetItemText(Index, 1, LocationStr);
|
|
sprintf(LocationStr, DisplayStr, NewValue);
|
|
m_SearchResults.SetItemText(Index, 2, LocationStr);
|
|
sprintf(LocationStr, DisplayStr, OldValue);
|
|
m_SearchResults.SetItemText(Index, 3, LocationStr);
|
|
StartAddress += MoveSize;
|
|
Len -= MoveSize;
|
|
ItemsAdded += 1;
|
|
if (ItemsAdded >= MaxSearch)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
::SetWindowText(GetDlgItem(IDC_BTN_SEARCH), "Search Results");
|
|
::ShowWindow(GetDlgItem(IDC_RESET_BUTTON), SW_SHOW);
|
|
::EnableWindow(GetDlgItem(IDC_RADIO_TEXT), false);
|
|
::EnableWindow(GetDlgItem(IDC_RADIO_JAL), false);
|
|
}
|
|
else
|
|
{
|
|
int ItemCount = m_SearchResults.GetItemCount();
|
|
for (int i = ItemCount - 1; i >= 0; i--)
|
|
{
|
|
int ItemId = m_SearchResults.GetItemData(i);
|
|
SearchResultItem & Result = m_SearchResult[ItemId];
|
|
|
|
bool UpdateResult = false;
|
|
uint32_t 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(__FILEW__, __LINE__);
|
|
}
|
|
|
|
switch (Option)
|
|
{
|
|
case SearchChangeState_Changed:
|
|
if (Result.Value != NewValue)
|
|
{
|
|
UpdateResult = true;
|
|
}
|
|
break;
|
|
case SearchChangeState_Unchanged:
|
|
if (Result.Value == NewValue)
|
|
{
|
|
UpdateResult = true;
|
|
}
|
|
break;
|
|
case SearchChangeState_Greater:
|
|
if (NewValue > Result.Value)
|
|
{
|
|
UpdateResult = true;
|
|
}
|
|
break;
|
|
case SearchChangeState_Lessthan:
|
|
if (NewValue < Result.Value)
|
|
{
|
|
UpdateResult = true;
|
|
}
|
|
break;
|
|
default:
|
|
g_Notify->BreakPoint(__FILEW__, __LINE__);
|
|
}
|
|
|
|
if (UpdateResult)
|
|
{
|
|
char LocationStr[20];
|
|
sprintf(LocationStr, DisplayStr, NewValue);
|
|
m_SearchResults.SetItemText(i, 2, LocationStr);
|
|
sprintf(LocationStr, DisplayStr, Result.Value);
|
|
m_SearchResults.SetItemText(i, 3, LocationStr);
|
|
Result.Value = NewValue;
|
|
}
|
|
else
|
|
{
|
|
m_SearchResults.DeleteItem(i);
|
|
}
|
|
}
|
|
}
|
|
::SetWindowText(GetDlgItem(IDC_BORDER_RESULTS), stdstr_f("Results (%d)", m_SearchResults.GetItemCount()).c_str());
|
|
}
|
|
|
|
void CDebugMemorySearch::SearchForText()
|
|
{
|
|
g_Notify->BreakPoint(__FILEW__, __LINE__);
|
|
}
|
|
|
|
void CDebugMemorySearch::Reset(void)
|
|
{
|
|
m_HaveResults = false;
|
|
SendMessage(GetDlgItem(IDC_RADIO_VALUE), BM_SETCHECK, BST_CHECKED, 0);
|
|
EnableUnknownOptions(false);
|
|
EnableValueOptions(true);
|
|
EnableTextOptions(false);
|
|
EnableJalOptions(false);
|
|
::SetWindowText(GetDlgItem(IDC_BTN_SEARCH), "Search");
|
|
::SetWindowText(GetDlgItem(IDC_BORDER_RESULTS), "Results");
|
|
::ShowWindow(GetDlgItem(IDC_RESET_BUTTON), SW_HIDE);
|
|
::EnableWindow(GetDlgItem(IDC_RADIO_UNKNOWN), true);
|
|
::EnableWindow(GetDlgItem(IDC_RADIO_VALUE), true);
|
|
::EnableWindow(GetDlgItem(IDC_RADIO_TEXT), false);
|
|
::EnableWindow(GetDlgItem(IDC_RADIO_JAL), false);
|
|
for (int i = 1; i < 10; i++)
|
|
{
|
|
if (!m_SearchResults.DeleteColumn(i))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
m_SearchResults.AddColumn("Value", 2);
|
|
m_SearchResults.DeleteAllItems();
|
|
m_SearchResults.SetColumnWidth(0, 50);
|
|
m_SearchResults.SetColumnWidth(1, 75);
|
|
m_SearchResults.SetColumnWidth(2, 75);
|
|
m_SearchResults.SetExtendedListViewStyle(LVS_EX_FULLROWSELECT);
|
|
FixUnknownOptions(true);
|
|
}
|
|
|
|
void CDebugMemorySearch::FixUnknownOptions(bool Reset)
|
|
{
|
|
CComboBox & cb = m_UnknownOptions;
|
|
|
|
if (!Reset && cb.GetCount() > 1)
|
|
{
|
|
return;
|
|
}
|
|
cb.ResetContent();
|
|
if (Reset)
|
|
{
|
|
cb.SetItemData(cb.AddString("Create compare base"), SearchChangeState_Reset);
|
|
cb.SetCurSel(0);
|
|
return;
|
|
}
|
|
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");
|
|
}
|
|
|
|
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)
|
|
{
|
|
g_Notify->BreakPoint(__FILEW__, __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(__FILEW__, __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(__FILEW__, __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(__FILEW__, __LINE__);
|
|
}
|
|
}
|
|
return false;
|
|
}
|