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

Merge branch 'get_breakpoints_and_cp_flags'

Browse source
This commit is contained in:
Vladimir Kononovich 2020-11-01 16:53:07 +03:00
commit be6ed9d619
12 changed files with 277 additions and 51 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
Core/BreakpointManager.cpp
View file

@ -54,6 +54,30 @@ void BreakpointManager::SetBreakpoints(Breakpoint breakpoints[], uint32_t count)
}
}
void BreakpointManager::GetBreakpoints(Breakpoint* breakpoints, int& execs, int& reads, int& writes)
{
execs = _breakpoints[static_cast<int>(BreakpointType::Execute)].size();
reads = _breakpoints[static_cast<int>(BreakpointType::Read)].size();
writes = _breakpoints[static_cast<int>(BreakpointType::Write)].size();
if (breakpoints == NULL) {
return;
}
int offset = 0;
for (auto it = _breakpoints[static_cast<int>(BreakpointType::Execute)].cbegin(); it != _breakpoints[static_cast<int>(BreakpointType::Execute)].cend(); it++) {
breakpoints[offset++] = it->second;
}
for (auto it = _breakpoints[static_cast<int>(BreakpointType::Read)].cbegin(); it != _breakpoints[static_cast<int>(BreakpointType::Read)].cend(); it++) {
breakpoints[offset++] = it->second;
}
for (auto it = _breakpoints[static_cast<int>(BreakpointType::Write)].cbegin(); it != _breakpoints[static_cast<int>(BreakpointType::Write)].cend(); it++) {
breakpoints[offset++] = it->second;
}
}
BreakpointType BreakpointManager::GetBreakpointType(MemoryOperationType type)
{
switch(type) {

1
Core/BreakpointManager.h
View file

@ -33,6 +33,7 @@ public:
BreakpointManager(Debugger *debugger, CpuType cpuType, IEventManager* eventManager = nullptr);
void SetBreakpoints(Breakpoint breakpoints[], uint32_t count);
void GetBreakpoints(Breakpoint* breakpoints, int& execs, int& reads, int& writes);
__forceinline int CheckBreakpoint(MemoryOperationInfo operationInfo, AddressInfo &address);
};

55
Core/Cpu.cpp
View file

@ -121,41 +121,24 @@ void Cpu::Write(uint32_t addr, uint8_t value, MemoryOperationType type)
void Cpu::SetReg(CpuRegister reg, uint16_t value)
{
switch (reg) {
case CpuRegister::CpuRegA:
{
_state.A = value;
} break;
case CpuRegister::CpuRegX:
{
_state.X = value;
} break;
case CpuRegister::CpuRegY:
{
_state.Y = value;
} break;
case CpuRegister::CpuRegSP:
{
_state.SP = value;
} break;
case CpuRegister::CpuRegD:
{
_state.D = value;
} break;
case CpuRegister::CpuRegPC:
{
_state.PC = value;
} break;
case CpuRegister::CpuRegK:
{
_state.K = value & 0xFF;
} break;
case CpuRegister::CpuRegDBR:
{
_state.DBR = value & 0xFF;
} break;
case CpuRegister::CpuRegPS:
{
_state.PS = value & 0xFF;
} break;
case CpuRegister::CpuRegA: { _state.A = value; } break;
case CpuRegister::CpuRegX: { _state.X = value; } break;
case CpuRegister::CpuRegY: { _state.Y = value; } break;
case CpuRegister::CpuRegSP: { _state.SP = value; } break;
case CpuRegister::CpuRegD: { _state.D = value; } break;
case CpuRegister::CpuRegPC: { _state.PC = value; } break;
case CpuRegister::CpuRegK: { _state.K = value & 0xFF; } break;
case CpuRegister::CpuRegDBR: { _state.DBR = value & 0xFF; } break;
case CpuRegister::CpuRegPS: { _state.PS = value & 0xFF; } break;
case CpuRegister::CpuFlagNmi: { _state.NmiFlag = value != 0; } break;
}
}
bool Cpu::GetCpuProcFlag(ProcFlags::ProcFlags flag) {
return _state.PS & static_cast<uint8_t>(flag);
}
void Cpu::SetCpuProcFlag(ProcFlags::ProcFlags flag, bool set)
{
_state.PS = set ? (_state.PS | static_cast<uint8_t>(flag)) : (_state.PS & ~static_cast<uint8_t>(flag));
}

2
Core/Cpu.h
View file

@ -331,6 +331,7 @@ public:
void Exec();
CpuState GetState();
bool GetCpuProcFlag(ProcFlags::ProcFlags flag);
uint64_t GetCycleCount();
template<uint64_t value>
@ -347,6 +348,7 @@ public:
void Serialize(Serializer &s) override;
void SetReg(CpuRegister reg, uint16_t value);
void SetCpuProcFlag(ProcFlags::ProcFlags flag, bool set);
#ifdef DUMMYCPU
private:

3
Core/DebugTypes.h
View file

@ -295,7 +295,8 @@ enum class CpuRegister : uint8_t
CpuRegPC,
CpuRegK,
CpuRegDBR,
CpuRegPS
CpuRegPS,
CpuFlagNmi
};
enum class Cx4Register : uint8_t

43
Core/Debugger.cpp
View file

@ -511,11 +511,21 @@ void Debugger::GetState(DebugState &state, bool partialPpuState)
}
}
bool Debugger::GetCpuProcFlag(ProcFlags::ProcFlags flag)
{
return _cpu->GetCpuProcFlag(flag);
}
void Debugger::SetCpuRegister(CpuRegister reg, uint16_t value)
{
_cpu->SetReg(reg, value);
}
void Debugger::SetCpuProcFlag(ProcFlags::ProcFlags flag, bool set)
{
_cpu->SetCpuProcFlag(flag, set);
}
void Debugger::SetCx4Register(Cx4Register reg, uint32_t value)
{
_cart->GetCx4()->SetReg(reg, value);
@ -711,6 +721,39 @@ void Debugger::SetBreakpoints(Breakpoint breakpoints[], uint32_t length)
}
}
void Debugger::GetBreakpoints(CpuType cpuType, Breakpoint* breakpoints, int& execs, int& reads, int& writes)
{
switch (cpuType) {
case CpuType::Cpu: return _cpuDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
case CpuType::Spc: return _spcDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
case CpuType::Gsu: {
if (_gsuDebugger) {
return _gsuDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
}
} break;
case CpuType::Sa1: {
if (_sa1Debugger) {
return _sa1Debugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
}
} break;
case CpuType::NecDsp: {
if (_necDspDebugger) {
return _necDspDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
}
} break;
case CpuType::Cx4: {
if (_cx4Debugger) {
return _cx4Debugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
}
} break;
case CpuType::Gameboy: {
if (_gbDebugger) {
return _gbDebugger->GetBreakpointManager()->GetBreakpoints(breakpoints, reads, writes, execs);
}
} break;
}
}
void Debugger::Log(string message)
{
auto lock = _logLock.AcquireSafe();

3
Core/Debugger.h
View file

@ -128,8 +128,10 @@ public:
void SleepUntilResume(BreakSource source, MemoryOperationInfo* operation = nullptr, int breakpointId = -1);
void GetState(DebugState& state, bool partialPpuState);
bool GetCpuProcFlag(ProcFlags::ProcFlags flag);
void SetCpuRegister(CpuRegister reg, uint16_t value);
void SetCpuProcFlag(ProcFlags::ProcFlags flag, bool set);
void SetCx4Register(Cx4Register reg, uint32_t value);
void SetGameboyRegister(GbRegister reg, uint16_t value);
void SetGsuRegister(GsuRegister reg, uint16_t value);
@ -148,6 +150,7 @@ public:
void RebuildPrgCache(CpuType cpuType);
void SetBreakpoints(Breakpoint breakpoints[], uint32_t length);
void GetBreakpoints(CpuType cpuType, Breakpoint* breakpoints, int& execs, int& reads, int& writes);
void Log(string message);
string GetLog();

14
InteropDLL/DebugApiWrapper.cpp
View file

@ -61,20 +61,24 @@ extern "C"
DllExport const char* GetExecutionTrace(uint32_t lineCount) { return GetDebugger()->GetTraceLogger()->GetExecutionTrace(lineCount); }
DllExport void __stdcall SetBreakpoints(Breakpoint breakpoints[], uint32_t length) { GetDebugger()->SetBreakpoints(breakpoints, length); }
DllExport void __stdcall GetBreakpoints(CpuType cpuType, Breakpoint* breakpoints, int& execs, int& reads, int& writes) { GetDebugger()->GetBreakpoints(cpuType, breakpoints, execs, reads, writes); }
DllExport int32_t __stdcall EvaluateExpression(char* expression, CpuType cpuType, EvalResultType *resultType, bool useCache) { return GetDebugger()->EvaluateExpression(expression, cpuType, *resultType, useCache); }
DllExport void __stdcall GetCallstack(CpuType cpuType, StackFrameInfo *callstackArray, uint32_t &callstackSize) { GetDebugger()->GetCallstackManager(cpuType)->GetCallstack(callstackArray, callstackSize); }
DllExport void __stdcall GetProfilerData(CpuType cpuType, ProfiledFunction* profilerData, uint32_t& functionCount) { GetDebugger()->GetCallstackManager(cpuType)->GetProfiler()->GetProfilerData(profilerData, functionCount); }
DllExport void __stdcall ResetProfiler(CpuType cpuType) { GetDebugger()->GetCallstackManager(cpuType)->GetProfiler()->Reset(); }
DllExport void __stdcall GetState(DebugState& state) { GetDebugger()->GetState(state, false); }
DllExport bool __stdcall GetCpuProcFlag(ProcFlags::ProcFlags flag) { return GetDebugger()->GetCpuProcFlag(flag); }
DllExport void __stdcall SetCpuRegister(CpuRegister reg, uint16_t value) { GetDebugger()->SetCpuRegister(reg, value); }
DllExport void __stdcall SetSpcRegister(SpcRegister reg, uint32_t value) { GetDebugger()->SetSpcRegister(reg, value); }
DllExport void __stdcall SetNecDspRegister(NecDspRegister reg, uint32_t value) { GetDebugger()->SetNecDspRegister(reg, value); }
DllExport void __stdcall SetSa1Register(CpuRegister reg, uint32_t value) { GetDebugger()->SetSa1Register(reg, value); }
DllExport void __stdcall SetGsuRegister(GsuRegister reg, uint32_t value) { GetDebugger()->SetGsuRegister(reg, value); }
DllExport void __stdcall SetCpuProcFlag(ProcFlags::ProcFlags flag, bool set) { GetDebugger()->SetCpuProcFlag(flag, set); };
DllExport void __stdcall SetSpcRegister(SpcRegister reg, uint16_t value) { GetDebugger()->SetSpcRegister(reg, value); }
DllExport void __stdcall SetNecDspRegister(NecDspRegister reg, uint16_t value) { GetDebugger()->SetNecDspRegister(reg, value); }
DllExport void __stdcall SetSa1Register(CpuRegister reg, uint16_t value) { GetDebugger()->SetSa1Register(reg, value); }
DllExport void __stdcall SetGsuRegister(GsuRegister reg, uint16_t value) { GetDebugger()->SetGsuRegister(reg, value); }
DllExport void __stdcall SetCx4Register(Cx4Register reg, uint32_t value) { GetDebugger()->SetCx4Register(reg, value); }
DllExport void __stdcall SetGameboyRegister(GbRegister reg, uint32_t value) { GetDebugger()->SetGameboyRegister(reg, value); }
DllExport void __stdcall SetGameboyRegister(GbRegister reg, uint16_t value) { GetDebugger()->SetGameboyRegister(reg, value); }
DllExport const char* __stdcall GetDebuggerLog()
{

26
UI/Debugger/Controls/ctrlCpuStatus.cs
View file

@ -9,6 +9,7 @@ using System.Threading.Tasks;
using System.Windows.Forms;
using Mesen.GUI.Controls;
using Mesen.GUI.Forms;
using System.Globalization;
namespace Mesen.GUI.Debugger.Controls
{
@ -25,15 +26,24 @@ namespace Mesen.GUI.Debugger.Controls
}
_cpuBinder.Entity = new CpuState();
_cpuBinder.AddBinding(nameof(CpuState.A), txtA);
_cpuBinder.AddBinding(nameof(CpuState.X), txtX);
_cpuBinder.AddBinding(nameof(CpuState.Y), txtY);
_cpuBinder.AddBinding(nameof(CpuState.D), txtD);
_cpuBinder.AddBinding(nameof(CpuState.DBR), txtDB);
_cpuBinder.AddBinding(nameof(CpuState.SP), txtS);
_cpuBinder.AddBinding(nameof(CpuState.PS), txtP);
_cpuBinder.AddBinding(nameof(CpuState.A), txtA, onEditHandler: (s, e) => { DebugApi.SetCpuRegister(CpuRegister.CpuRegA, UInt16.Parse(txtA.Text, NumberStyles.HexNumber)); });
_cpuBinder.AddBinding(nameof(CpuState.X), txtX, onEditHandler: (s, e) => { DebugApi.SetCpuRegister(CpuRegister.CpuRegX, UInt16.Parse(txtX.Text, NumberStyles.HexNumber)); });
_cpuBinder.AddBinding(nameof(CpuState.Y), txtY, onEditHandler: (s, e) => { DebugApi.SetCpuRegister(CpuRegister.CpuRegY, UInt16.Parse(txtY.Text, NumberStyles.HexNumber)); });
_cpuBinder.AddBinding(nameof(CpuState.D), txtD, onEditHandler: (s, e) => { DebugApi.SetCpuRegister(CpuRegister.CpuRegD, UInt16.Parse(txtD.Text, NumberStyles.HexNumber)); });
_cpuBinder.AddBinding(nameof(CpuState.DBR), txtDB, onEditHandler: (s, e) => { DebugApi.SetCpuRegister(CpuRegister.CpuRegDBR, UInt16.Parse(txtDB.Text, NumberStyles.HexNumber)); });
_cpuBinder.AddBinding(nameof(CpuState.SP), txtS, onEditHandler: (s, e) => { DebugApi.SetCpuRegister(CpuRegister.CpuRegSP, UInt16.Parse(txtS.Text, NumberStyles.HexNumber)); });
_cpuBinder.AddBinding(nameof(CpuState.PS), txtP, onEditHandler: (s, e) => { DebugApi.SetCpuRegister(CpuRegister.CpuRegPS, UInt16.Parse(txtP.Text, NumberStyles.HexNumber)); });
_cpuBinder.AddBinding(nameof(CpuState.NmiFlag), chkNmi);
_cpuBinder.AddBinding(nameof(CpuState.NmiFlag), chkNmi, onEditHandler: (s, e) => { DebugApi.SetCpuRegister(CpuRegister.CpuFlagNmi, (UInt16)(chkNmi.Checked ? 1 : 0)); });
chkIndex.CheckedChanged += (s, e) => { DebugApi.SetCpuProcFlag(ProcFlags.IndexMode8, chkIndex.Checked); };
chkCarry.CheckedChanged += (s, e) => { DebugApi.SetCpuProcFlag(ProcFlags.Carry, chkCarry.Checked); };
chkDecimal.CheckedChanged += (s, e) => { DebugApi.SetCpuProcFlag(ProcFlags.Decimal, chkDecimal.Checked); };
chkInterrupt.CheckedChanged += (s, e) => { DebugApi.SetCpuProcFlag(ProcFlags.IrqDisable, chkInterrupt.Checked); };
chkNegative.CheckedChanged += (s, e) => { DebugApi.SetCpuProcFlag(ProcFlags.Negative, chkNegative.Checked); };
chkOverflow.CheckedChanged += (s, e) => { DebugApi.SetCpuProcFlag(ProcFlags.Overflow, chkOverflow.Checked); };
chkMemory.CheckedChanged += (s, e) => { DebugApi.SetCpuProcFlag(ProcFlags.MemoryMode8, chkMemory.Checked); };
chkZero.CheckedChanged += (s, e) => { DebugApi.SetCpuProcFlag(ProcFlags.Zero, chkZero.Checked); };
}
public void UpdateStatus(CpuState state)

40
UI/Forms/EntityBinder.cs
View file

@ -17,6 +17,7 @@ namespace Mesen.GUI.Forms
public class EntityBinder
{
private Dictionary<string, object> _bindings = new Dictionary<string, object>();
private Dictionary<string, EventHandler> _bindedHandlers = new Dictionary<string, EventHandler>();
private Dictionary<string, eNumberFormat> _fieldFormat = new Dictionary<string, eNumberFormat>();
private Dictionary<string, FieldInfoWrapper> _fieldInfo = null;
@ -29,7 +30,7 @@ namespace Mesen.GUI.Forms
public bool Updating { get; private set; }
public void AddBinding(string fieldName, object bindedField, eNumberFormat format = eNumberFormat.Default)
public void AddBinding(string fieldName, object bindedField, eNumberFormat format = eNumberFormat.Default, EventHandler onEditHandler = null)
{
if(BindedType == null) {
throw new Exception("Need to override BindedType to use bindings");
@ -54,6 +55,43 @@ namespace Mesen.GUI.Forms
BaseConfigForm.InitializeComboBox(((ComboBox)bindedField), fieldType);
}
_bindings[fieldName] = bindedField;
_bindedHandlers[fieldName] = onEditHandler;
if(bindedField is TextBox) {
((TextBox)bindedField).Leave += onEditHandler;
} else if(bindedField is ctrlPathSelection) {
((ctrlPathSelection)bindedField).Leave += onEditHandler;
} else if(bindedField is CheckBox) {
((CheckBox)bindedField).CheckedChanged += onEditHandler;
} else if(bindedField is ToolStripMenuItem) {
((ToolStripMenuItem)bindedField).CheckedChanged += onEditHandler;
} else if(bindedField is ctrlRiskyOption) {
((ctrlRiskyOption)bindedField).Click += onEditHandler;
} else if(bindedField is RadioButton) {
((RadioButton)bindedField).CheckedChanged += onEditHandler;
} else if(bindedField is PictureBox) {
((PictureBox)bindedField).BackColorChanged += onEditHandler;
} else if(bindedField is Panel) {
FieldInfoWrapper field = _fieldInfo[fieldName];
object value = field.GetValue(this.Entity);
RadioButton radio = ((Panel)bindedField).Controls.OfType<RadioButton>().FirstOrDefault(r => r.Tag.Equals(value));
if(radio != null) {
radio.CheckedChanged += onEditHandler;
} else {
throw new Exception("No radio button matching value found");
}
} else if(bindedField is ctrlTrackbar) {
((ctrlTrackbar)bindedField).ValueChanged += onEditHandler;
} else if(bindedField is ctrlHorizontalTrackbar) {
((ctrlHorizontalTrackbar)bindedField).ValueChanged += onEditHandler;
} else if(bindedField is TrackBar) {
((TrackBar)bindedField).ValueChanged += onEditHandler;
} else if(bindedField is MesenNumericUpDown) {
((MesenNumericUpDown)bindedField).ValueChanged += onEditHandler;
} else if(bindedField is ComboBox) {
((ComboBox)bindedField).SelectedIndexChanged += onEditHandler;
}
_fieldFormat[fieldName] = format;
} else {
throw new Exception("Invalid field name");

11
UI/Interop/DebugApi.cs
View file

@ -58,6 +58,16 @@ namespace Mesen.GUI
return state;
}
[DllImport(DllPath)] public static extern void SetCpuRegister(CpuRegister reg, UInt16 value);
[DllImport(DllPath)] public static extern void SetCpuProcFlag(ProcFlags flag, [MarshalAs(UnmanagedType.I1)]bool set);
[DllImport(DllPath)] public static extern void SetSpcRegister(SpcRegister reg, UInt16 value);
[DllImport(DllPath)] public static extern void SetNecDspRegister(NecDspRegister reg, UInt16 value);
[DllImport(DllPath)] public static extern void SetSa1Register(CpuRegister reg, UInt16 value);
[DllImport(DllPath)] public static extern void SetGsuRegister(GsuRegister reg, UInt16 value);
[DllImport(DllPath)] public static extern void SetCx4Register(Cx4Register reg, UInt32 value);
[DllImport(DllPath)] public static extern void SetGameboyRegister(GbRegister reg, UInt16 value);
[DllImport(DllPath)] public static extern void SetScriptTimeout(UInt32 timeout);
[DllImport(DllPath)] public static extern Int32 LoadScript([MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8Marshaler))]string name, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8Marshaler))]string content, Int32 scriptId = -1);
[DllImport(DllPath)] public static extern void RemoveScript(Int32 scriptId);
@ -79,6 +89,7 @@ namespace Mesen.GUI
[DllImport(DllPath)] public static extern void ClearLabels();
[DllImport(DllPath)] public static extern void SetBreakpoints([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)]InteropBreakpoint[] breakpoints, UInt32 length);
[DllImport(DllPath)] public static extern void GetBreakpoints(CpuType cpuType, [In, Out] Breakpoint[] breakpoints, ref Int32 execs, ref Int32 reads, ref Int32 writes);
[DllImport(DllPath)] public static extern void SaveRomToDisk([MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8Marshaler))]string filename, [MarshalAs(UnmanagedType.I1)]bool saveAsIps, CdlStripOption cdlStripOption);

106
UI/Interop/DebugState.cs
View file

@ -925,4 +925,110 @@ namespace Mesen.GUI
public InternalRegisterState InternalRegs;
public AluState Alu;
}
public enum CpuRegister : byte
{
CpuRegA,
CpuRegX,
CpuRegY,
CpuRegSP,
CpuRegD,
CpuRegPC,
CpuRegK,
CpuRegDBR,
CpuRegPS,
CpuFlagNmi,
}
public enum Cx4Register : byte
{
Cx4Reg0,
Cx4Reg1,
Cx4Reg2,
Cx4Reg3,
Cx4Reg4,
Cx4Reg5,
Cx4Reg6,
Cx4Reg7,
Cx4Reg8,
Cx4Reg9,
Cx4Reg10,
Cx4Reg11,
Cx4Reg12,
Cx4Reg13,
Cx4Reg14,
Cx4Reg15,
Cx4RegPB,
Cx4RegPC,
Cx4RegA,
Cx4RegP,
Cx4RegSP,
}
public enum GbRegister : byte
{
GbRegPC,
GbRegSP,
GbRegA,
GbRegFlags,
GbRegB,
GbRegC,
GbRegD,
GbRegE,
GbRegH,
GbRegL,
}
public enum GsuRegister : byte
{
GsuReg0,
GsuReg1,
GsuReg2,
GsuReg3,
GsuReg4,
GsuReg5,
GsuReg6,
GsuReg7,
GsuReg8,
GsuReg9,
GsuRegA,
GsuRegB,
GsuRegC,
GsuRegD,
GsuRegE,
GsuRegF,
GsuRegSFR,
}
public enum NecDspRegister : byte
{
NecDspRegA,
NecDspRegFlagsA,
NecDspRegB,
NecDspRegFlagsB,
NecDspRegTR,
NecDspRegTRB,
NecDspRegPC,
NecDspRegRP,
NecDspRegDP,
NecDspRegDR,
NecDspRegSR,
NecDspRegK,
NecDspRegL,
NecDspRegM,
NecDspRegN,
NecDspRegSerialOut,
NecDspRegSerialIn,
NecDspRegSP,
}
public enum SpcRegister : byte
{
SpcRegPC,
SpcRegA,
SpcRegX,
SpcRegY,
SpcRegSP,
SpcRegPS,
}
}