Merge branch 'get_breakpoints_and_cp_flags'

Core/BreakpointManager.cpp

@@ -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) {

Core/BreakpointManager.h

@@ -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);
 };
 

Core/Cpu.cpp

@@ -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:
+	case CpuRegister::CpuRegA:	{	_state.A = value;	} break;
-	{
+	case CpuRegister::CpuRegX:	{	_state.X = value;	} break;
-		_state.A = value;
+	case CpuRegister::CpuRegY:	{	_state.Y = value;	} break;
-	} break;
+	case CpuRegister::CpuRegSP:	{	_state.SP = value;	} break;
-	case CpuRegister::CpuRegX:
+	case CpuRegister::CpuRegD:	{	_state.D = value;	} break;
-	{
+	case CpuRegister::CpuRegPC:	{	_state.PC = value;	} break;
-		_state.X = value;
+	case CpuRegister::CpuRegK:	{	_state.K = value & 0xFF;	} break;
-	} break;
+	case CpuRegister::CpuRegDBR:	{	_state.DBR = value & 0xFF;	} break;
-	case CpuRegister::CpuRegY:
+	case CpuRegister::CpuRegPS:	{	_state.PS = value & 0xFF;	} break;
-	{
+	case CpuRegister::CpuFlagNmi:	{	_state.NmiFlag = value != 0;	} break;
-		_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;
 	}
 }
+
+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));
+}

Core/Cpu.h

@@ -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:

Core/DebugTypes.h

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

Core/Debugger.cpp

@@ -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();

Core/Debugger.h

@@ -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();

InteropDLL/DebugApiWrapper.cpp

@@ -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 SetCpuProcFlag(ProcFlags::ProcFlags flag, bool set) { GetDebugger()->SetCpuProcFlag(flag, set); };
-	DllExport void __stdcall SetNecDspRegister(NecDspRegister reg, uint32_t value) { GetDebugger()->SetNecDspRegister(reg, value); }
+	DllExport void __stdcall SetSpcRegister(SpcRegister reg, uint16_t value) { GetDebugger()->SetSpcRegister(reg, value); }
-	DllExport void __stdcall SetSa1Register(CpuRegister reg, uint32_t value) { GetDebugger()->SetSa1Register(reg, value); }
+	DllExport void __stdcall SetNecDspRegister(NecDspRegister reg, uint16_t value) { GetDebugger()->SetNecDspRegister(reg, value); }
-	DllExport void __stdcall SetGsuRegister(GsuRegister reg, uint32_t value) { GetDebugger()->SetGsuRegister(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()
 	{

UI/Debugger/Controls/ctrlCpuStatus.cs

@@ -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.A), txtA, onEditHandler: (s, e) => { DebugApi.SetCpuRegister(CpuRegister.CpuRegA, UInt16.Parse(txtA.Text, NumberStyles.HexNumber)); });
-			_cpuBinder.AddBinding(nameof(CpuState.X), txtX);
+			_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);
+			_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);
+			_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);
+			_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);
+			_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);
+			_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)

UI/Forms/EntityBinder.cs

@@ -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");

UI/Interop/DebugApi.cs

@@ -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);
 

UI/Interop/DebugState.cs

@@ -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,
+	}
 }