empathicqubit/Mesen-SX
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Debugger: Greatly reduced memory usage when debugger tools are opened

Browse source
This commit is contained in:
Sour 2019-04-05 00:02:43 -04:00
parent 02fa095a91
commit b1d1a3f466
5 changed files with 56 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

74
Core/Disassembler.cpp
View file

@ -23,12 +23,12 @@ Disassembler::Disassembler(shared_ptr<Console> console, shared_ptr<CodeDataLogge
_wram = _memoryManager->DebugGetWorkRam(); _wram = _memoryManager->DebugGetWorkRam();
_wramSize = MemoryManager::WorkRamSize; _wramSize = MemoryManager::WorkRamSize;
_prgCache = vector<shared_ptr<DisassemblyInfo>>(_prgRomSize); _prgCache = vector<DisassemblyInfo>(_prgRomSize);
_sramCache = vector<shared_ptr<DisassemblyInfo>>(_sramSize); _sramCache = vector<DisassemblyInfo>(_sramSize);
_wramCache = vector<shared_ptr<DisassemblyInfo>>(_wramSize); _wramCache = vector<DisassemblyInfo>(_wramSize);
} }
void Disassembler::GetSource(AddressInfo &info, uint8_t **source, uint32_t &size, vector<shared_ptr<DisassemblyInfo>> **cache) void Disassembler::GetSource(AddressInfo &info, uint8_t **source, uint32_t &size, vector<DisassemblyInfo> **cache)
{ {
switch(info.Type) { switch(info.Type) {
case SnesMemoryType::PrgRom: case SnesMemoryType::PrgRom:
@ -58,18 +58,18 @@ uint32_t Disassembler::BuildCache(AddressInfo &addrInfo, uint8_t cpuFlags)
{ {
uint8_t *source; uint8_t *source;
uint32_t sourceLength; uint32_t sourceLength;
vector<shared_ptr<DisassemblyInfo>> *cache; vector<DisassemblyInfo> *cache;
GetSource(addrInfo, &source, sourceLength, &cache); GetSource(addrInfo, &source, sourceLength, &cache);
if(addrInfo.Address >= 0) { if(addrInfo.Address >= 0) {
DisassemblyInfo *disInfo = (*cache)[addrInfo.Address].get(); DisassemblyInfo disInfo = (*cache)[addrInfo.Address];
if(!disInfo) { if(!disInfo.IsInitialized()) {
shared_ptr<DisassemblyInfo> disassemblyInfo(new DisassemblyInfo(source+addrInfo.Address, cpuFlags)); DisassemblyInfo disassemblyInfo(source+addrInfo.Address, cpuFlags);
(*cache)[addrInfo.Address] = disassemblyInfo; (*cache)[addrInfo.Address] = disassemblyInfo;
_needDisassemble = true; _needDisassemble = true;
disInfo = disassemblyInfo.get(); disInfo = disassemblyInfo;
} }
return disInfo->GetOperandSize() + 1; return disInfo.GetOperandSize() + 1;
} }
return 0; return 0;
} }
@ -78,15 +78,15 @@ void Disassembler::InvalidateCache(AddressInfo addrInfo)
{ {
uint8_t *source; uint8_t *source;
uint32_t sourceLength; uint32_t sourceLength;
vector<shared_ptr<DisassemblyInfo>> *cache; vector<DisassemblyInfo> *cache;
GetSource(addrInfo, &source, sourceLength, &cache); GetSource(addrInfo, &source, sourceLength, &cache);
if(addrInfo.Address >= 0) { if(addrInfo.Address >= 0) {
for(int i = 0; i < 4; i++) { for(int i = 0; i < 4; i++) {
if(addrInfo.Address >= i) { if(addrInfo.Address >= i) {
if((*cache)[addrInfo.Address - i]) { if((*cache)[addrInfo.Address - i].IsInitialized()) {
_needDisassemble = true; _needDisassemble = true;
(*cache)[addrInfo.Address - i].reset(); (*cache)[addrInfo.Address - i].Reset();
} }
} }
} }
@ -107,13 +107,11 @@ void Disassembler::Disassemble()
uint8_t *source; uint8_t *source;
uint32_t sourceLength; uint32_t sourceLength;
vector<shared_ptr<DisassemblyInfo>> *cache; vector<DisassemblyInfo> *cache;
bool disassembleAll = false; bool disassembleAll = false;
bool inUnknownBlock = false; bool inUnknownBlock = false;
shared_ptr<DisassemblyInfo> disassemblyInfo;
shared_ptr<DisassemblyInfo> tmpInfo(new DisassemblyInfo());
AddressInfo addrInfo = {}; AddressInfo addrInfo = {};
AddressInfo prevAddrInfo = {}; AddressInfo prevAddrInfo = {};
for(int32_t i = 0; i <= 0xFFFFFF; i++) { for(int32_t i = 0; i <= 0xFFFFFF; i++) {
@ -126,19 +124,19 @@ void Disassembler::Disassemble()
GetSource(addrInfo, &source, sourceLength, &cache); GetSource(addrInfo, &source, sourceLength, &cache);
DisassemblyInfo *disassemblyInfo = (*cache)[addrInfo.Address].get(); DisassemblyInfo disassemblyInfo = (*cache)[addrInfo.Address];
uint8_t opSize = 0; uint8_t opSize = 0;
uint8_t opCode = (source + addrInfo.Address)[0]; uint8_t opCode = (source + addrInfo.Address)[0];
bool needRealign = true; bool needRealign = true;
if(!disassemblyInfo && disassembleAll) { if(!disassemblyInfo.IsInitialized() && disassembleAll) {
opSize = DisassemblyInfo::GetOperandSize(opCode, 0); opSize = DisassemblyInfo::GetOperandSize(opCode, 0);
} else if(disassemblyInfo) { } else if(disassemblyInfo.IsInitialized()) {
opSize = disassemblyInfo->GetOperandSize(); opSize = disassemblyInfo.GetOperandSize();
needRealign = false; needRealign = false;
} }
if(disassemblyInfo || disassembleAll) { if(disassemblyInfo.IsInitialized() || disassembleAll) {
if(inUnknownBlock) { if(inUnknownBlock) {
_disassembly.push_back(DisassemblyResult(prevAddrInfo, i - 1, LineFlags::BlockEnd)); _disassembly.push_back(DisassemblyResult(prevAddrInfo, i - 1, LineFlags::BlockEnd));
inUnknownBlock = false; inUnknownBlock = false;
@ -151,7 +149,7 @@ void Disassembler::Disassemble()
_disassembly.push_back(DisassemblyResult(addrInfo, i)); _disassembly.push_back(DisassemblyResult(addrInfo, i));
if(needRealign) { if(needRealign) {
for(int j = 1; j < opSize; j++) { for(int j = 1; j < opSize; j++) {
if((*cache)[addrInfo.Address + j]) { if((*cache)[addrInfo.Address + j].IsInitialized()) {
break; break;
} }
i++; i++;
@ -180,16 +178,16 @@ void Disassembler::Disassemble()
DisassemblyInfo Disassembler::GetDisassemblyInfo(AddressInfo &info) DisassemblyInfo Disassembler::GetDisassemblyInfo(AddressInfo &info)
{ {
DisassemblyInfo* disassemblyInfo = nullptr; DisassemblyInfo disassemblyInfo;
switch(info.Type) { switch(info.Type) {
default: break; default: break;
case SnesMemoryType::PrgRom: disassemblyInfo = _prgCache[info.Address].get(); break; case SnesMemoryType::PrgRom: disassemblyInfo = _prgCache[info.Address]; break;
case SnesMemoryType::WorkRam: disassemblyInfo = _wramCache[info.Address].get(); break; case SnesMemoryType::WorkRam: disassemblyInfo = _wramCache[info.Address]; break;
case SnesMemoryType::SaveRam: disassemblyInfo = _sramCache[info.Address].get(); break; case SnesMemoryType::SaveRam: disassemblyInfo = _sramCache[info.Address]; break;
} }
if(disassemblyInfo) { if(disassemblyInfo.IsInitialized()) {
return *disassemblyInfo; return disassemblyInfo;
} else { } else {
return DisassemblyInfo(); return DisassemblyInfo();
} }
@ -240,10 +238,10 @@ bool Disassembler::GetLineData(uint32_t lineIndex, CodeLineData &data)
bool isBlockStartEnd = (data.Flags & (LineFlags::BlockStart | LineFlags::BlockEnd)) != 0; bool isBlockStartEnd = (data.Flags & (LineFlags::BlockStart | LineFlags::BlockEnd)) != 0;
if(!isBlockStartEnd && result.Address.Address >= 0) { if(!isBlockStartEnd && result.Address.Address >= 0) {
shared_ptr<DisassemblyInfo> disInfo; DisassemblyInfo disInfo;
uint8_t *source; uint8_t *source;
uint32_t sourceLength; uint32_t sourceLength;
vector<shared_ptr<DisassemblyInfo>> *cache; vector<DisassemblyInfo> *cache;
GetSource(result.Address, &source, sourceLength, &cache); GetSource(result.Address, &source, sourceLength, &cache);
disInfo = (*cache)[result.Address.Address]; disInfo = (*cache)[result.Address.Address];
@ -251,26 +249,26 @@ bool Disassembler::GetLineData(uint32_t lineIndex, CodeLineData &data)
state.PC = (uint16_t)result.CpuAddress; state.PC = (uint16_t)result.CpuAddress;
state.K = (result.CpuAddress >> 16); state.K = (result.CpuAddress >> 16);
if(!disInfo) { if(!disInfo.IsInitialized()) {
disInfo.reset(new DisassemblyInfo(source + result.Address.Address, state.PS)); disInfo = DisassemblyInfo(source + result.Address.Address, state.PS);
} else { } else {
data.Flags |= (uint8_t)LineFlags::VerifiedCode; data.Flags |= (uint8_t)LineFlags::VerifiedCode;
} }
string text; string text;
disInfo->GetDisassembly(text, result.CpuAddress); disInfo.GetDisassembly(text, result.CpuAddress);
memcpy(data.Text, text.c_str(), std::min<int>((int)text.size(), 1000)); memcpy(data.Text, text.c_str(), std::min<int>((int)text.size(), 1000));
data.OpSize = disInfo->GetOperandSize() + 1; data.OpSize = disInfo.GetOperandSize() + 1;
data.EffectiveAddress = disInfo->GetEffectiveAddress(state, _console); data.EffectiveAddress = disInfo.GetEffectiveAddress(state, _console);
if(data.EffectiveAddress >= 0) { if(data.EffectiveAddress >= 0) {
data.Value = disInfo->GetMemoryValue(data.EffectiveAddress, _console->GetMemoryManager().get(), data.ValueSize); data.Value = disInfo.GetMemoryValue(data.EffectiveAddress, _console->GetMemoryManager().get(), data.ValueSize);
} else { } else {
data.ValueSize = 0; data.ValueSize = 0;
} }
disInfo->GetByteCode(data.ByteCode); disInfo.GetByteCode(data.ByteCode);
data.Comment[0] = 0; data.Comment[0] = 0;
} else { } else {
if(data.Flags & LineFlags::SubStart) { if(data.Flags & LineFlags::SubStart) {

8
Core/Disassembler.h
View file

@ -16,9 +16,9 @@ private:
Console *_console; Console *_console;
shared_ptr<CodeDataLogger> _cdl; shared_ptr<CodeDataLogger> _cdl;
vector<shared_ptr<DisassemblyInfo>> _prgCache; vector<DisassemblyInfo> _prgCache;
vector<shared_ptr<DisassemblyInfo>> _wramCache; vector<DisassemblyInfo> _wramCache;
vector<shared_ptr<DisassemblyInfo>> _sramCache; vector<DisassemblyInfo> _sramCache;
SimpleLock _disassemblyLock; SimpleLock _disassemblyLock;
vector<DisassemblyResult> _disassembly; vector<DisassemblyResult> _disassembly;
@ -32,7 +32,7 @@ private:
uint8_t *_sram; uint8_t *_sram;
uint32_t _sramSize; uint32_t _sramSize;
void GetSource(AddressInfo &info, uint8_t **source, uint32_t &size, vector<shared_ptr<DisassemblyInfo>> **cache); void GetSource(AddressInfo &info, uint8_t **source, uint32_t &size, vector<DisassemblyInfo> **cache);
public: public:
Disassembler(shared_ptr<Console> console, shared_ptr<CodeDataLogger> cdl); Disassembler(shared_ptr<Console> console, shared_ptr<CodeDataLogger> cdl);

13
Core/DisassemblyInfo.cpp
View file

@ -19,7 +19,6 @@ DisassemblyInfo::DisassemblyInfo(uint8_t *opPointer, uint8_t cpuFlags)
void DisassemblyInfo::Initialize(uint8_t *opPointer, uint8_t cpuFlags) void DisassemblyInfo::Initialize(uint8_t *opPointer, uint8_t cpuFlags)
{ {
_flags = cpuFlags & (ProcFlags::MemoryMode8 | ProcFlags::IndexMode8); _flags = cpuFlags & (ProcFlags::MemoryMode8 | ProcFlags::IndexMode8);
_byteCode[0] = opPointer[0]; _byteCode[0] = opPointer[0];
_addrMode = DisassemblyInfo::OpMode[_byteCode[0]]; _addrMode = DisassemblyInfo::OpMode[_byteCode[0]];
_opSize = GetOperandSize(_addrMode, _flags) + 1; _opSize = GetOperandSize(_addrMode, _flags) + 1;
@ -27,6 +26,18 @@ void DisassemblyInfo::Initialize(uint8_t *opPointer, uint8_t cpuFlags)
for(int i = 1; i < _opSize; i++) { for(int i = 1; i < _opSize; i++) {
_byteCode[i] = opPointer[i]; _byteCode[i] = opPointer[i];
} }
_initialized = true;
}
bool DisassemblyInfo::IsInitialized()
{
return _initialized;
}
void DisassemblyInfo::Reset()
{
_initialized = false;
} }
void DisassemblyInfo::GetDisassembly(string &out, uint32_t memoryAddr) void DisassemblyInfo::GetDisassembly(string &out, uint32_t memoryAddr)

3
Core/DisassemblyInfo.h
View file

@ -19,12 +19,15 @@ private:
uint8_t _opSize; uint8_t _opSize;
AddrMode _addrMode; AddrMode _addrMode;
uint8_t _flags; uint8_t _flags;
bool _initialized = false;
public: public:
DisassemblyInfo(); DisassemblyInfo();
DisassemblyInfo(uint8_t *opPointer, uint8_t cpuFlags); DisassemblyInfo(uint8_t *opPointer, uint8_t cpuFlags);
void Initialize(uint8_t * opPointer, uint8_t cpuFlags); void Initialize(uint8_t * opPointer, uint8_t cpuFlags);
bool IsInitialized();
void Reset();
void GetDisassembly(string &out, uint32_t memoryAddr); void GetDisassembly(string &out, uint32_t memoryAddr);
uint32_t GetOperandAddress(uint32_t memoryAddr); uint32_t GetOperandAddress(uint32_t memoryAddr);

2
Core/MemoryAccessCounter.cpp
View file

@ -10,7 +10,7 @@ MemoryAccessCounter::MemoryAccessCounter(Debugger* debugger, MemoryManager* memo
_debugger = debugger; _debugger = debugger;
_memoryManager = memoryManager; _memoryManager = memoryManager;
for(int i = 0; i < (int)SnesMemoryType::Register; i++) { for(int i = 1; i < (int)SnesMemoryType::Register; i++) {
uint32_t memSize = _debugger->GetMemoryDumper()->GetMemorySize((SnesMemoryType)i); uint32_t memSize = _debugger->GetMemoryDumper()->GetMemorySize((SnesMemoryType)i);
_readCounts[i].insert(_readCounts[i].end(), memSize, 0); _readCounts[i].insert(_readCounts[i].end(), memSize, 0);