919 lines
29 KiB
C++
919 lines
29 KiB
C++
#include "stdafx.h"
|
|
#include "Debugger.h"
|
|
#include "DebugTypes.h"
|
|
#include "Console.h"
|
|
#include "Cpu.h"
|
|
#include "Ppu.h"
|
|
#include "Spc.h"
|
|
#include "Sa1.h"
|
|
#include "Gsu.h"
|
|
#include "Cx4.h"
|
|
#include "NecDsp.h"
|
|
#include "Gameboy.h"
|
|
#include "CpuDebugger.h"
|
|
#include "SpcDebugger.h"
|
|
#include "GsuDebugger.h"
|
|
#include "NecDspDebugger.h"
|
|
#include "Cx4Debugger.h"
|
|
#include "GbDebugger.h"
|
|
#include "BaseCartridge.h"
|
|
#include "MemoryManager.h"
|
|
#include "EmuSettings.h"
|
|
#include "SoundMixer.h"
|
|
#include "MemoryMappings.h"
|
|
#include "NotificationManager.h"
|
|
#include "CpuTypes.h"
|
|
#include "DisassemblyInfo.h"
|
|
#include "TraceLogger.h"
|
|
#include "MemoryDumper.h"
|
|
#include "MemoryAccessCounter.h"
|
|
#include "CodeDataLogger.h"
|
|
#include "Disassembler.h"
|
|
#include "BreakpointManager.h"
|
|
#include "PpuTools.h"
|
|
#include "EventManager.h"
|
|
#include "GbEventManager.h"
|
|
#include "EventType.h"
|
|
#include "DebugBreakHelper.h"
|
|
#include "LabelManager.h"
|
|
#include "ScriptManager.h"
|
|
#include "CallstackManager.h"
|
|
#include "ExpressionEvaluator.h"
|
|
#include "InternalRegisters.h"
|
|
#include "AluMulDiv.h"
|
|
#include "Assembler.h"
|
|
#include "Gameboy.h"
|
|
#include "GbPpu.h"
|
|
#include "GbAssembler.h"
|
|
#include "GameboyHeader.h"
|
|
#include "../Utilities/HexUtilities.h"
|
|
#include "../Utilities/FolderUtilities.h"
|
|
#include "../Utilities/IpsPatcher.h"
|
|
|
|
Debugger::Debugger(shared_ptr<Console> console)
|
|
{
|
|
_console = console;
|
|
_cpu = console->GetCpu();
|
|
_ppu = console->GetPpu();
|
|
_spc = console->GetSpc();
|
|
_cart = console->GetCartridge();
|
|
_settings = console->GetSettings();
|
|
_memoryManager = console->GetMemoryManager();
|
|
_dmaController = console->GetDmaController();
|
|
_internalRegs = console->GetInternalRegisters();
|
|
_gameboy = _cart->GetGameboy();
|
|
|
|
_labelManager.reset(new LabelManager(this));
|
|
_watchExpEval[(int)CpuType::Cpu].reset(new ExpressionEvaluator(this, CpuType::Cpu));
|
|
_watchExpEval[(int)CpuType::Spc].reset(new ExpressionEvaluator(this, CpuType::Spc));
|
|
_watchExpEval[(int)CpuType::Sa1].reset(new ExpressionEvaluator(this, CpuType::Sa1));
|
|
_watchExpEval[(int)CpuType::Gsu].reset(new ExpressionEvaluator(this, CpuType::Gsu));
|
|
_watchExpEval[(int)CpuType::NecDsp].reset(new ExpressionEvaluator(this, CpuType::NecDsp));
|
|
_watchExpEval[(int)CpuType::Cx4].reset(new ExpressionEvaluator(this, CpuType::Cx4));
|
|
_watchExpEval[(int)CpuType::Gameboy].reset(new ExpressionEvaluator(this, CpuType::Gameboy));
|
|
|
|
_codeDataLogger.reset(new CodeDataLogger(_cart->DebugGetPrgRomSize(), CpuType::Cpu));
|
|
_memoryDumper.reset(new MemoryDumper(this));
|
|
_disassembler.reset(new Disassembler(console, _codeDataLogger, this));
|
|
_traceLogger.reset(new TraceLogger(this, _console));
|
|
_memoryAccessCounter.reset(new MemoryAccessCounter(this, console.get()));
|
|
_ppuTools.reset(new PpuTools(_console.get(), _ppu.get()));
|
|
_scriptManager.reset(new ScriptManager(this));
|
|
|
|
if(_gameboy) {
|
|
_gbDebugger.reset(new GbDebugger(this));
|
|
}
|
|
_cpuDebugger.reset(new CpuDebugger(this, CpuType::Cpu));
|
|
_spcDebugger.reset(new SpcDebugger(this));
|
|
if(_cart->GetSa1()) {
|
|
_sa1Debugger.reset(new CpuDebugger(this, CpuType::Sa1));
|
|
} else if(_cart->GetGsu()) {
|
|
_gsuDebugger.reset(new GsuDebugger(this));
|
|
} else if(_cart->GetDsp()) {
|
|
_necDspDebugger.reset(new NecDspDebugger(this));
|
|
} else if(_cart->GetCx4()) {
|
|
_cx4Debugger.reset(new Cx4Debugger(this));
|
|
}
|
|
|
|
_executionStopped = true;
|
|
_breakRequestCount = 0;
|
|
_suspendRequestCount = 0;
|
|
|
|
CpuType cpuType = _gbDebugger ? CpuType::Gameboy : CpuType::Cpu;
|
|
string cdlFile = FolderUtilities::CombinePath(FolderUtilities::GetDebuggerFolder(), FolderUtilities::GetFilename(_cart->GetRomInfo().RomFile.GetFileName(), false) + ".cdl");
|
|
GetCodeDataLogger(cpuType)->LoadCdlFile(cdlFile, _settings->CheckDebuggerFlag(DebuggerFlags::AutoResetCdl), _cart->GetCrc32());
|
|
|
|
RefreshCodeCache();
|
|
|
|
if(_console->IsPaused()) {
|
|
Step(CpuType::Cpu, 1, StepType::Step);
|
|
}
|
|
_executionStopped = false;
|
|
}
|
|
|
|
Debugger::~Debugger()
|
|
{
|
|
Release();
|
|
}
|
|
|
|
void Debugger::Release()
|
|
{
|
|
CpuType cpuType = _gbDebugger ? CpuType::Gameboy : CpuType::Cpu;
|
|
string cdlFile = FolderUtilities::CombinePath(FolderUtilities::GetDebuggerFolder(), FolderUtilities::GetFilename(_cart->GetRomInfo().RomFile.GetFileName(), false) + ".cdl");
|
|
GetCodeDataLogger(cpuType)->SaveCdlFile(cdlFile, _cart->GetCrc32());
|
|
|
|
while(_executionStopped) {
|
|
Run();
|
|
}
|
|
}
|
|
|
|
void Debugger::Reset()
|
|
{
|
|
_memoryAccessCounter->ResetCounts();
|
|
_cpuDebugger->Reset();
|
|
_spcDebugger->Reset();
|
|
if(_sa1Debugger) {
|
|
_sa1Debugger->Reset();
|
|
}
|
|
}
|
|
|
|
template<CpuType type>
|
|
void Debugger::ProcessMemoryRead(uint32_t addr, uint8_t value, MemoryOperationType opType)
|
|
{
|
|
switch(type) {
|
|
case CpuType::Cpu: _cpuDebugger->ProcessRead(addr, value, opType); break;
|
|
case CpuType::Spc: _spcDebugger->ProcessRead(addr, value, opType); break;
|
|
case CpuType::NecDsp: _necDspDebugger->ProcessRead(addr, value, opType); break;
|
|
case CpuType::Sa1: _sa1Debugger->ProcessRead(addr, value, opType); break;
|
|
case CpuType::Gsu: _gsuDebugger->ProcessRead(addr, value, opType); break;
|
|
case CpuType::Cx4: _cx4Debugger->ProcessRead(addr, value, opType); break;
|
|
case CpuType::Gameboy: _gbDebugger->ProcessRead(addr, value, opType); break;
|
|
}
|
|
|
|
if(_scriptManager->HasScript()) {
|
|
_scriptManager->ProcessMemoryOperation(addr, value, opType, type);
|
|
}
|
|
}
|
|
|
|
template<CpuType type>
|
|
void Debugger::ProcessMemoryWrite(uint32_t addr, uint8_t value, MemoryOperationType opType)
|
|
{
|
|
switch(type) {
|
|
case CpuType::Cpu: _cpuDebugger->ProcessWrite(addr, value, opType); break;
|
|
case CpuType::Spc: _spcDebugger->ProcessWrite(addr, value, opType); break;
|
|
case CpuType::NecDsp: _necDspDebugger->ProcessWrite(addr, value, opType); break;
|
|
case CpuType::Sa1: _sa1Debugger->ProcessWrite(addr, value, opType); break;
|
|
case CpuType::Gsu: _gsuDebugger->ProcessWrite(addr, value, opType); break;
|
|
case CpuType::Cx4: _cx4Debugger->ProcessWrite(addr, value, opType); break;
|
|
case CpuType::Gameboy: _gbDebugger->ProcessWrite(addr, value, opType); break;
|
|
}
|
|
|
|
if(_scriptManager->HasScript()) {
|
|
_scriptManager->ProcessMemoryOperation(addr, value, opType, type);
|
|
}
|
|
}
|
|
|
|
void Debugger::ProcessWorkRamRead(uint32_t addr, uint8_t value)
|
|
{
|
|
AddressInfo addressInfo { (int32_t)addr, SnesMemoryType::WorkRam };
|
|
_memoryAccessCounter->ProcessMemoryRead(addressInfo, _memoryManager->GetMasterClock());
|
|
|
|
MemoryOperationInfo operation { 0x7E0000 | addr, value, MemoryOperationType::Read };
|
|
ProcessBreakConditions(false, _cpuDebugger->GetBreakpointManager(), operation, addressInfo);
|
|
}
|
|
|
|
void Debugger::ProcessWorkRamWrite(uint32_t addr, uint8_t value)
|
|
{
|
|
AddressInfo addressInfo { (int32_t)addr, SnesMemoryType::WorkRam };
|
|
_memoryAccessCounter->ProcessMemoryWrite(addressInfo, _memoryManager->GetMasterClock());
|
|
|
|
MemoryOperationInfo operation { 0x7E0000 | addr, value, MemoryOperationType::Write };
|
|
ProcessBreakConditions(false, _cpuDebugger->GetBreakpointManager(), operation, addressInfo);
|
|
}
|
|
|
|
void Debugger::ProcessPpuRead(uint16_t addr, uint8_t value, SnesMemoryType memoryType)
|
|
{
|
|
AddressInfo addressInfo { addr, memoryType };
|
|
MemoryOperationInfo operation { addr, value, MemoryOperationType::Read };
|
|
|
|
BreakpointManager* bpManager = DebugUtilities::ToCpuType(memoryType) == CpuType::Gameboy ? _gbDebugger->GetBreakpointManager() : _cpuDebugger->GetBreakpointManager();
|
|
ProcessBreakConditions(false, bpManager, operation, addressInfo);
|
|
|
|
_memoryAccessCounter->ProcessMemoryRead(addressInfo, _console->GetMasterClock());
|
|
}
|
|
|
|
void Debugger::ProcessPpuWrite(uint16_t addr, uint8_t value, SnesMemoryType memoryType)
|
|
{
|
|
AddressInfo addressInfo { addr, memoryType };
|
|
MemoryOperationInfo operation { addr, value, MemoryOperationType::Write };
|
|
|
|
BreakpointManager* bpManager = DebugUtilities::ToCpuType(memoryType) == CpuType::Gameboy ? _gbDebugger->GetBreakpointManager() : _cpuDebugger->GetBreakpointManager();
|
|
ProcessBreakConditions(false, bpManager, operation, addressInfo);
|
|
|
|
_memoryAccessCounter->ProcessMemoryWrite(addressInfo, _console->GetMasterClock());
|
|
}
|
|
|
|
template<CpuType cpuType>
|
|
void Debugger::ProcessPpuCycle()
|
|
{
|
|
uint16_t scanline;
|
|
uint16_t cycle;
|
|
if(cpuType == CpuType::Gameboy) {
|
|
scanline = _gameboy->GetPpu()->GetScanline();
|
|
cycle = _gameboy->GetPpu()->GetCycle();
|
|
} else {
|
|
scanline = _ppu->GetScanline();
|
|
cycle = _memoryManager->GetHClock();
|
|
}
|
|
|
|
_ppuTools->UpdateViewers(scanline, cycle, cpuType);
|
|
|
|
switch(cpuType) {
|
|
case CpuType::Cpu:
|
|
//Catch up SPC/DSP as needed (if we're tracing or debugging those particular CPUs)
|
|
if(_traceLogger->IsCpuLogged(CpuType::Spc) || _settings->CheckDebuggerFlag(DebuggerFlags::SpcDebuggerEnabled)) {
|
|
_spc->Run();
|
|
} else if(_traceLogger->IsCpuLogged(CpuType::NecDsp)) {
|
|
_cart->RunCoprocessors();
|
|
}
|
|
|
|
_cpuDebugger->ProcessPpuCycle(scanline, cycle);
|
|
break;
|
|
|
|
case CpuType::Gameboy:
|
|
_gbDebugger->ProcessPpuCycle(scanline, cycle);
|
|
break;
|
|
}
|
|
|
|
if(_breakRequestCount > 0) {
|
|
SleepUntilResume(BreakSource::Unspecified);
|
|
}
|
|
}
|
|
|
|
void Debugger::SleepUntilResume(BreakSource source, MemoryOperationInfo *operation, int breakpointId)
|
|
{
|
|
if(_suspendRequestCount) {
|
|
return;
|
|
}
|
|
|
|
_console->GetSoundMixer()->StopAudio();
|
|
_disassembler->Disassemble(CpuType::Cpu);
|
|
_disassembler->Disassemble(CpuType::Spc);
|
|
if(_cart->GetSa1()) {
|
|
_disassembler->Disassemble(CpuType::Sa1);
|
|
} else if(_cart->GetGsu()) {
|
|
_disassembler->Disassemble(CpuType::Gsu);
|
|
} else if(_cart->GetDsp()) {
|
|
_disassembler->Disassemble(CpuType::NecDsp);
|
|
} else if(_cart->GetCx4()) {
|
|
_disassembler->Disassemble(CpuType::Cx4);
|
|
} else if(_cart->GetGameboy()) {
|
|
_disassembler->RefreshDisassembly(CpuType::Gameboy);
|
|
}
|
|
|
|
_executionStopped = true;
|
|
|
|
if(source != BreakSource::Unspecified || _breakRequestCount == 0) {
|
|
//Only trigger code break event if the pause was caused by user action
|
|
BreakEvent evt = {};
|
|
evt.BreakpointId = breakpointId;
|
|
evt.Source = source;
|
|
if(operation) {
|
|
evt.Operation = *operation;
|
|
}
|
|
_waitForBreakResume = true;
|
|
_console->GetNotificationManager()->SendNotification(ConsoleNotificationType::CodeBreak, &evt);
|
|
}
|
|
|
|
while((_waitForBreakResume && !_suspendRequestCount) || _breakRequestCount) {
|
|
std::this_thread::sleep_for(std::chrono::duration<int, std::milli>(10));
|
|
}
|
|
|
|
_executionStopped = false;
|
|
}
|
|
|
|
void Debugger::ProcessBreakConditions(bool needBreak, BreakpointManager* bpManager, MemoryOperationInfo &operation, AddressInfo &addressInfo, BreakSource source)
|
|
{
|
|
if(needBreak || _breakRequestCount || _waitForBreakResume) {
|
|
SleepUntilResume(source);
|
|
} else {
|
|
int breakpointId = bpManager->CheckBreakpoint(operation, addressInfo);
|
|
if(breakpointId >= 0) {
|
|
SleepUntilResume(BreakSource::Breakpoint, &operation, breakpointId);
|
|
}
|
|
}
|
|
}
|
|
|
|
template<CpuType type>
|
|
void Debugger::ProcessInterrupt(uint32_t originalPc, uint32_t currentPc, bool forNmi)
|
|
{
|
|
switch(type) {
|
|
case CpuType::Cpu: _cpuDebugger->ProcessInterrupt(originalPc, currentPc, forNmi); break;
|
|
case CpuType::Sa1: _sa1Debugger->ProcessInterrupt(originalPc, currentPc, forNmi); break;
|
|
case CpuType::Gameboy: _gbDebugger->ProcessInterrupt(originalPc, currentPc); break;
|
|
}
|
|
|
|
ProcessEvent(forNmi ? EventType::Nmi : EventType::Irq);
|
|
}
|
|
|
|
void Debugger::ProcessEvent(EventType type)
|
|
{
|
|
_scriptManager->ProcessEvent(type);
|
|
|
|
switch(type) {
|
|
default: break;
|
|
|
|
case EventType::StartFrame:
|
|
_console->GetNotificationManager()->SendNotification(ConsoleNotificationType::EventViewerRefresh, (void*)CpuType::Cpu);
|
|
GetEventManager(CpuType::Cpu)->ClearFrameEvents();
|
|
break;
|
|
|
|
case EventType::GbStartFrame:
|
|
if(_settings->CheckFlag(EmulationFlags::GameboyMode)) {
|
|
_scriptManager->ProcessEvent(EventType::StartFrame);
|
|
}
|
|
_console->GetNotificationManager()->SendNotification(ConsoleNotificationType::EventViewerRefresh, (void*)CpuType::Gameboy);
|
|
GetEventManager(CpuType::Gameboy)->ClearFrameEvents();
|
|
break;
|
|
|
|
case EventType::GbEndFrame:
|
|
if(_settings->CheckFlag(EmulationFlags::GameboyMode)) {
|
|
_scriptManager->ProcessEvent(EventType::EndFrame);
|
|
}
|
|
break;
|
|
|
|
case EventType::Reset:
|
|
Reset();
|
|
break;
|
|
|
|
case EventType::StateLoaded:
|
|
_memoryAccessCounter->ResetCounts();
|
|
break;
|
|
}
|
|
}
|
|
|
|
int32_t Debugger::EvaluateExpression(string expression, CpuType cpuType, EvalResultType &resultType, bool useCache)
|
|
{
|
|
MemoryOperationInfo operationInfo { 0, 0, MemoryOperationType::Read };
|
|
DebugState state;
|
|
GetState(state, false);
|
|
if(useCache) {
|
|
return _watchExpEval[(int)cpuType]->Evaluate(expression, state, resultType, operationInfo);
|
|
} else {
|
|
ExpressionEvaluator expEval(this, cpuType);
|
|
return expEval.Evaluate(expression, state, resultType, operationInfo);
|
|
}
|
|
}
|
|
|
|
void Debugger::Run()
|
|
{
|
|
_cpuDebugger->Run();
|
|
_spcDebugger->Run();
|
|
if(_sa1Debugger) {
|
|
_sa1Debugger->Run();
|
|
}
|
|
if(_gsuDebugger) {
|
|
_gsuDebugger->Run();
|
|
}
|
|
if(_necDspDebugger) {
|
|
_necDspDebugger->Run();
|
|
}
|
|
if(_cx4Debugger) {
|
|
_cx4Debugger->Run();
|
|
}
|
|
if(_gbDebugger) {
|
|
_gbDebugger->Run();
|
|
}
|
|
_waitForBreakResume = false;
|
|
}
|
|
|
|
void Debugger::Step(CpuType cpuType, int32_t stepCount, StepType type)
|
|
{
|
|
DebugBreakHelper helper(this);
|
|
StepRequest step;
|
|
IDebugger *debugger = nullptr;
|
|
|
|
switch(cpuType) {
|
|
case CpuType::Cpu: debugger = _cpuDebugger.get(); break;
|
|
case CpuType::Spc: debugger = _spcDebugger.get(); break;
|
|
case CpuType::NecDsp: debugger = _necDspDebugger.get(); break;
|
|
case CpuType::Sa1: debugger = _sa1Debugger.get(); break;
|
|
case CpuType::Gsu: debugger = _gsuDebugger.get(); break;
|
|
case CpuType::Cx4: debugger = _cx4Debugger.get(); break;
|
|
case CpuType::Gameboy: debugger = _gbDebugger.get(); break;
|
|
}
|
|
|
|
if(debugger) {
|
|
debugger->Step(stepCount, type);
|
|
}
|
|
|
|
if(debugger != _cpuDebugger.get()) {
|
|
_cpuDebugger->Run();
|
|
}
|
|
if(debugger != _spcDebugger.get()) {
|
|
_spcDebugger->Run();
|
|
}
|
|
if(_sa1Debugger && debugger != _sa1Debugger.get()) {
|
|
_sa1Debugger->Run();
|
|
}
|
|
if(_gsuDebugger && debugger != _gsuDebugger.get()) {
|
|
_gsuDebugger->Run();
|
|
}
|
|
if(_necDspDebugger && debugger != _necDspDebugger.get()) {
|
|
_necDspDebugger->Run();
|
|
}
|
|
if(_cx4Debugger && debugger != _cx4Debugger.get()) {
|
|
_cx4Debugger->Run();
|
|
}
|
|
if(_gbDebugger && debugger != _gbDebugger.get()) {
|
|
_gbDebugger->Run();
|
|
}
|
|
_waitForBreakResume = false;
|
|
}
|
|
|
|
bool Debugger::IsExecutionStopped()
|
|
{
|
|
return _executionStopped || _console->IsThreadPaused();
|
|
}
|
|
|
|
bool Debugger::HasBreakRequest()
|
|
{
|
|
return _breakRequestCount > 0;
|
|
}
|
|
|
|
void Debugger::BreakRequest(bool release)
|
|
{
|
|
if(release) {
|
|
_breakRequestCount--;
|
|
} else {
|
|
_breakRequestCount++;
|
|
}
|
|
}
|
|
|
|
void Debugger::SuspendDebugger(bool release)
|
|
{
|
|
if(release) {
|
|
if(_suspendRequestCount > 0) {
|
|
_suspendRequestCount--;
|
|
} else {
|
|
#ifdef _DEBUG
|
|
//throw std::runtime_error("unexpected debugger suspend::release call");
|
|
#endif
|
|
}
|
|
} else {
|
|
_suspendRequestCount++;
|
|
}
|
|
}
|
|
|
|
void Debugger::BreakImmediately(BreakSource source)
|
|
{
|
|
bool gbDebugger = _settings->CheckDebuggerFlag(DebuggerFlags::GbDebuggerEnabled);
|
|
if(source == BreakSource::GbDisableLcdOutsideVblank && (!gbDebugger || !_settings->CheckDebuggerFlag(DebuggerFlags::GbBreakOnDisableLcdOutsideVblank))) {
|
|
return;
|
|
} else if(source == BreakSource::GbInvalidVramAccess && (!gbDebugger || !_settings->CheckDebuggerFlag(DebuggerFlags::GbBreakOnInvalidVramAccess))) {
|
|
return;
|
|
} else if(source == BreakSource::GbInvalidOamAccess && (!gbDebugger || !_settings->CheckDebuggerFlag(DebuggerFlags::GbBreakOnInvalidOamAccess))) {
|
|
return;
|
|
}
|
|
SleepUntilResume(source);
|
|
}
|
|
|
|
void Debugger::GetState(DebugState &state, bool partialPpuState)
|
|
{
|
|
state.MasterClock = _console->GetMasterClock();
|
|
state.Cpu = _cpu->GetState();
|
|
_ppu->GetState(state.Ppu, partialPpuState);
|
|
state.Spc = _spc->GetState();
|
|
state.Dsp = _spc->GetDspState();
|
|
|
|
if(!partialPpuState) {
|
|
for(int i = 0; i < 8; i++) {
|
|
state.DmaChannels[i] = _dmaController->GetChannelConfig(i);
|
|
}
|
|
state.InternalRegs = _internalRegs->GetState();
|
|
state.Alu = _internalRegs->GetAluState();
|
|
}
|
|
|
|
if(_cart->GetDsp()) {
|
|
state.NecDsp = _cart->GetDsp()->GetState();
|
|
}
|
|
if(_cart->GetSa1()) {
|
|
state.Sa1 = _cart->GetSa1()->GetState();
|
|
}
|
|
if(_cart->GetGsu()) {
|
|
state.Gsu = _cart->GetGsu()->GetState();
|
|
}
|
|
if(_cart->GetCx4()) {
|
|
state.Cx4 = _cart->GetCx4()->GetState();
|
|
}
|
|
if(_cart->GetGameboy()) {
|
|
state.Gameboy = _cart->GetGameboy()->GetState();
|
|
}
|
|
}
|
|
|
|
bool Debugger::GetCpuProcFlag(ProcFlags::ProcFlags flag)
|
|
{
|
|
return _cpu->GetCpuProcFlag(flag);
|
|
}
|
|
|
|
void Debugger::SetCpuRegister(CpuRegister reg, uint16_t value)
|
|
{
|
|
_cpu->SetReg(reg, value);
|
|
}
|
|
|
|
void Debugger::SetCpuProcFlag(ProcFlags::ProcFlags flag, bool set)
|
|
{
|
|
_cpu->SetCpuProcFlag(flag, set);
|
|
}
|
|
|
|
void Debugger::SetCx4Register(Cx4Register reg, uint32_t value)
|
|
{
|
|
_cart->GetCx4()->SetReg(reg, value);
|
|
}
|
|
|
|
void Debugger::SetGameboyRegister(GbRegister reg, uint16_t value)
|
|
{
|
|
_cart->GetGameboy()->SetReg(reg, value);
|
|
}
|
|
|
|
void Debugger::SetGsuRegister(GsuRegister reg, uint16_t value)
|
|
{
|
|
_cart->GetGsu()->SetReg(reg, value);
|
|
}
|
|
|
|
void Debugger::SetNecDspRegister(NecDspRegister reg, uint16_t value)
|
|
{
|
|
_cart->GetDsp()->SetReg(reg, value);
|
|
}
|
|
|
|
void Debugger::SetSa1Register(CpuRegister reg, uint16_t value)
|
|
{
|
|
_cart->GetSa1()->SetReg(reg, value);
|
|
}
|
|
|
|
void Debugger::SetSpcRegister(SpcRegister reg, uint16_t value)
|
|
{
|
|
_spc->SetReg(reg, value);
|
|
}
|
|
|
|
AddressInfo Debugger::GetAbsoluteAddress(AddressInfo relAddress)
|
|
{
|
|
if(relAddress.Type == SnesMemoryType::CpuMemory) {
|
|
if(_memoryManager->IsRegister(relAddress.Address)) {
|
|
return { relAddress.Address & 0xFFFF, SnesMemoryType::Register };
|
|
} else {
|
|
return _memoryManager->GetMemoryMappings()->GetAbsoluteAddress(relAddress.Address);
|
|
}
|
|
} else if(relAddress.Type == SnesMemoryType::SpcMemory) {
|
|
return _spc->GetAbsoluteAddress(relAddress.Address);
|
|
} else if(relAddress.Type == SnesMemoryType::Sa1Memory) {
|
|
return _cart->GetSa1()->GetMemoryMappings()->GetAbsoluteAddress(relAddress.Address);
|
|
} else if(relAddress.Type == SnesMemoryType::GsuMemory) {
|
|
return _cart->GetGsu()->GetMemoryMappings()->GetAbsoluteAddress(relAddress.Address);
|
|
} else if(relAddress.Type == SnesMemoryType::Cx4Memory) {
|
|
return _cart->GetCx4()->GetMemoryMappings()->GetAbsoluteAddress(relAddress.Address);
|
|
} else if(relAddress.Type == SnesMemoryType::NecDspMemory) {
|
|
return { relAddress.Address, SnesMemoryType::DspProgramRom };
|
|
} else if(relAddress.Type == SnesMemoryType::GameboyMemory) {
|
|
return _cart->GetGameboy()->GetAbsoluteAddress(relAddress.Address);
|
|
}
|
|
|
|
throw std::runtime_error("Unsupported address type");
|
|
}
|
|
|
|
AddressInfo Debugger::GetRelativeAddress(AddressInfo absAddress, CpuType cpuType)
|
|
{
|
|
MemoryMappings* mappings = nullptr;
|
|
switch(cpuType) {
|
|
case CpuType::Cpu: mappings = _memoryManager->GetMemoryMappings(); break;
|
|
case CpuType::Spc: break;
|
|
case CpuType::NecDsp: break;
|
|
case CpuType::Sa1: mappings = _cart->GetSa1()->GetMemoryMappings(); break;
|
|
case CpuType::Gsu: mappings = _cart->GetGsu()->GetMemoryMappings(); break;
|
|
case CpuType::Cx4: mappings = _cart->GetCx4()->GetMemoryMappings(); break;
|
|
case CpuType::Gameboy: break;
|
|
}
|
|
|
|
switch(absAddress.Type) {
|
|
case SnesMemoryType::PrgRom:
|
|
case SnesMemoryType::WorkRam:
|
|
case SnesMemoryType::SaveRam: {
|
|
if(!mappings) {
|
|
throw std::runtime_error("Unsupported cpu type");
|
|
}
|
|
|
|
uint8_t startBank = 0;
|
|
//Try to find a mirror close to where the PC is
|
|
if(cpuType == CpuType::Cpu) {
|
|
if(absAddress.Type == SnesMemoryType::WorkRam) {
|
|
startBank = 0x7E;
|
|
} else {
|
|
startBank = _cpu->GetState().K & 0xC0;
|
|
}
|
|
} else if(cpuType == CpuType::Sa1) {
|
|
startBank = (_cart->GetSa1()->GetCpuState().K & 0xC0);
|
|
} else if(cpuType == CpuType::Gsu) {
|
|
startBank = (_cart->GetGsu()->GetState().ProgramBank & 0xC0);
|
|
}
|
|
|
|
return { mappings->GetRelativeAddress(absAddress, startBank), DebugUtilities::GetCpuMemoryType(cpuType) };
|
|
}
|
|
|
|
case SnesMemoryType::SpcRam:
|
|
case SnesMemoryType::SpcRom:
|
|
return { _spc->GetRelativeAddress(absAddress), SnesMemoryType::SpcMemory };
|
|
|
|
case SnesMemoryType::GbPrgRom:
|
|
case SnesMemoryType::GbWorkRam:
|
|
case SnesMemoryType::GbCartRam:
|
|
case SnesMemoryType::GbHighRam:
|
|
case SnesMemoryType::GbBootRom:
|
|
return { _cart->GetGameboy()->GetRelativeAddress(absAddress), SnesMemoryType::GameboyMemory };
|
|
|
|
case SnesMemoryType::DspProgramRom:
|
|
return { absAddress.Address, SnesMemoryType::NecDspMemory };
|
|
|
|
case SnesMemoryType::Register:
|
|
return { absAddress.Address & 0xFFFF, SnesMemoryType::Register };
|
|
|
|
default:
|
|
return { -1, SnesMemoryType::Register };
|
|
}
|
|
}
|
|
|
|
void Debugger::SetCdlData(CpuType cpuType, uint8_t *cdlData, uint32_t length)
|
|
{
|
|
DebugBreakHelper helper(this);
|
|
GetCodeDataLogger(cpuType)->SetCdlData(cdlData, length);
|
|
RefreshCodeCache();
|
|
}
|
|
|
|
void Debugger::MarkBytesAs(CpuType cpuType, uint32_t start, uint32_t end, uint8_t flags)
|
|
{
|
|
DebugBreakHelper helper(this);
|
|
GetCodeDataLogger(cpuType)->MarkBytesAs(start, end, flags);
|
|
RefreshCodeCache();
|
|
}
|
|
|
|
void Debugger::RefreshCodeCache()
|
|
{
|
|
_disassembler->ResetPrgCache();
|
|
RebuildPrgCache(CpuType::Cpu);
|
|
RebuildPrgCache(CpuType::Gameboy);
|
|
}
|
|
|
|
void Debugger::RebuildPrgCache(CpuType cpuType)
|
|
{
|
|
shared_ptr<CodeDataLogger> cdl = GetCodeDataLogger(cpuType);
|
|
if(!cdl) {
|
|
return;
|
|
}
|
|
|
|
uint32_t prgRomSize = cdl->GetPrgSize();
|
|
AddressInfo addrInfo;
|
|
addrInfo.Type = cpuType == CpuType::Gameboy ? SnesMemoryType::GbPrgRom : SnesMemoryType::PrgRom;
|
|
|
|
for(uint32_t i = 0; i < prgRomSize; i++) {
|
|
if(cdl->IsCode(i)) {
|
|
addrInfo.Address = (int32_t)i;
|
|
i += _disassembler->BuildCache(addrInfo, cdl->GetCpuFlags(i), cdl->GetCpuType(i)) - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Debugger::GetCdlData(uint32_t offset, uint32_t length, SnesMemoryType memoryType, uint8_t* cdlData)
|
|
{
|
|
CpuType cpuType = DebugUtilities::ToCpuType(memoryType);
|
|
shared_ptr<CodeDataLogger> cdl = GetCodeDataLogger(cpuType);
|
|
if(memoryType == SnesMemoryType::PrgRom || memoryType == SnesMemoryType::GbPrgRom) {
|
|
cdl->GetCdlData(offset, length, cdlData);
|
|
} else {
|
|
SnesMemoryType prgType = _gbDebugger ? SnesMemoryType::GbPrgRom : SnesMemoryType::PrgRom;
|
|
|
|
AddressInfo relAddress;
|
|
relAddress.Type = memoryType;
|
|
for(uint32_t i = 0; i < length; i++) {
|
|
relAddress.Address = offset + i;
|
|
AddressInfo info = GetAbsoluteAddress(relAddress);
|
|
cdlData[i] = info.Type == prgType ? cdl->GetFlags(info.Address) : 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Debugger::SetBreakpoints(Breakpoint breakpoints[], uint32_t length)
|
|
{
|
|
_cpuDebugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
|
|
_spcDebugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
|
|
if(_gsuDebugger) {
|
|
_gsuDebugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
|
|
}
|
|
if(_sa1Debugger) {
|
|
_sa1Debugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
|
|
}
|
|
if(_necDspDebugger) {
|
|
_necDspDebugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
|
|
}
|
|
if(_cx4Debugger) {
|
|
_cx4Debugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
|
|
}
|
|
if(_gbDebugger) {
|
|
_gbDebugger->GetBreakpointManager()->SetBreakpoints(breakpoints, length);
|
|
}
|
|
}
|
|
|
|
void Debugger::GetBreakpoints(CpuType cpuType, Breakpoint* breakpoints, int& execs, int& reads, int& writes)
|
|
{
|
|
switch (cpuType) {
|
|
case CpuType::Cpu: return _cpuDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
|
|
case CpuType::Spc: return _spcDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
|
|
case CpuType::Gsu: {
|
|
if (_gsuDebugger) {
|
|
return _gsuDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
|
|
}
|
|
} break;
|
|
case CpuType::Sa1: {
|
|
if (_sa1Debugger) {
|
|
return _sa1Debugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
|
|
}
|
|
} break;
|
|
case CpuType::NecDsp: {
|
|
if (_necDspDebugger) {
|
|
return _necDspDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
|
|
}
|
|
} break;
|
|
case CpuType::Cx4: {
|
|
if (_cx4Debugger) {
|
|
return _cx4Debugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
|
|
}
|
|
} break;
|
|
case CpuType::Gameboy: {
|
|
if (_gbDebugger) {
|
|
return _gbDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
|
|
}
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void Debugger::Log(string message)
|
|
{
|
|
auto lock = _logLock.AcquireSafe();
|
|
if(_debuggerLog.size() >= 1000) {
|
|
_debuggerLog.pop_front();
|
|
}
|
|
_debuggerLog.push_back(message);
|
|
}
|
|
|
|
string Debugger::GetLog()
|
|
{
|
|
auto lock = _logLock.AcquireSafe();
|
|
stringstream ss;
|
|
for(string& msg : _debuggerLog) {
|
|
ss << msg << "\n";
|
|
}
|
|
return ss.str();
|
|
}
|
|
|
|
void Debugger::SaveRomToDisk(string filename, bool saveAsIps, CdlStripOption stripOption)
|
|
{
|
|
vector<uint8_t> output;
|
|
RomInfo romInfo = _cart->GetRomInfo();
|
|
Gameboy* gb = _cart->GetGameboy();
|
|
|
|
vector<uint8_t> rom;
|
|
if(gb) {
|
|
uint8_t* prgRom = gb->DebugGetMemory(SnesMemoryType::GbPrgRom);
|
|
uint32_t prgRomSize = gb->DebugGetMemorySize(SnesMemoryType::GbPrgRom);
|
|
rom = vector<uint8_t>(prgRom, prgRom+prgRomSize);
|
|
} else {
|
|
rom = vector<uint8_t>(_cart->DebugGetPrgRom(), _cart->DebugGetPrgRom() + _cart->DebugGetPrgRomSize());
|
|
}
|
|
|
|
if(saveAsIps) {
|
|
output = IpsPatcher::CreatePatch(_cart->GetOriginalPrgRom(), rom);
|
|
} else {
|
|
if(stripOption != CdlStripOption::StripNone) {
|
|
GetCodeDataLogger(gb ? CpuType::Gameboy : CpuType::Cpu)->StripData(rom.data(), stripOption);
|
|
|
|
//Preserve rom header regardless of CDL file contents
|
|
if(gb) {
|
|
GameboyHeader header = gb->GetHeader();
|
|
memcpy(rom.data() + romInfo.HeaderOffset, &header, sizeof(GameboyHeader));
|
|
} else {
|
|
memcpy(rom.data() + romInfo.HeaderOffset, &romInfo.Header, sizeof(SnesCartInformation));
|
|
}
|
|
}
|
|
output = rom;
|
|
}
|
|
|
|
ofstream file(filename, ios::out | ios::binary);
|
|
if(file) {
|
|
file.write((char*)output.data(), output.size());
|
|
file.close();
|
|
}
|
|
}
|
|
|
|
shared_ptr<TraceLogger> Debugger::GetTraceLogger()
|
|
{
|
|
return _traceLogger;
|
|
}
|
|
|
|
shared_ptr<MemoryDumper> Debugger::GetMemoryDumper()
|
|
{
|
|
return _memoryDumper;
|
|
}
|
|
|
|
shared_ptr<MemoryAccessCounter> Debugger::GetMemoryAccessCounter()
|
|
{
|
|
return _memoryAccessCounter;
|
|
}
|
|
|
|
shared_ptr<CodeDataLogger> Debugger::GetCodeDataLogger(CpuType cpuType)
|
|
{
|
|
if(cpuType == CpuType::Gameboy) {
|
|
return _gbDebugger ? _gbDebugger->GetCodeDataLogger() : nullptr;
|
|
} else {
|
|
return _codeDataLogger;
|
|
}
|
|
}
|
|
|
|
shared_ptr<Disassembler> Debugger::GetDisassembler()
|
|
{
|
|
return _disassembler;
|
|
}
|
|
|
|
shared_ptr<PpuTools> Debugger::GetPpuTools()
|
|
{
|
|
return _ppuTools;
|
|
}
|
|
|
|
shared_ptr<IEventManager> Debugger::GetEventManager(CpuType cpuType)
|
|
{
|
|
if(cpuType == CpuType::Gameboy) {
|
|
return std::dynamic_pointer_cast<IEventManager>(_gbDebugger->GetEventManager());
|
|
} else {
|
|
return std::dynamic_pointer_cast<IEventManager>(_cpuDebugger->GetEventManager());
|
|
}
|
|
}
|
|
|
|
shared_ptr<LabelManager> Debugger::GetLabelManager()
|
|
{
|
|
return _labelManager;
|
|
}
|
|
|
|
shared_ptr<ScriptManager> Debugger::GetScriptManager()
|
|
{
|
|
return _scriptManager;
|
|
}
|
|
|
|
shared_ptr<CallstackManager> Debugger::GetCallstackManager(CpuType cpuType)
|
|
{
|
|
switch(cpuType) {
|
|
case CpuType::Cpu: return _cpuDebugger->GetCallstackManager();
|
|
case CpuType::Spc: return _spcDebugger->GetCallstackManager();
|
|
case CpuType::Sa1: return _sa1Debugger->GetCallstackManager();
|
|
case CpuType::Gameboy: return _gbDebugger->GetCallstackManager();
|
|
|
|
case CpuType::Gsu:
|
|
case CpuType::NecDsp:
|
|
case CpuType::Cx4:
|
|
break;
|
|
}
|
|
throw std::runtime_error("GetCallstackManager() - Unsupported CPU type");
|
|
}
|
|
|
|
shared_ptr<Console> Debugger::GetConsole()
|
|
{
|
|
return _console;
|
|
}
|
|
|
|
shared_ptr<IAssembler> Debugger::GetAssembler(CpuType cpuType)
|
|
{
|
|
if(cpuType == CpuType::Gameboy) {
|
|
return std::dynamic_pointer_cast<IAssembler>(_gbDebugger->GetAssembler());
|
|
} else {
|
|
return std::dynamic_pointer_cast<IAssembler>(_cpuDebugger->GetAssembler());
|
|
}
|
|
}
|
|
|
|
template void Debugger::ProcessMemoryRead<CpuType::Cpu>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
template void Debugger::ProcessMemoryRead<CpuType::Sa1>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
template void Debugger::ProcessMemoryRead<CpuType::Spc>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
template void Debugger::ProcessMemoryRead<CpuType::Gsu>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
template void Debugger::ProcessMemoryRead<CpuType::NecDsp>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
template void Debugger::ProcessMemoryRead<CpuType::Cx4>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
template void Debugger::ProcessMemoryRead<CpuType::Gameboy>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
|
|
template void Debugger::ProcessMemoryWrite<CpuType::Cpu>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
template void Debugger::ProcessMemoryWrite<CpuType::Sa1>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
template void Debugger::ProcessMemoryWrite<CpuType::Spc>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
template void Debugger::ProcessMemoryWrite<CpuType::Gsu>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
template void Debugger::ProcessMemoryWrite<CpuType::NecDsp>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
template void Debugger::ProcessMemoryWrite<CpuType::Cx4>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
template void Debugger::ProcessMemoryWrite<CpuType::Gameboy>(uint32_t addr, uint8_t value, MemoryOperationType opType);
|
|
|
|
template void Debugger::ProcessInterrupt<CpuType::Cpu>(uint32_t originalPc, uint32_t currentPc, bool forNmi);
|
|
template void Debugger::ProcessInterrupt<CpuType::Sa1>(uint32_t originalPc, uint32_t currentPc, bool forNmi);
|
|
template void Debugger::ProcessInterrupt<CpuType::Gameboy>(uint32_t originalPc, uint32_t currentPc, bool forNmi);
|
|
|
|
template void Debugger::ProcessPpuCycle<CpuType::Cpu>();
|
|
template void Debugger::ProcessPpuCycle<CpuType::Gameboy>();
|