Emulation/Mesen-S
1
0
Fork 0
mirror of https://github.com/SourMesen/Mesen-S.git synced 2024-06-23 06:41:55 -04:00
Code Issues Packages Projects Releases Wiki Activity

Debugger: Fixed display issues in disassembly view for SA-1 debugger

Browse source 
Effective addresses and their values were incorrect
This commit is contained in:
Sour 2020-02-27 19:59:41 -05:00
parent f5fbc87928
commit 28443f84d6
13 changed files with 70 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
Core/Cpu.cpp
View file

@ -9,12 +9,14 @@
#include "Cpu.Instructions.h"
#include "Cpu.Shared.h"
#ifndef DUMMYCPU
Cpu::Cpu(Console *console)
{
_console = console;
_memoryManager = console->GetMemoryManager().get();
_dmaController = console->GetDmaController().get();
}
#endif
Cpu::~Cpu()
{
@ -86,32 +88,24 @@ void Cpu::ProcessCpuCycle()
_state.IrqLock = _dmaController->ProcessPendingTransfers();
}
#ifndef DUMMYCPU
uint8_t Cpu::Read(uint32_t addr, MemoryOperationType type)
{
#ifdef DUMMYCPU
uint8_t value = _memoryManager->Peek(addr);
LogRead(addr, value);
return value;
#else
_memoryManager->SetCpuSpeed(_memoryManager->GetCpuSpeed(addr));
ProcessCpuCycle();
uint8_t value = _memoryManager->Read(addr, type);
UpdateIrqNmiFlags();
return value;
#endif
}
void Cpu::Write(uint32_t addr, uint8_t value, MemoryOperationType type)
{
#ifdef DUMMYCPU
LogWrite(addr, value);
#else
_memoryManager->SetCpuSpeed(_memoryManager->GetCpuSpeed(addr));
ProcessCpuCycle();
_memoryManager->Write(addr, value, type);
UpdateIrqNmiFlags();
#endif
}
#endif
uint16_t Cpu::GetResetVector()
{

7
Core/Cpu.h
View file

@ -9,6 +9,7 @@
#include "CpuTypes.h"
#include "../Utilities/ISerializable.h"
class MemoryMappings;
class MemoryManager;
class DmaController;
class Console;
@ -313,7 +314,12 @@ private:
void RunOp();
public:
#ifndef DUMMYCPU
Cpu(Console *console);
#else
DummyCpu(Console* console, CpuType type);
#endif
virtual ~Cpu();
void PowerOn();
@ -339,6 +345,7 @@ public:
#ifdef DUMMYCPU
private:
MemoryMappings* _memoryMappings;
uint32_t _writeCounter = 0;
uint32_t _writeAddresses[10];
uint8_t _writeValue[10];

4
Core/CpuDisUtils.cpp
View file

@ -104,10 +104,10 @@ uint32_t CpuDisUtils::GetOperandAddress(DisassemblyInfo &info, uint32_t memoryAd
return opAddr;
}
int32_t CpuDisUtils::GetEffectiveAddress(DisassemblyInfo &info, Console *console, CpuState &state)
int32_t CpuDisUtils::GetEffectiveAddress(DisassemblyInfo &info, Console *console, CpuState &state, CpuType type)
{
if(HasEffectiveAddress(CpuDisUtils::OpMode[info.GetOpCode()])) {
DummyCpu cpu(console);
DummyCpu cpu(console, type);
state.PS &= ~(ProcFlags::IndexMode8 | ProcFlags::MemoryMode8);
state.PS |= info.GetFlags();
cpu.SetDummyState(state);

3
Core/CpuDisUtils.h
View file

@ -6,6 +6,7 @@ class Console;
class LabelManager;
class EmuSettings;
struct CpuState;
enum class CpuType : uint8_t;
enum class AddrMode : uint8_t;
class CpuDisUtils
@ -23,7 +24,7 @@ public:
static void GetDisassembly(DisassemblyInfo &info, string &out, uint32_t memoryAddr, LabelManager* labelManager, EmuSettings* settings);
static uint8_t GetOpSize(uint8_t opCode, uint8_t flags);
static int32_t GetEffectiveAddress(DisassemblyInfo &info, Console* console, CpuState &state);
static int32_t GetEffectiveAddress(DisassemblyInfo &info, Console* console, CpuState &state, CpuType type);
};
enum class AddrMode : uint8_t

1
Core/Debugger.cpp
View file

@ -547,6 +547,7 @@ void Debugger::GetCdlData(uint32_t offset, uint32_t length, SnesMemoryType memor
MemoryMappings* mappings = nullptr;
switch(memoryType) {
case SnesMemoryType::CpuMemory: mappings = _memoryManager->GetMemoryMappings(); break;
case SnesMemoryType::Sa1Memory: mappings = _cart->GetSa1()->GetMemoryMappings(); break;
case SnesMemoryType::GsuMemory: mappings = _cart->GetGsu()->GetMemoryMappings(); break;
case SnesMemoryType::Cx4Memory: mappings = _cart->GetCx4()->GetMemoryMappings(); break;
default: throw std::runtime_error("GetCdlData - Unsupported memory type");

14
Core/Disassembler.cpp
View file

@ -33,8 +33,10 @@ Disassembler::Disassembler(shared_ptr<Console> console, shared_ptr<CodeDataLogge
_debugger = debugger;
_labelManager = debugger->GetLabelManager();
_console = console.get();
_cpu = console->GetCpu().get();
_spc = console->GetSpc().get();
_gsu = cart->GetGsu();
_sa1 = cart->GetSa1();
_settings = console->GetSettings().get();
_memoryDumper = _debugger->GetMemoryDumper().get();
_memoryManager = console->GetMemoryManager().get();
@ -510,18 +512,18 @@ bool Disassembler::GetLineData(CpuType type, uint32_t lineIndex, CodeLineData &d
switch(lineCpuType) {
case CpuType::Cpu:
case CpuType::Sa1: {
CpuState state = _console->GetCpu()->GetState();
CpuState state = type == CpuType::Sa1 ? _sa1->GetCpuState() : _cpu->GetState();
state.PC = (uint16_t)result.CpuAddress;
state.K = (result.CpuAddress >> 16);
if(!disInfo.IsInitialized()) {
disInfo = DisassemblyInfo(src.Data + result.Address.Address, state.PS, CpuType::Cpu);
disInfo = DisassemblyInfo(src.Data + result.Address.Address, state.PS, type);
} else {
data.Flags |= (result.Address.Type != SnesMemoryType::PrgRom || _cdl->IsCode(data.AbsoluteAddress)) ? LineFlags::VerifiedCode : LineFlags::UnexecutedCode;
}
data.OpSize = disInfo.GetOpSize();
data.EffectiveAddress = disInfo.GetEffectiveAddress(_console, &state);
data.EffectiveAddress = disInfo.GetEffectiveAddress(_console, &state, type);
if(data.EffectiveAddress >= 0) {
data.Value = disInfo.GetMemoryValue(data.EffectiveAddress, _memoryDumper, memType, data.ValueSize);
@ -542,7 +544,7 @@ bool Disassembler::GetLineData(CpuType type, uint32_t lineIndex, CodeLineData &d
}
data.OpSize = disInfo.GetOpSize();
data.EffectiveAddress = disInfo.GetEffectiveAddress(_console, &state);
data.EffectiveAddress = disInfo.GetEffectiveAddress(_console, &state, lineCpuType);
if(data.EffectiveAddress >= 0) {
data.Value = disInfo.GetMemoryValue(data.EffectiveAddress, _memoryDumper, memType, data.ValueSize);
data.ValueSize = 1;
@ -561,7 +563,7 @@ bool Disassembler::GetLineData(CpuType type, uint32_t lineIndex, CodeLineData &d
}
data.OpSize = disInfo.GetOpSize();
data.EffectiveAddress = disInfo.GetEffectiveAddress(_console, &state);
data.EffectiveAddress = disInfo.GetEffectiveAddress(_console, &state, lineCpuType);
if(data.EffectiveAddress >= 0) {
data.Value = disInfo.GetMemoryValue(data.EffectiveAddress, _memoryDumper, memType, data.ValueSize);
data.ValueSize = 2;
@ -574,7 +576,7 @@ bool Disassembler::GetLineData(CpuType type, uint32_t lineIndex, CodeLineData &d
case CpuType::NecDsp:
case CpuType::Cx4:
if(!disInfo.IsInitialized()) {
disInfo = DisassemblyInfo(src.Data + result.Address.Address, 0, lineCpuType);
disInfo = DisassemblyInfo(src.Data + result.Address.Address, 0, type);
} else {
data.Flags |= LineFlags::VerifiedCode;
}

4
Core/Disassembler.h
View file

@ -7,8 +7,10 @@
class MemoryManager;
class Console;
class Cpu;
class Spc;
class Gsu;
class Sa1;
class Debugger;
class LabelManager;
class CodeDataLogger;
@ -29,8 +31,10 @@ class Disassembler
private:
MemoryManager *_memoryManager;
Console *_console;
Cpu* _cpu;
Spc* _spc;
Gsu* _gsu;
Sa1* _sa1;
EmuSettings* _settings;
Debugger *_debugger;
shared_ptr<CodeDataLogger> _cdl;

4
Core/DisassemblyInfo.cpp
View file

@ -61,12 +61,12 @@ void DisassemblyInfo::GetDisassembly(string &out, uint32_t memoryAddr, LabelMana
}
}
int32_t DisassemblyInfo::GetEffectiveAddress(Console *console, void *cpuState)
int32_t DisassemblyInfo::GetEffectiveAddress(Console *console, void *cpuState, CpuType cpuType)
{
switch(_cpuType) {
case CpuType::Sa1:
case CpuType::Cpu:
return CpuDisUtils::GetEffectiveAddress(*this, console, *(CpuState*)cpuState);
return CpuDisUtils::GetEffectiveAddress(*this, console, *(CpuState*)cpuState, cpuType);
case CpuType::Spc: return SpcDisUtils::GetEffectiveAddress(*this, console, *(SpcState*)cpuState);
case CpuType::Gsu: return GsuDisUtils::GetEffectiveAddress(*this, console, *(GsuState*)cpuState);

2
Core/DisassemblyInfo.h
View file

@ -44,7 +44,7 @@ public:
bool UpdateCpuFlags(uint8_t & cpuFlags);
int32_t GetEffectiveAddress(Console *console, void *cpuState);
int32_t GetEffectiveAddress(Console *console, void *cpuState, CpuType type);
uint16_t GetMemoryValue(uint32_t effectiveAddress, MemoryDumper *memoryDumper, SnesMemoryType memType, uint8_t &valueSize);
};

24
Core/DummyCpu.h
View file

@ -1,6 +1,10 @@
#pragma once
#include "stdafx.h"
#include "MemoryMappings.h"
#include "DebugTypes.h"
#include "BaseCartridge.h"
#include "Sa1.h"
#define DUMMYCPU
#define Cpu DummyCpu
@ -9,6 +13,26 @@
#undef Cpu
#undef DUMMYCPU
DummyCpu::DummyCpu(Console* console, CpuType type)
{
_console = console;
_memoryMappings = type == CpuType::Cpu ? console->GetMemoryManager()->GetMemoryMappings() : console->GetCartridge()->GetSa1()->GetMemoryMappings();
_dmaController = nullptr;
_memoryManager = nullptr;
}
uint8_t DummyCpu::Read(uint32_t addr, MemoryOperationType type)
{
uint8_t value = _memoryMappings->Peek(addr);
LogRead(addr, value);
return value;
}
void DummyCpu::Write(uint32_t addr, uint8_t value, MemoryOperationType type)
{
LogWrite(addr, value);
}
void DummyCpu::SetDummyState(CpuState &state)
{
_state = state;

22
Core/TraceLogger.cpp
View file

@ -255,9 +255,9 @@ void TraceLogger::WriteDisassembly(DisassemblyInfo &info, RowPart &rowPart, uint
WriteValue(output, code, rowPart);
}
void TraceLogger::WriteEffectiveAddress(DisassemblyInfo &info, RowPart &rowPart, void *cpuState, string &output, SnesMemoryType cpuMemoryType)
void TraceLogger::WriteEffectiveAddress(DisassemblyInfo &info, RowPart &rowPart, void *cpuState, string &output, SnesMemoryType cpuMemoryType, CpuType cpuType)
{
int32_t effectiveAddress = info.GetEffectiveAddress(_console, cpuState);
int32_t effectiveAddress = info.GetEffectiveAddress(_console, cpuState, cpuType);
if(effectiveAddress >= 0) {
if(_options.UseLabels) {
AddressInfo addr { effectiveAddress, cpuMemoryType };
@ -271,9 +271,9 @@ void TraceLogger::WriteEffectiveAddress(DisassemblyInfo &info, RowPart &rowPart,
}
}
void TraceLogger::WriteMemoryValue(DisassemblyInfo &info, RowPart &rowPart, void *cpuState, string &output, SnesMemoryType memType)
void TraceLogger::WriteMemoryValue(DisassemblyInfo &info, RowPart &rowPart, void *cpuState, string &output, SnesMemoryType memType, CpuType cpuType)
{
int32_t address = info.GetEffectiveAddress(_console, cpuState);
int32_t address = info.GetEffectiveAddress(_console, cpuState, cpuType);
if(address >= 0) {
uint8_t valueSize;
uint16_t value = info.GetMemoryValue(address, _memoryDumper, memType, valueSize);
@ -297,7 +297,7 @@ void TraceLogger::WriteAlign(int originalSize, RowPart &rowPart, string &output)
}
}
void TraceLogger::GetTraceRow(string &output, CpuState &cpuState, PpuState &ppuState, DisassemblyInfo &disassemblyInfo, SnesMemoryType memType)
void TraceLogger::GetTraceRow(string &output, CpuState &cpuState, PpuState &ppuState, DisassemblyInfo &disassemblyInfo, SnesMemoryType memType, CpuType cpuType)
{
int originalSize = (int)output.size();
uint32_t pcAddress = (cpuState.K << 16) | cpuState.PC;
@ -306,8 +306,8 @@ void TraceLogger::GetTraceRow(string &output, CpuState &cpuState, PpuState &ppuS
case RowDataType::Text: output += rowPart.Text; break;
case RowDataType::ByteCode: WriteByteCode(disassemblyInfo, rowPart, output); break;
case RowDataType::Disassembly: WriteDisassembly(disassemblyInfo, rowPart, (uint8_t)cpuState.SP, pcAddress, output); break;
case RowDataType::EffectiveAddress: WriteEffectiveAddress(disassemblyInfo, rowPart, &cpuState, output, memType); break;
case RowDataType::MemoryValue: WriteMemoryValue(disassemblyInfo, rowPart, &cpuState, output, memType); break;
case RowDataType::EffectiveAddress: WriteEffectiveAddress(disassemblyInfo, rowPart, &cpuState, output, memType, cpuType); break;
case RowDataType::MemoryValue: WriteMemoryValue(disassemblyInfo, rowPart, &cpuState, output, memType, cpuType); break;
case RowDataType::Align: WriteAlign(originalSize, rowPart, output); break;
case RowDataType::PC: WriteValue(output, HexUtilities::ToHex24(pcAddress), rowPart); break;
@ -337,8 +337,8 @@ void TraceLogger::GetTraceRow(string &output, SpcState &cpuState, PpuState &ppuS
case RowDataType::Text: output += rowPart.Text; break;
case RowDataType::ByteCode: WriteByteCode(disassemblyInfo, rowPart, output); break;
case RowDataType::Disassembly: WriteDisassembly(disassemblyInfo, rowPart, cpuState.SP, pcAddress, output); break;
case RowDataType::EffectiveAddress: WriteEffectiveAddress(disassemblyInfo, rowPart, &cpuState, output, SnesMemoryType::SpcMemory); break;
case RowDataType::MemoryValue: WriteMemoryValue(disassemblyInfo, rowPart, &cpuState, output, SnesMemoryType::SpcMemory); break;
case RowDataType::EffectiveAddress: WriteEffectiveAddress(disassemblyInfo, rowPart, &cpuState, output, SnesMemoryType::SpcMemory, CpuType::Spc); break;
case RowDataType::MemoryValue: WriteMemoryValue(disassemblyInfo, rowPart, &cpuState, output, SnesMemoryType::SpcMemory, CpuType::Spc); break;
case RowDataType::Align: WriteAlign(originalSize, rowPart, output); break;
case RowDataType::PC: WriteValue(output, HexUtilities::ToHex((uint16_t)pcAddress), rowPart); break;
@ -489,10 +489,10 @@ bool TraceLogger::ConditionMatches(DebugState &state, DisassemblyInfo &disassemb
void TraceLogger::GetTraceRow(string &output, CpuType cpuType, DisassemblyInfo &disassemblyInfo, DebugState &state)
{
switch(cpuType) {
case CpuType::Cpu: GetTraceRow(output, state.Cpu, state.Ppu, disassemblyInfo, SnesMemoryType::CpuMemory); break;
case CpuType::Cpu: GetTraceRow(output, state.Cpu, state.Ppu, disassemblyInfo, SnesMemoryType::CpuMemory, cpuType); break;
case CpuType::Spc: GetTraceRow(output, state.Spc, state.Ppu, disassemblyInfo); break;
case CpuType::NecDsp: GetTraceRow(output, state.NecDsp, state.Ppu, disassemblyInfo); break;
case CpuType::Sa1: GetTraceRow(output, state.Sa1, state.Ppu, disassemblyInfo, SnesMemoryType::Sa1Memory); break;
case CpuType::Sa1: GetTraceRow(output, state.Sa1, state.Ppu, disassemblyInfo, SnesMemoryType::Sa1Memory, cpuType); break;
case CpuType::Gsu: GetTraceRow(output, state.Gsu, state.Ppu, disassemblyInfo); break;
case CpuType::Cx4: GetTraceRow(output, state.Cx4, state.Ppu, disassemblyInfo); break;
}

6
Core/TraceLogger.h
View file

@ -111,8 +111,8 @@ private:
void WriteByteCode(DisassemblyInfo &info, RowPart &rowPart, string &output);
void WriteDisassembly(DisassemblyInfo &info, RowPart &rowPart, uint8_t sp, uint32_t pc, string &output);
void WriteEffectiveAddress(DisassemblyInfo &info, RowPart &rowPart, void *cpuState, string &output, SnesMemoryType cpuMemoryType);
void WriteMemoryValue(DisassemblyInfo &info, RowPart &rowPart, void *cpuState, string &output, SnesMemoryType memType);
void WriteEffectiveAddress(DisassemblyInfo &info, RowPart &rowPart, void *cpuState, string &output, SnesMemoryType cpuMemoryType, CpuType cpuType);
void WriteMemoryValue(DisassemblyInfo &info, RowPart &rowPart, void *cpuState, string &output, SnesMemoryType memType, CpuType cpuType);
void WriteAlign(int originalSize, RowPart &rowPart, string &output);
void AddRow(CpuType cpuType, DisassemblyInfo &disassemblyInfo, DebugState &state);
//bool ConditionMatches(DebugState &state, DisassemblyInfo &disassemblyInfo, OperationInfo &operationInfo);
@ -120,7 +120,7 @@ private:
void ParseFormatString(vector<RowPart> &rowParts, string format);
void GetTraceRow(string &output, CpuType cpuType, DisassemblyInfo &disassemblyInfo, DebugState &state);
void GetTraceRow(string &output, CpuState &cpuState, PpuState &ppuState, DisassemblyInfo &disassemblyInfo, SnesMemoryType memType);
void GetTraceRow(string &output, CpuState &cpuState, PpuState &ppuState, DisassemblyInfo &disassemblyInfo, SnesMemoryType memType, CpuType cpuType);
void GetTraceRow(string &output, SpcState &cpuState, PpuState &ppuState, DisassemblyInfo &disassemblyInfo);
void GetTraceRow(string &output, NecDspState &cpuState, PpuState &ppuState, DisassemblyInfo &disassemblyInfo);
void GetTraceRow(string &output, GsuState &gsuState, PpuState &ppuState, DisassemblyInfo &disassemblyInfo);

7
UI/Debugger/Controls/ctrlDisassemblyView.cs
View file

@ -458,12 +458,7 @@ namespace Mesen.GUI.Debugger.Controls
Type = _manager.RelativeMemoryType
};
AddressInfo absAddress = DebugApi.GetAbsoluteAddress(relAddress);
if(absAddress.Address >= 0) {
DebugWindowManager.OpenMemoryViewer(absAddress);
} else {
DebugWindowManager.OpenMemoryViewer(relAddress);
}
DebugWindowManager.OpenMemoryViewer(relAddress);
} else if(location.Label != null) {
DebugWindowManager.OpenMemoryViewer(location.Label.GetAbsoluteAddress());
}