mirror of
https://github.com/SourMesen/Mesen-S.git
synced 2024-05-11 01:05:01 -04:00
Debugger: Code refactoring (disassembler)
+ Fixed some issues when switching between different coprocessors while debug windows are opened
This commit is contained in:
Sour
parent
98fe9a85d6
commit
8ebe0401f7
|
|
@ -95,8 +95,6 @@ Debugger::Debugger(shared_ptr<Console> console)
|
|||
_cx4Debugger.reset(new Cx4Debugger(this));
|
||||
}
|
||||
|
||||
_step.reset(new StepRequest());
|
||||
|
||||
_executionStopped = true;
|
||||
_breakRequestCount = 0;
|
||||
_suspendRequestCount = 0;
|
||||
|
|
@ -360,7 +358,6 @@ int32_t Debugger::EvaluateExpression(string expression, CpuType cpuType, EvalRes
|
|||
|
||||
void Debugger::Run()
|
||||
{
|
||||
_step.reset(new StepRequest());
|
||||
_cpuDebugger->Run();
|
||||
_spcDebugger->Run();
|
||||
if(_sa1Debugger) {
|
||||
|
|
@ -396,11 +393,11 @@ void Debugger::Step(CpuType cpuType, int32_t stepCount, StepType type)
|
|||
case CpuType::Cx4: debugger = _cx4Debugger.get(); break;
|
||||
case CpuType::Gameboy: debugger = _gbDebugger.get(); break;
|
||||
}
|
||||
debugger->Step(stepCount, type);
|
||||
|
||||
if(!debugger) {
|
||||
_step.reset(new StepRequest(step));
|
||||
|
||||
if(debugger) {
|
||||
debugger->Step(stepCount, type);
|
||||
}
|
||||
|
||||
if(debugger != _cpuDebugger.get()) {
|
||||
_cpuDebugger->Run();
|
||||
}
|
||||
|
|
@ -787,7 +784,7 @@ shared_ptr<CallstackManager> Debugger::GetCallstackManager(CpuType 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(); break;
|
||||
case CpuType::Gameboy: return _gbDebugger->GetCallstackManager();
|
||||
|
||||
case CpuType::Gsu:
|
||||
case CpuType::NecDsp:
|
||||
|
|
|
|||
|
|
@ -83,8 +83,6 @@ private:
|
|||
atomic<uint32_t> _breakRequestCount;
|
||||
atomic<uint32_t> _suspendRequestCount;
|
||||
|
||||
unique_ptr<StepRequest> _step;
|
||||
|
||||
bool _waitForBreakResume = false;
|
||||
|
||||
void Reset();
|
||||
|
|
|
|||
|
|
@ -39,93 +39,37 @@ Disassembler::Disassembler(shared_ptr<Console> console, shared_ptr<CodeDataLogge
|
|||
_spc = console->GetSpc().get();
|
||||
_gsu = cart->GetGsu();
|
||||
_sa1 = cart->GetSa1();
|
||||
_cx4 = cart->GetCx4();
|
||||
_necDsp = cart->GetDsp();
|
||||
_gameboy = cart->GetGameboy();
|
||||
_settings = console->GetSettings().get();
|
||||
_memoryDumper = _debugger->GetMemoryDumper().get();
|
||||
_memoryManager = console->GetMemoryManager().get();
|
||||
|
||||
_prgRom = console->GetCartridge()->DebugGetPrgRom();
|
||||
_prgRomSize = console->GetCartridge()->DebugGetPrgRomSize();
|
||||
_sram = console->GetCartridge()->DebugGetSaveRam();
|
||||
_sramSize = console->GetCartridge()->DebugGetSaveRamSize();
|
||||
_wram = _memoryManager->DebugGetWorkRam();
|
||||
_wramSize = MemoryManager::WorkRamSize;
|
||||
|
||||
_spcRam = _spc->GetSpcRam();
|
||||
_spcRamSize = Spc::SpcRamSize;
|
||||
_spcRom = _spc->GetSpcRom();
|
||||
_spcRomSize = Spc::SpcRomSize;
|
||||
|
||||
_necDspProgramRom = cart->GetDsp() ? cart->GetDsp()->DebugGetProgramRom() : nullptr;
|
||||
_necDspProgramRomSize = cart->GetDsp() ? cart->GetDsp()->DebugGetProgramRomSize() : 0;
|
||||
|
||||
_sa1InternalRam = _sa1 ? _sa1->DebugGetInternalRam() : nullptr;
|
||||
_sa1InternalRamSize = _sa1 ? _sa1->DebugGetInternalRamSize() : 0;
|
||||
|
||||
_gsuWorkRam = _gsu ? _gsu->DebugGetWorkRam() : nullptr;
|
||||
_gsuWorkRamSize = _gsu ? _gsu->DebugGetWorkRamSize() : 0;
|
||||
|
||||
_bsxPsRam = cart->GetBsx() ? cart->GetBsx()->DebugGetPsRam() : nullptr;
|
||||
_bsxPsRamSize = cart->GetBsx() ? cart->GetBsx()->DebugGetPsRamSize() : 0;
|
||||
_bsxMemPack = cart->GetBsx() ? cart->GetBsxMemoryPack()->DebugGetMemoryPack() : nullptr;
|
||||
_bsxMemPackSize = cart->GetBsx() ? cart->GetBsxMemoryPack()->DebugGetMemoryPackSize() : 0;
|
||||
|
||||
_gbPrgRom = _gameboy ? _gameboy->DebugGetMemory(SnesMemoryType::GbPrgRom) : nullptr;
|
||||
_gbPrgRomSize = _gameboy ? _gameboy->DebugGetMemorySize(SnesMemoryType::GbPrgRom) : 0;
|
||||
_gbWorkRam = _gameboy ? _gameboy->DebugGetMemory(SnesMemoryType::GbWorkRam) : nullptr;
|
||||
_gbWorkRamSize = _gameboy ? _gameboy->DebugGetMemorySize(SnesMemoryType::GbWorkRam) : 0;
|
||||
_gbCartRam = _gameboy ? _gameboy->DebugGetMemory(SnesMemoryType::GbCartRam) : nullptr;
|
||||
_gbCartRamSize = _gameboy ? _gameboy->DebugGetMemorySize(SnesMemoryType::GbCartRam) : 0;
|
||||
_gbHighRam = _gameboy ? _gameboy->DebugGetMemory(SnesMemoryType::GbHighRam) : nullptr;
|
||||
_gbHighRamSize = _gameboy ? _gameboy->DebugGetMemorySize(SnesMemoryType::GbHighRam) : 0;
|
||||
_gbBootRom = _gameboy ? _gameboy->DebugGetMemory(SnesMemoryType::GbBootRom) : nullptr;
|
||||
_gbBootRomSize = _gameboy ? _gameboy->DebugGetMemorySize(SnesMemoryType::GbBootRom) : 0;
|
||||
|
||||
_prgCache = vector<DisassemblyInfo>(_prgRomSize);
|
||||
_sramCache = vector<DisassemblyInfo>(_sramSize);
|
||||
_wramCache = vector<DisassemblyInfo>(_wramSize);
|
||||
_spcRamCache = vector<DisassemblyInfo>(_spcRamSize);
|
||||
_spcRomCache = vector<DisassemblyInfo>(_spcRomSize);
|
||||
_necDspRomCache = vector<DisassemblyInfo>(_necDspProgramRomSize);
|
||||
_sa1InternalRamCache = vector<DisassemblyInfo>(_sa1InternalRamSize);
|
||||
_gsuWorkRamCache = vector<DisassemblyInfo>(_gsuWorkRamSize);
|
||||
_bsxPsRamCache = vector<DisassemblyInfo>(_bsxPsRamSize);
|
||||
_bsxMemPackCache = vector<DisassemblyInfo>(_bsxMemPackSize);
|
||||
|
||||
_gbPrgCache = vector<DisassemblyInfo>(_gbPrgRomSize);
|
||||
_gbWorkRamCache = vector<DisassemblyInfo>(_gbWorkRamSize);
|
||||
_gbCartRamCache = vector<DisassemblyInfo>(_gbCartRamSize);
|
||||
_gbHighRamCache = vector<DisassemblyInfo>(_gbHighRamSize);
|
||||
_gbBootRomCache = vector<DisassemblyInfo>(_gbBootRomSize);
|
||||
|
||||
for(int i = 0; i < (int)DebugUtilities::GetLastCpuType(); i++) {
|
||||
_disassemblyResult[i] = vector<DisassemblyResult>();
|
||||
_needDisassemble[i] = true;
|
||||
}
|
||||
|
||||
_sources[(int)SnesMemoryType::PrgRom] = { _prgRom, &_prgCache, _prgRomSize };
|
||||
_sources[(int)SnesMemoryType::WorkRam] = { _wram, &_wramCache, _wramSize };
|
||||
_sources[(int)SnesMemoryType::SaveRam] = { _sram, &_sramCache, _sramSize };
|
||||
_sources[(int)SnesMemoryType::SpcRam] = { _spcRam, &_spcRamCache, _spcRamSize };
|
||||
_sources[(int)SnesMemoryType::SpcRom] = { _spcRom, &_spcRomCache, _spcRomSize };
|
||||
_sources[(int)SnesMemoryType::DspProgramRom] = { _necDspProgramRom, &_necDspRomCache, _necDspProgramRomSize };
|
||||
_sources[(int)SnesMemoryType::Sa1InternalRam] = { _sa1InternalRam, &_sa1InternalRamCache, _sa1InternalRamSize };
|
||||
_sources[(int)SnesMemoryType::GsuWorkRam] = { _gsuWorkRam, &_gsuWorkRamCache, _gsuWorkRamSize };
|
||||
_sources[(int)SnesMemoryType::BsxPsRam] = { _bsxPsRam, &_bsxPsRamCache, _bsxPsRamSize };
|
||||
_sources[(int)SnesMemoryType::BsxMemoryPack] = { _bsxMemPack, &_bsxMemPackCache, _bsxMemPackSize };
|
||||
|
||||
_sources[(int)SnesMemoryType::GbPrgRom] = { _gbPrgRom, &_gbPrgCache, _gbPrgRomSize };
|
||||
_sources[(int)SnesMemoryType::GbWorkRam] = { _gbWorkRam, &_gbWorkRamCache, _gbWorkRamSize };
|
||||
_sources[(int)SnesMemoryType::GbCartRam] = { _gbCartRam, &_gbCartRamCache, _gbCartRamSize };
|
||||
_sources[(int)SnesMemoryType::GbHighRam] = { _gbHighRam, &_gbHighRamCache, _gbHighRamSize };
|
||||
_sources[(int)SnesMemoryType::GbBootRom] = { _gbBootRom, &_gbBootRomCache, _gbBootRomSize };
|
||||
for(int i = (int)SnesMemoryType::PrgRom; i < (int)SnesMemoryType::Register; i++) {
|
||||
InitSource((SnesMemoryType)i);
|
||||
}
|
||||
|
||||
if(_necDspProgramRomSize > 0) {
|
||||
if(_necDsp) {
|
||||
//Build cache for the entire DSP chip (since it only contains instructions)
|
||||
AddressInfo dspStart = { 0, SnesMemoryType::DspProgramRom };
|
||||
BuildCache(dspStart, 0, CpuType::NecDsp);
|
||||
}
|
||||
}
|
||||
|
||||
void Disassembler::InitSource(SnesMemoryType type)
|
||||
{
|
||||
uint8_t* src = _memoryDumper->GetMemoryBuffer(type);
|
||||
uint32_t size = _memoryDumper->GetMemorySize(type);
|
||||
_disassemblyCache[(int)type] = vector<DisassemblyInfo>(size);
|
||||
_sources[(int)type] = { src, &_disassemblyCache[(int)type], size };
|
||||
}
|
||||
|
||||
DisassemblerSource& Disassembler::GetSource(SnesMemoryType type)
|
||||
{
|
||||
if(_sources[(int)type].Data == nullptr) {
|
||||
|
|
@ -135,20 +79,6 @@ DisassemblerSource& Disassembler::GetSource(SnesMemoryType type)
|
|||
return _sources[(int)type];
|
||||
}
|
||||
|
||||
vector<DisassemblyResult>& Disassembler::GetDisassemblyList(CpuType type)
|
||||
{
|
||||
switch(type) {
|
||||
case CpuType::Cpu: return _disassembly;
|
||||
case CpuType::Spc: return _spcDisassembly;
|
||||
case CpuType::NecDsp: return _necDspDisassembly;
|
||||
case CpuType::Sa1: return _sa1Disassembly;
|
||||
case CpuType::Gsu: return _gsuDisassembly;
|
||||
case CpuType::Cx4: return _cx4Disassembly;
|
||||
case CpuType::Gameboy: return _gbDisassembly;
|
||||
}
|
||||
throw std::runtime_error("Disassembly::GetDisassemblyList(): Invalid cpu type");
|
||||
}
|
||||
|
||||
uint32_t Disassembler::BuildCache(AddressInfo &addrInfo, uint8_t cpuFlags, CpuType type)
|
||||
{
|
||||
DisassemblerSource& src = GetSource(addrInfo.Type);
|
||||
|
|
@ -202,8 +132,8 @@ void Disassembler::SetDisassembleFlag(CpuType type)
|
|||
|
||||
void Disassembler::ResetPrgCache()
|
||||
{
|
||||
_prgCache = vector<DisassemblyInfo>(_prgRomSize);
|
||||
_gbPrgCache = vector<DisassemblyInfo>(_gbPrgRomSize);
|
||||
InitSource(SnesMemoryType::PrgRom);
|
||||
InitSource(SnesMemoryType::GbPrgRom);
|
||||
_needDisassemble[(int)CpuType::Cpu] = true;
|
||||
_needDisassemble[(int)CpuType::Sa1] = true;
|
||||
_needDisassemble[(int)CpuType::Gsu] = true;
|
||||
|
|
@ -242,9 +172,6 @@ void Disassembler::Disassemble(CpuType cpuType)
|
|||
|
||||
auto lock = _disassemblyLock.AcquireSafe();
|
||||
|
||||
bool isSpc = cpuType == CpuType::Spc;
|
||||
bool isGb = cpuType == CpuType::Gameboy;
|
||||
bool isDsp = cpuType == CpuType::NecDsp;
|
||||
MemoryMappings *mappings = nullptr;
|
||||
int32_t maxAddr = 0xFFFFFF;
|
||||
switch(cpuType) {
|
||||
|
|
@ -253,17 +180,17 @@ void Disassembler::Disassemble(CpuType cpuType)
|
|||
break;
|
||||
|
||||
case CpuType::Sa1:
|
||||
if(!_console->GetCartridge()->GetSa1()) {
|
||||
if(!_sa1) {
|
||||
return;
|
||||
}
|
||||
mappings = _console->GetCartridge()->GetSa1()->GetMemoryMappings();
|
||||
mappings = _sa1->GetMemoryMappings();
|
||||
break;
|
||||
|
||||
case CpuType::Gsu:
|
||||
if(!_console->GetCartridge()->GetGsu()) {
|
||||
if(!_gsu) {
|
||||
return;
|
||||
}
|
||||
mappings = _console->GetCartridge()->GetGsu()->GetMemoryMappings();
|
||||
mappings = _gsu->GetMemoryMappings();
|
||||
break;
|
||||
|
||||
case CpuType::NecDsp:
|
||||
|
|
@ -271,7 +198,7 @@ void Disassembler::Disassemble(CpuType cpuType)
|
|||
return;
|
||||
}
|
||||
mappings = nullptr;
|
||||
maxAddr = _necDspProgramRomSize - 1;
|
||||
maxAddr = _necDsp->DebugGetProgramRomSize() - 1;
|
||||
break;
|
||||
|
||||
case CpuType::Spc:
|
||||
|
|
@ -297,7 +224,7 @@ void Disassembler::Disassemble(CpuType cpuType)
|
|||
default: throw std::runtime_error("Disassemble(): Invalid cpu type");
|
||||
}
|
||||
|
||||
vector<DisassemblyResult> &results = GetDisassemblyList(cpuType);
|
||||
vector<DisassemblyResult> &results = _disassemblyResult[(int)cpuType];
|
||||
results.clear();
|
||||
|
||||
bool disUnident = _settings->CheckDebuggerFlag(DebuggerFlags::DisassembleUnidentifiedData);
|
||||
|
|
@ -313,16 +240,11 @@ void Disassembler::Disassemble(CpuType cpuType)
|
|||
int byteCounter = 0;
|
||||
for(int32_t i = 0; i <= maxAddr; i++) {
|
||||
prevAddrInfo = addrInfo;
|
||||
if(isDsp) {
|
||||
addrInfo = { i, SnesMemoryType::DspProgramRom };
|
||||
} else {
|
||||
if(isGb) {
|
||||
addrInfo = _gameboy->GetAbsoluteAddress(i);
|
||||
} else if(isSpc) {
|
||||
addrInfo = _spc->GetAbsoluteAddress(i);
|
||||
} else {
|
||||
addrInfo = mappings->GetAbsoluteAddress(i);
|
||||
}
|
||||
switch(cpuType) {
|
||||
case CpuType::Spc: addrInfo = _spc->GetAbsoluteAddress(i); break;
|
||||
case CpuType::NecDsp: addrInfo = { i, SnesMemoryType::DspProgramRom }; break;
|
||||
case CpuType::Gameboy: addrInfo = _gameboy->GetAbsoluteAddress(i); break;
|
||||
default: addrInfo = mappings->GetAbsoluteAddress(i); break;
|
||||
}
|
||||
|
||||
if(addrInfo.Address < 0) {
|
||||
|
|
@ -452,21 +374,7 @@ void Disassembler::Disassemble(CpuType cpuType)
|
|||
|
||||
DisassemblyInfo Disassembler::GetDisassemblyInfo(AddressInfo &info, uint32_t cpuAddress, uint8_t cpuFlags, CpuType type)
|
||||
{
|
||||
DisassemblyInfo disassemblyInfo;
|
||||
switch(info.Type) {
|
||||
default: break;
|
||||
case SnesMemoryType::PrgRom: disassemblyInfo = _prgCache[info.Address]; break;
|
||||
case SnesMemoryType::WorkRam: disassemblyInfo = _wramCache[info.Address]; break;
|
||||
case SnesMemoryType::SaveRam: disassemblyInfo = _sramCache[info.Address]; break;
|
||||
case SnesMemoryType::SpcRam: disassemblyInfo = _spcRamCache[info.Address]; break;
|
||||
case SnesMemoryType::SpcRom: disassemblyInfo = _spcRomCache[info.Address]; break;
|
||||
case SnesMemoryType::DspProgramRom: disassemblyInfo = _necDspRomCache[info.Address]; break;
|
||||
case SnesMemoryType::Sa1InternalRam: disassemblyInfo = _sa1InternalRamCache[info.Address]; break;
|
||||
case SnesMemoryType::GbPrgRom: disassemblyInfo = _gbPrgCache[info.Address]; break;
|
||||
case SnesMemoryType::GbWorkRam: disassemblyInfo = _gbWorkRamCache[info.Address]; break;
|
||||
case SnesMemoryType::GbCartRam: disassemblyInfo = _gbCartRamCache[info.Address]; break;
|
||||
}
|
||||
|
||||
DisassemblyInfo disassemblyInfo = (*GetSource(info.Type).Cache)[info.Address];
|
||||
if(!disassemblyInfo.IsInitialized()) {
|
||||
disassemblyInfo.Initialize(cpuAddress, cpuFlags, type, _memoryDumper);
|
||||
}
|
||||
|
|
@ -483,14 +391,14 @@ void Disassembler::RefreshDisassembly(CpuType type)
|
|||
uint32_t Disassembler::GetLineCount(CpuType type)
|
||||
{
|
||||
auto lock = _disassemblyLock.AcquireSafe();
|
||||
vector<DisassemblyResult> &source = GetDisassemblyList(type);
|
||||
vector<DisassemblyResult>& source = _disassemblyResult[(int)type];
|
||||
return (uint32_t)source.size();
|
||||
}
|
||||
|
||||
uint32_t Disassembler::GetLineIndex(CpuType type, uint32_t cpuAddress)
|
||||
{
|
||||
auto lock = _disassemblyLock.AcquireSafe();
|
||||
vector<DisassemblyResult> &source = GetDisassemblyList(type);
|
||||
vector<DisassemblyResult>& source = _disassemblyResult[(int)type];
|
||||
uint32_t lastAddress = 0;
|
||||
for(size_t i = 1; i < source.size(); i++) {
|
||||
if(source[i].CpuAddress < 0 || (source[i].Flags & LineFlags::SubStart) | (source[i].Flags & LineFlags::Label) || ((source[i].Flags & LineFlags::Comment) && source[i].CommentLine >= 0)) {
|
||||
|
|
@ -512,7 +420,7 @@ bool Disassembler::GetLineData(CpuType type, uint32_t lineIndex, CodeLineData &d
|
|||
{
|
||||
auto lock =_disassemblyLock.AcquireSafe();
|
||||
|
||||
vector<DisassemblyResult> &source = GetDisassemblyList(type);
|
||||
vector<DisassemblyResult>& source = _disassemblyResult[(int)type];
|
||||
SnesMemoryType memType = DebugUtilities::GetCpuMemoryType(type);
|
||||
int32_t maxAddr = type == CpuType::Spc ? 0xFFFF : 0xFFFFFF;
|
||||
if(lineIndex < source.size()) {
|
||||
|
|
@ -695,7 +603,7 @@ bool Disassembler::GetLineData(CpuType type, uint32_t lineIndex, CodeLineData &d
|
|||
int32_t Disassembler::SearchDisassembly(CpuType type, const char *searchString, int32_t startPosition, int32_t endPosition, bool searchBackwards)
|
||||
{
|
||||
auto lock = _disassemblyLock.AcquireSafe();
|
||||
vector<DisassemblyResult> &source = GetDisassemblyList(type);
|
||||
vector<DisassemblyResult>& source = _disassemblyResult[(int)type];
|
||||
int step = searchBackwards ? -1 : 1;
|
||||
CodeLineData lineData = {};
|
||||
for(int i = startPosition; i != endPosition; i += step) {
|
||||
|
|
|
|||
|
|
@ -11,6 +11,8 @@ class Cpu;
|
|||
class Spc;
|
||||
class Gsu;
|
||||
class Sa1;
|
||||
class Cx4;
|
||||
class NecDsp;
|
||||
class Gameboy;
|
||||
class Debugger;
|
||||
class LabelManager;
|
||||
|
|
@ -36,6 +38,8 @@ private:
|
|||
Spc* _spc;
|
||||
Gsu* _gsu;
|
||||
Sa1* _sa1;
|
||||
Cx4* _cx4;
|
||||
NecDsp* _necDsp;
|
||||
Gameboy* _gameboy;
|
||||
EmuSettings* _settings;
|
||||
Debugger *_debugger;
|
||||
|
|
@ -43,74 +47,15 @@ private:
|
|||
shared_ptr<LabelManager> _labelManager;
|
||||
MemoryDumper *_memoryDumper;
|
||||
|
||||
vector<DisassemblyInfo> _prgCache;
|
||||
vector<DisassemblyInfo> _wramCache;
|
||||
vector<DisassemblyInfo> _sramCache;
|
||||
vector<DisassemblyInfo> _spcRamCache;
|
||||
vector<DisassemblyInfo> _spcRomCache;
|
||||
vector<DisassemblyInfo> _necDspRomCache;
|
||||
vector<DisassemblyInfo> _sa1InternalRamCache;
|
||||
vector<DisassemblyInfo> _gsuWorkRamCache;
|
||||
vector<DisassemblyInfo> _bsxPsRamCache;
|
||||
vector<DisassemblyInfo> _bsxMemPackCache;
|
||||
|
||||
vector<DisassemblyInfo> _gbPrgCache;
|
||||
vector<DisassemblyInfo> _gbWorkRamCache;
|
||||
vector<DisassemblyInfo> _gbCartRamCache;
|
||||
vector<DisassemblyInfo> _gbHighRamCache;
|
||||
vector<DisassemblyInfo> _gbBootRomCache;
|
||||
|
||||
DisassemblerSource _sources[(int)SnesMemoryType::Register] = {};
|
||||
vector<DisassemblyInfo> _disassemblyCache[(int)SnesMemoryType::Register];
|
||||
|
||||
SimpleLock _disassemblyLock;
|
||||
vector<DisassemblyResult> _disassembly;
|
||||
vector<DisassemblyResult> _spcDisassembly;
|
||||
vector<DisassemblyResult> _sa1Disassembly;
|
||||
vector<DisassemblyResult> _gsuDisassembly;
|
||||
vector<DisassemblyResult> _necDspDisassembly;
|
||||
vector<DisassemblyResult> _cx4Disassembly;
|
||||
vector<DisassemblyResult> _gbDisassembly;
|
||||
|
||||
DisassemblerSource _sources[(int)SnesMemoryType::Register];
|
||||
|
||||
vector<DisassemblyResult> _disassemblyResult[(int)DebugUtilities::GetLastCpuType()+1];
|
||||
bool _needDisassemble[(int)DebugUtilities::GetLastCpuType()+1];
|
||||
|
||||
uint8_t *_prgRom;
|
||||
uint32_t _prgRomSize;
|
||||
uint8_t *_wram;
|
||||
uint32_t _wramSize;
|
||||
uint8_t *_sram;
|
||||
uint32_t _sramSize;
|
||||
uint8_t *_spcRam;
|
||||
uint32_t _spcRamSize;
|
||||
uint8_t *_spcRom;
|
||||
uint32_t _spcRomSize;
|
||||
|
||||
uint8_t *_necDspProgramRom;
|
||||
uint32_t _necDspProgramRomSize;
|
||||
|
||||
uint8_t *_sa1InternalRam;
|
||||
uint32_t _sa1InternalRamSize;
|
||||
|
||||
uint8_t *_gsuWorkRam;
|
||||
uint32_t _gsuWorkRamSize;
|
||||
|
||||
uint8_t* _bsxPsRam;
|
||||
uint32_t _bsxPsRamSize;
|
||||
uint8_t* _bsxMemPack;
|
||||
uint32_t _bsxMemPackSize;
|
||||
|
||||
uint8_t* _gbPrgRom;
|
||||
uint32_t _gbPrgRomSize;
|
||||
uint8_t* _gbWorkRam;
|
||||
uint32_t _gbWorkRamSize;
|
||||
uint8_t* _gbCartRam;
|
||||
uint32_t _gbCartRamSize;
|
||||
uint8_t* _gbHighRam;
|
||||
uint32_t _gbHighRamSize;
|
||||
uint8_t* _gbBootRom;
|
||||
uint32_t _gbBootRomSize;
|
||||
|
||||
void InitSource(SnesMemoryType type);
|
||||
DisassemblerSource& GetSource(SnesMemoryType type);
|
||||
vector<DisassemblyResult>& GetDisassemblyList(CpuType type);
|
||||
void SetDisassembleFlag(CpuType type);
|
||||
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -35,34 +35,34 @@ void MemoryDumper::SetMemoryState(SnesMemoryType type, uint8_t *buffer, uint32_t
|
|||
return;
|
||||
}
|
||||
|
||||
uint8_t* dst = GetMemoryBuffer(type);
|
||||
if(dst) {
|
||||
memcpy(dst, buffer, length);
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t* MemoryDumper::GetMemoryBuffer(SnesMemoryType type)
|
||||
{
|
||||
switch(type) {
|
||||
default:
|
||||
case SnesMemoryType::CpuMemory:
|
||||
case SnesMemoryType::SpcMemory:
|
||||
case SnesMemoryType::Sa1Memory:
|
||||
case SnesMemoryType::GsuMemory:
|
||||
case SnesMemoryType::Cx4Memory:
|
||||
case SnesMemoryType::GameboyMemory:
|
||||
break;
|
||||
|
||||
case SnesMemoryType::PrgRom: memcpy(_cartridge->DebugGetPrgRom(), buffer, length); break;
|
||||
case SnesMemoryType::WorkRam: memcpy(_memoryManager->DebugGetWorkRam(), buffer, length); break;
|
||||
case SnesMemoryType::SaveRam: memcpy(_cartridge->DebugGetSaveRam(), buffer, length); break;
|
||||
case SnesMemoryType::VideoRam: memcpy(_ppu->GetVideoRam(), buffer, length); break;
|
||||
case SnesMemoryType::SpriteRam: memcpy(_ppu->GetSpriteRam(), buffer, length); break;
|
||||
case SnesMemoryType::CGRam: memcpy(_ppu->GetCgRam(), buffer, length); break;
|
||||
case SnesMemoryType::SpcRam: memcpy(_spc->GetSpcRam(), buffer, length); break;
|
||||
case SnesMemoryType::SpcRom: memcpy(_spc->GetSpcRom(), buffer, length); break;
|
||||
default: return nullptr;
|
||||
case SnesMemoryType::PrgRom: return _cartridge->DebugGetPrgRom();
|
||||
case SnesMemoryType::WorkRam: return _memoryManager->DebugGetWorkRam();
|
||||
case SnesMemoryType::SaveRam: return _cartridge->DebugGetSaveRam();
|
||||
case SnesMemoryType::VideoRam: return _ppu->GetVideoRam();
|
||||
case SnesMemoryType::SpriteRam: return _ppu->GetSpriteRam();
|
||||
case SnesMemoryType::CGRam: return _ppu->GetCgRam();
|
||||
case SnesMemoryType::SpcRam: return _spc->GetSpcRam();
|
||||
case SnesMemoryType::SpcRom: return _spc->GetSpcRom();
|
||||
|
||||
case SnesMemoryType::DspProgramRom: memcpy(_cartridge->GetDsp()->DebugGetProgramRom(), buffer, length); _cartridge->GetDsp()->BuildProgramCache(); break;
|
||||
case SnesMemoryType::DspDataRom: memcpy(_cartridge->GetDsp()->DebugGetDataRom(), buffer, length); break;
|
||||
case SnesMemoryType::DspDataRam: memcpy(_cartridge->GetDsp()->DebugGetDataRam(), buffer, length); break;
|
||||
case SnesMemoryType::DspProgramRom: return _cartridge->GetDsp() ? _cartridge->GetDsp()->DebugGetProgramRom() : nullptr;
|
||||
case SnesMemoryType::DspDataRom: return _cartridge->GetDsp() ? _cartridge->GetDsp()->DebugGetDataRom() : nullptr;
|
||||
case SnesMemoryType::DspDataRam: return _cartridge->GetDsp() ? _cartridge->GetDsp()->DebugGetDataRam() : nullptr;
|
||||
|
||||
case SnesMemoryType::Sa1InternalRam: memcpy(_cartridge->GetSa1()->DebugGetInternalRam(), buffer, length); break;
|
||||
case SnesMemoryType::GsuWorkRam: memcpy(_cartridge->GetGsu()->DebugGetWorkRam(), buffer, length); break;
|
||||
case SnesMemoryType::Cx4DataRam: memcpy(_cartridge->GetCx4()->DebugGetDataRam(), buffer, length); break;
|
||||
case SnesMemoryType::BsxPsRam: memcpy(_cartridge->GetBsx()->DebugGetPsRam(), buffer, length); break;
|
||||
case SnesMemoryType::BsxMemoryPack: memcpy(_cartridge->GetBsxMemoryPack()->DebugGetMemoryPack(), buffer, length); break;
|
||||
case SnesMemoryType::Sa1InternalRam: return _cartridge->GetSa1() ? _cartridge->GetSa1()->DebugGetInternalRam() : nullptr;
|
||||
case SnesMemoryType::GsuWorkRam: return _cartridge->GetGsu() ? _cartridge->GetGsu()->DebugGetWorkRam() : nullptr;
|
||||
case SnesMemoryType::Cx4DataRam: return _cartridge->GetCx4() ? _cartridge->GetCx4()->DebugGetDataRam() : nullptr;
|
||||
case SnesMemoryType::BsxPsRam: return _cartridge->GetBsx() ? _cartridge->GetBsx()->DebugGetPsRam() : nullptr;
|
||||
case SnesMemoryType::BsxMemoryPack: return _cartridge->GetBsxMemoryPack() ? _cartridge->GetBsxMemoryPack()->DebugGetMemoryPack() : nullptr;
|
||||
|
||||
case SnesMemoryType::GbPrgRom:
|
||||
case SnesMemoryType::GbWorkRam:
|
||||
|
|
@ -71,11 +71,7 @@ void MemoryDumper::SetMemoryState(SnesMemoryType type, uint8_t *buffer, uint32_t
|
|||
case SnesMemoryType::GbHighRam:
|
||||
case SnesMemoryType::GbBootRom:
|
||||
case SnesMemoryType::GbSpriteRam:
|
||||
if(_cartridge->GetGameboy()) {
|
||||
memcpy(_cartridge->GetGameboy()->DebugGetMemory(type), buffer, length);
|
||||
}
|
||||
break;
|
||||
|
||||
return _cartridge->GetGameboy() ? _cartridge->GetGameboy()->DebugGetMemory(type) : nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -123,8 +119,6 @@ uint32_t MemoryDumper::GetMemorySize(SnesMemoryType type)
|
|||
void MemoryDumper::GetMemoryState(SnesMemoryType type, uint8_t *buffer)
|
||||
{
|
||||
switch(type) {
|
||||
default: break;
|
||||
|
||||
case SnesMemoryType::CpuMemory:
|
||||
for(int i = 0; i <= 0xFFFFFF; i+=0x1000) {
|
||||
_memoryManager->PeekBlock(i, buffer+i);
|
||||
|
|
@ -171,34 +165,10 @@ void MemoryDumper::GetMemoryState(SnesMemoryType type, uint8_t *buffer)
|
|||
break;
|
||||
}
|
||||
|
||||
case SnesMemoryType::PrgRom: memcpy(buffer, _cartridge->DebugGetPrgRom(), _cartridge->DebugGetPrgRomSize()); break;
|
||||
case SnesMemoryType::WorkRam: memcpy(buffer, _memoryManager->DebugGetWorkRam(), MemoryManager::WorkRamSize); break;
|
||||
case SnesMemoryType::SaveRam: memcpy(buffer, _cartridge->DebugGetSaveRam(), _cartridge->DebugGetSaveRamSize()); break;
|
||||
case SnesMemoryType::VideoRam: memcpy(buffer, _ppu->GetVideoRam(), Ppu::VideoRamSize); break;
|
||||
case SnesMemoryType::SpriteRam: memcpy(buffer, _ppu->GetSpriteRam(), Ppu::SpriteRamSize); break;
|
||||
case SnesMemoryType::CGRam: memcpy(buffer, _ppu->GetCgRam(), Ppu::CgRamSize); break;
|
||||
case SnesMemoryType::SpcRam: memcpy(buffer, _spc->GetSpcRam(), Spc::SpcRamSize); break;
|
||||
case SnesMemoryType::SpcRom: memcpy(buffer, _spc->GetSpcRom(), Spc::SpcRomSize); break;
|
||||
|
||||
case SnesMemoryType::DspProgramRom: memcpy(buffer, _cartridge->GetDsp()->DebugGetProgramRom(), _cartridge->GetDsp()->DebugGetProgramRomSize()); break;
|
||||
case SnesMemoryType::DspDataRom: memcpy(buffer, _cartridge->GetDsp()->DebugGetDataRom(), _cartridge->GetDsp()->DebugGetDataRomSize()); break;
|
||||
case SnesMemoryType::DspDataRam: memcpy(buffer, _cartridge->GetDsp()->DebugGetDataRam(), _cartridge->GetDsp()->DebugGetDataRamSize()); break;
|
||||
|
||||
case SnesMemoryType::Sa1InternalRam: memcpy(buffer, _cartridge->GetSa1()->DebugGetInternalRam(), _cartridge->GetSa1()->DebugGetInternalRamSize()); break;
|
||||
case SnesMemoryType::GsuWorkRam: memcpy(buffer, _cartridge->GetGsu()->DebugGetWorkRam(), _cartridge->GetGsu()->DebugGetWorkRamSize()); break;
|
||||
case SnesMemoryType::Cx4DataRam: memcpy(buffer, _cartridge->GetCx4()->DebugGetDataRam(), _cartridge->GetCx4()->DebugGetDataRamSize()); break;
|
||||
case SnesMemoryType::BsxPsRam: memcpy(buffer, _cartridge->GetBsx()->DebugGetPsRam(), _cartridge->GetBsx()->DebugGetPsRamSize()); break;
|
||||
case SnesMemoryType::BsxMemoryPack: memcpy(buffer, _cartridge->GetBsxMemoryPack()->DebugGetMemoryPack(), _cartridge->GetBsxMemoryPack()->DebugGetMemoryPackSize()); break;
|
||||
|
||||
case SnesMemoryType::GbPrgRom:
|
||||
case SnesMemoryType::GbWorkRam:
|
||||
case SnesMemoryType::GbVideoRam:
|
||||
case SnesMemoryType::GbCartRam:
|
||||
case SnesMemoryType::GbHighRam:
|
||||
case SnesMemoryType::GbBootRom:
|
||||
case SnesMemoryType::GbSpriteRam:
|
||||
if(_cartridge->GetGameboy()) {
|
||||
memcpy(buffer, _cartridge->GetGameboy()->DebugGetMemory(type), _cartridge->GetGameboy()->DebugGetMemorySize(type));
|
||||
default:
|
||||
uint8_t* src = GetMemoryBuffer(type);
|
||||
if(src) {
|
||||
memcpy(buffer, src, GetMemorySize(type));
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
@ -233,8 +203,6 @@ void MemoryDumper::SetMemoryValue(SnesMemoryType memoryType, uint32_t address, u
|
|||
};
|
||||
|
||||
switch(memoryType) {
|
||||
default: break;
|
||||
|
||||
case SnesMemoryType::CpuMemory: _memoryManager->GetMemoryMappings()->DebugWrite(address, value); break;
|
||||
case SnesMemoryType::SpcMemory: _spc->DebugWrite(address, value); break;
|
||||
case SnesMemoryType::Sa1Memory: _cartridge->GetSa1()->GetMemoryMappings()->DebugWrite(address, value); break;
|
||||
|
|
@ -242,35 +210,11 @@ void MemoryDumper::SetMemoryValue(SnesMemoryType memoryType, uint32_t address, u
|
|||
case SnesMemoryType::Cx4Memory: _cartridge->GetCx4()->GetMemoryMappings()->DebugWrite(address, value); break;
|
||||
case SnesMemoryType::GameboyMemory: _cartridge->GetGameboy()->GetMemoryManager()->DebugWrite(address, value); break;
|
||||
|
||||
case SnesMemoryType::PrgRom: _cartridge->DebugGetPrgRom()[address] = value; invalidateCache(); break;
|
||||
case SnesMemoryType::WorkRam: _memoryManager->DebugGetWorkRam()[address] = value; invalidateCache(); break;
|
||||
case SnesMemoryType::SaveRam: _cartridge->DebugGetSaveRam()[address] = value; invalidateCache(); break;
|
||||
|
||||
case SnesMemoryType::VideoRam: _ppu->GetVideoRam()[address] = value; break;
|
||||
case SnesMemoryType::SpriteRam: _ppu->GetSpriteRam()[address] = value; break;
|
||||
case SnesMemoryType::CGRam: _ppu->GetCgRam()[address] = value; break;
|
||||
case SnesMemoryType::SpcRam: _spc->GetSpcRam()[address] = value; invalidateCache(); break;
|
||||
case SnesMemoryType::SpcRom: _spc->GetSpcRom()[address] = value; invalidateCache(); break;
|
||||
|
||||
case SnesMemoryType::DspProgramRom: _cartridge->GetDsp()->DebugGetProgramRom()[address] = value; _cartridge->GetDsp()->BuildProgramCache(); break;
|
||||
case SnesMemoryType::DspDataRom: _cartridge->GetDsp()->DebugGetDataRom()[address] = value; break;
|
||||
case SnesMemoryType::DspDataRam: _cartridge->GetDsp()->DebugGetDataRam()[address] = value; break;
|
||||
|
||||
case SnesMemoryType::Sa1InternalRam: _cartridge->GetSa1()->DebugGetInternalRam()[address] = value; invalidateCache(); break;
|
||||
case SnesMemoryType::GsuWorkRam: _cartridge->GetGsu()->DebugGetWorkRam()[address] = value; invalidateCache(); break;
|
||||
case SnesMemoryType::Cx4DataRam: _cartridge->GetCx4()->DebugGetDataRam()[address] = value; break;
|
||||
case SnesMemoryType::BsxPsRam: _cartridge->GetBsx()->DebugGetPsRam()[address] = value; break;
|
||||
case SnesMemoryType::BsxMemoryPack: _cartridge->GetBsxMemoryPack()->DebugGetMemoryPack()[address] = value; break;
|
||||
|
||||
case SnesMemoryType::GbPrgRom:
|
||||
case SnesMemoryType::GbWorkRam:
|
||||
case SnesMemoryType::GbVideoRam:
|
||||
case SnesMemoryType::GbCartRam:
|
||||
case SnesMemoryType::GbHighRam:
|
||||
case SnesMemoryType::GbBootRom:
|
||||
case SnesMemoryType::GbSpriteRam:
|
||||
if(_cartridge->GetGameboy()) {
|
||||
_cartridge->GetGameboy()->DebugGetMemory(memoryType)[address] = value;
|
||||
default:
|
||||
uint8_t* src = GetMemoryBuffer(memoryType);
|
||||
if(src) {
|
||||
src[address] = value;
|
||||
invalidateCache();
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
@ -283,43 +227,16 @@ uint8_t MemoryDumper::GetMemoryValue(SnesMemoryType memoryType, uint32_t address
|
|||
}
|
||||
|
||||
switch(memoryType) {
|
||||
default: return 0;
|
||||
|
||||
case SnesMemoryType::CpuMemory: return _memoryManager->Peek(address);
|
||||
case SnesMemoryType::SpcMemory: return _spc->DebugRead(address);
|
||||
case SnesMemoryType::Sa1Memory: return _cartridge->GetSa1()->GetMemoryMappings()->Peek(address);
|
||||
case SnesMemoryType::GsuMemory: return _cartridge->GetGsu()->GetMemoryMappings()->Peek(address);
|
||||
case SnesMemoryType::Cx4Memory: return _cartridge->GetCx4()->GetMemoryMappings()->Peek(address);
|
||||
case SnesMemoryType::GameboyMemory: return _cartridge->GetGameboy()->GetMemoryManager()->DebugRead(address);
|
||||
|
||||
case SnesMemoryType::PrgRom: return _cartridge->DebugGetPrgRom()[address];
|
||||
case SnesMemoryType::WorkRam: return _memoryManager->DebugGetWorkRam()[address];
|
||||
case SnesMemoryType::SaveRam: return _cartridge->DebugGetSaveRam()[address];
|
||||
|
||||
case SnesMemoryType::VideoRam: return _ppu->GetVideoRam()[address];
|
||||
case SnesMemoryType::SpriteRam: return _ppu->GetSpriteRam()[address];
|
||||
case SnesMemoryType::CGRam: return _ppu->GetCgRam()[address];
|
||||
case SnesMemoryType::SpcRam: return _spc->GetSpcRam()[address];
|
||||
case SnesMemoryType::SpcRom: return _spc->GetSpcRom()[address];
|
||||
|
||||
case SnesMemoryType::DspProgramRom: return _cartridge->GetDsp()->DebugGetProgramRom()[address];
|
||||
case SnesMemoryType::DspDataRom: return _cartridge->GetDsp()->DebugGetDataRom()[address];
|
||||
case SnesMemoryType::DspDataRam: return _cartridge->GetDsp()->DebugGetDataRam()[address];
|
||||
|
||||
case SnesMemoryType::Sa1InternalRam: return _cartridge->GetSa1()->DebugGetInternalRam()[address];
|
||||
case SnesMemoryType::GsuWorkRam: return _cartridge->GetGsu()->DebugGetWorkRam()[address];
|
||||
case SnesMemoryType::Cx4DataRam: return _cartridge->GetCx4()->DebugGetDataRam()[address];
|
||||
case SnesMemoryType::BsxPsRam: return _cartridge->GetBsx()->DebugGetPsRam()[address];
|
||||
case SnesMemoryType::BsxMemoryPack: return _cartridge->GetBsxMemoryPack()->DebugGetMemoryPack()[address];
|
||||
|
||||
case SnesMemoryType::GbPrgRom:
|
||||
case SnesMemoryType::GbWorkRam:
|
||||
case SnesMemoryType::GbVideoRam:
|
||||
case SnesMemoryType::GbCartRam:
|
||||
case SnesMemoryType::GbHighRam:
|
||||
case SnesMemoryType::GbBootRom:
|
||||
case SnesMemoryType::GbSpriteRam:
|
||||
return _cartridge->GetGameboy() ? _cartridge->GetGameboy()->DebugGetMemory(memoryType)[address] : 0;
|
||||
default:
|
||||
uint8_t* src = GetMemoryBuffer(memoryType);
|
||||
return src ? src[address] : 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ private:
|
|||
public:
|
||||
MemoryDumper(Debugger* debugger);
|
||||
|
||||
uint8_t* GetMemoryBuffer(SnesMemoryType type);
|
||||
uint32_t GetMemorySize(SnesMemoryType type);
|
||||
void GetMemoryState(SnesMemoryType type, uint8_t *buffer);
|
||||
|
||||
|
|
|
|||
|
|
@ -154,6 +154,31 @@ namespace Mesen.GUI.Debugger
|
|||
}
|
||||
}
|
||||
|
||||
public static void CloseWindows(CoprocessorType coprocessorType)
|
||||
{
|
||||
if(coprocessorType != CoprocessorType.CX4) {
|
||||
CloseWindows(CpuType.Cx4);
|
||||
}
|
||||
if(coprocessorType != CoprocessorType.GSU) {
|
||||
CloseWindows(CpuType.Gsu);
|
||||
}
|
||||
if(coprocessorType != CoprocessorType.SA1) {
|
||||
CloseWindows(CpuType.Sa1);
|
||||
}
|
||||
if(coprocessorType < CoprocessorType.DSP1 && coprocessorType > CoprocessorType.DSP4 && coprocessorType != CoprocessorType.ST010 && coprocessorType != CoprocessorType.ST011) {
|
||||
CloseWindows(CpuType.NecDsp);
|
||||
}
|
||||
|
||||
if(coprocessorType == CoprocessorType.Gameboy) {
|
||||
CloseWindows(CpuType.Cpu);
|
||||
CloseWindows(CpuType.Spc);
|
||||
}
|
||||
|
||||
if(coprocessorType != CoprocessorType.Gameboy && coprocessorType != CoprocessorType.SGB) {
|
||||
CloseWindows(CpuType.Gameboy);
|
||||
}
|
||||
}
|
||||
|
||||
public static void CloseAll()
|
||||
{
|
||||
List<Form> openedWindows = new List<Form>(_openedWindows);
|
||||
|
|
|
|||
|
|
@ -160,11 +160,7 @@ namespace Mesen.GUI.Forms
|
|||
RomInfo romInfo = EmuApi.GetRomInfo();
|
||||
|
||||
this.Invoke((Action)(() => {
|
||||
if(romInfo.CoprocessorType == CoprocessorType.Gameboy) {
|
||||
DebugWindowManager.CloseWindows(CpuType.Cpu);
|
||||
} else if(romInfo.CoprocessorType != CoprocessorType.SGB) {
|
||||
DebugWindowManager.CloseWindows(CpuType.Gameboy);
|
||||
}
|
||||
DebugWindowManager.CloseWindows(romInfo.CoprocessorType);
|
||||
}));
|
||||
|
||||
Task.Run(() => {
|
||||
|
|
|
|||
Loading…
Reference in a new issue