From 8ebe0401f75439d1951fade8496a2659ee560803 Mon Sep 17 00:00:00 2001 From: Sour Date: Tue, 7 Jul 2020 21:20:31 -0400 Subject: [PATCH] Debugger: Code refactoring (disassembler) + Fixed some issues when switching between different coprocessors while debug windows are opened --- Core/Debugger.cpp | 13 +-- Core/Debugger.h | 2 - Core/Disassembler.cpp | 158 +++++++---------------------- Core/Disassembler.h | 73 ++------------ Core/MemoryDumper.cpp | 159 +++++++----------------------- Core/MemoryDumper.h | 1 + UI/Debugger/DebugWindowManager.cs | 25 +++++ UI/Forms/frmMain.cs | 6 +- 8 files changed, 112 insertions(+), 325 deletions(-) diff --git a/Core/Debugger.cpp b/Core/Debugger.cpp index 077924c..6d09df2 100644 --- a/Core/Debugger.cpp +++ b/Core/Debugger.cpp @@ -95,8 +95,6 @@ Debugger::Debugger(shared_ptr 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 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: diff --git a/Core/Debugger.h b/Core/Debugger.h index 5a62b00..b3d6ed2 100644 --- a/Core/Debugger.h +++ b/Core/Debugger.h @@ -83,8 +83,6 @@ private: atomic _breakRequestCount; atomic _suspendRequestCount; - unique_ptr _step; - bool _waitForBreakResume = false; void Reset(); diff --git a/Core/Disassembler.cpp b/Core/Disassembler.cpp index 2ec1265..6f1e50d 100644 --- a/Core/Disassembler.cpp +++ b/Core/Disassembler.cpp @@ -39,93 +39,37 @@ Disassembler::Disassembler(shared_ptr console, shared_ptrGetSpc().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(_prgRomSize); - _sramCache = vector(_sramSize); - _wramCache = vector(_wramSize); - _spcRamCache = vector(_spcRamSize); - _spcRomCache = vector(_spcRomSize); - _necDspRomCache = vector(_necDspProgramRomSize); - _sa1InternalRamCache = vector(_sa1InternalRamSize); - _gsuWorkRamCache = vector(_gsuWorkRamSize); - _bsxPsRamCache = vector(_bsxPsRamSize); - _bsxMemPackCache = vector(_bsxMemPackSize); - - _gbPrgCache = vector(_gbPrgRomSize); - _gbWorkRamCache = vector(_gbWorkRamSize); - _gbCartRamCache = vector(_gbCartRamSize); - _gbHighRamCache = vector(_gbHighRamSize); - _gbBootRomCache = vector(_gbBootRomSize); - for(int i = 0; i < (int)DebugUtilities::GetLastCpuType(); i++) { + _disassemblyResult[i] = vector(); _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(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& 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(_prgRomSize); - _gbPrgCache = vector(_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 &results = GetDisassemblyList(cpuType); + vector &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 &source = GetDisassemblyList(type); + vector& source = _disassemblyResult[(int)type]; return (uint32_t)source.size(); } uint32_t Disassembler::GetLineIndex(CpuType type, uint32_t cpuAddress) { auto lock = _disassemblyLock.AcquireSafe(); - vector &source = GetDisassemblyList(type); + vector& 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 &source = GetDisassemblyList(type); + vector& 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 &source = GetDisassemblyList(type); + vector& source = _disassemblyResult[(int)type]; int step = searchBackwards ? -1 : 1; CodeLineData lineData = {}; for(int i = startPosition; i != endPosition; i += step) { diff --git a/Core/Disassembler.h b/Core/Disassembler.h index f1fc10d..a84a092 100644 --- a/Core/Disassembler.h +++ b/Core/Disassembler.h @@ -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; MemoryDumper *_memoryDumper; - vector _prgCache; - vector _wramCache; - vector _sramCache; - vector _spcRamCache; - vector _spcRomCache; - vector _necDspRomCache; - vector _sa1InternalRamCache; - vector _gsuWorkRamCache; - vector _bsxPsRamCache; - vector _bsxMemPackCache; - - vector _gbPrgCache; - vector _gbWorkRamCache; - vector _gbCartRamCache; - vector _gbHighRamCache; - vector _gbBootRomCache; - + DisassemblerSource _sources[(int)SnesMemoryType::Register] = {}; + vector _disassemblyCache[(int)SnesMemoryType::Register]; + SimpleLock _disassemblyLock; - vector _disassembly; - vector _spcDisassembly; - vector _sa1Disassembly; - vector _gsuDisassembly; - vector _necDspDisassembly; - vector _cx4Disassembly; - vector _gbDisassembly; - - DisassemblerSource _sources[(int)SnesMemoryType::Register]; - + vector _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& GetDisassemblyList(CpuType type); void SetDisassembleFlag(CpuType type); public: diff --git a/Core/MemoryDumper.cpp b/Core/MemoryDumper.cpp index cc6e5cc..0d0d48a 100644 --- a/Core/MemoryDumper.cpp +++ b/Core/MemoryDumper.cpp @@ -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; } } diff --git a/Core/MemoryDumper.h b/Core/MemoryDumper.h index 8712e9f..ec95ff3 100644 --- a/Core/MemoryDumper.h +++ b/Core/MemoryDumper.h @@ -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); diff --git a/UI/Debugger/DebugWindowManager.cs b/UI/Debugger/DebugWindowManager.cs index 36b7983..0b40c7c 100644 --- a/UI/Debugger/DebugWindowManager.cs +++ b/UI/Debugger/DebugWindowManager.cs @@ -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
openedWindows = new List(_openedWindows); diff --git a/UI/Forms/frmMain.cs b/UI/Forms/frmMain.cs index b155ebb..dc3fb9b 100644 --- a/UI/Forms/frmMain.cs +++ b/UI/Forms/frmMain.cs @@ -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(() => {