diff --git a/Core/Console.cpp b/Core/Console.cpp
index ca10ecb..5becedb 100644
--- a/Core/Console.cpp
+++ b/Core/Console.cpp
@@ -137,7 +137,7 @@ void Console::LoadRom(VirtualFile romFile, VirtualFile patchFile)
_memoryManager->Initialize(shared_from_this());
- _cpu.reset(new Cpu(_memoryManager));
+ _cpu.reset(new Cpu(_memoryManager.get()));
_memoryManager->IncrementMasterClockValue<160>();
//if(_debugger) {
diff --git a/Core/Core.vcxproj b/Core/Core.vcxproj
index 3e82d0e..0381271 100644
--- a/Core/Core.vcxproj
+++ b/Core/Core.vcxproj
@@ -57,6 +57,7 @@
+
diff --git a/Core/Core.vcxproj.filters b/Core/Core.vcxproj.filters
index d6b4380..4979940 100644
--- a/Core/Core.vcxproj.filters
+++ b/Core/Core.vcxproj.filters
@@ -188,6 +188,9 @@
Debugger
+
+ Debugger
+
diff --git a/Core/Cpu.Instructions.cpp b/Core/Cpu.Instructions.cpp
index 22d8136..4d13748 100644
--- a/Core/Cpu.Instructions.cpp
+++ b/Core/Cpu.Instructions.cpp
@@ -655,6 +655,7 @@ Move operations
****************/
void Cpu::MVN()
{
+#ifndef DUMMYCPU
_state.DBR = _operand & 0xFF;
uint32_t destBank = _state.DBR << 16;
uint32_t srcBank = (_operand << 8) & 0xFF0000;
@@ -671,15 +672,17 @@ void Cpu::MVN()
if(_state.A != 0xFFFF) {
//"Idle" cycles, instruction re-reads OP code and operands before every new byte
- _memoryManager->Read((_state.K << 16) | (_state.PC - 3), MemoryOperationType::Read);
- _memoryManager->Read((_state.K << 16) | (_state.PC - 2), MemoryOperationType::Read);
- _memoryManager->Read((_state.K << 16) | (_state.PC - 1), MemoryOperationType::Read);
+ Read((_state.K << 16) | (_state.PC - 3), MemoryOperationType::Read);
+ Read((_state.K << 16) | (_state.PC - 2), MemoryOperationType::Read);
+ Read((_state.K << 16) | (_state.PC - 1), MemoryOperationType::Read);
}
} while(_state.A != 0xFFFF);
+#endif
}
void Cpu::MVP()
{
+#ifndef DUMMYCPU
_state.DBR = _operand & 0xFF;
uint32_t destBank = _state.DBR << 16;
uint32_t srcBank = (_operand << 8) & 0xFF0000;
@@ -696,11 +699,12 @@ void Cpu::MVP()
if(_state.A != 0xFFFF) {
//"Idle" cycles, instruction re-reads OP code and operands before every new byte
- _memoryManager->Read((_state.K << 16) | (_state.PC - 3), MemoryOperationType::Read);
- _memoryManager->Read((_state.K << 16) | (_state.PC - 2), MemoryOperationType::Read);
- _memoryManager->Read((_state.K << 16) | (_state.PC - 1), MemoryOperationType::Read);
+ Read((_state.K << 16) | (_state.PC - 3), MemoryOperationType::Read);
+ Read((_state.K << 16) | (_state.PC - 2), MemoryOperationType::Read);
+ Read((_state.K << 16) | (_state.PC - 1), MemoryOperationType::Read);
}
} while(_state.A != 0xFFFF);
+#endif
}
/********************
diff --git a/Core/Cpu.cpp b/Core/Cpu.cpp
index 56cc35e..39999eb 100644
--- a/Core/Cpu.cpp
+++ b/Core/Cpu.cpp
@@ -3,7 +3,7 @@
#include "Cpu.h"
#include "MemoryManager.h"
-Cpu::Cpu(shared_ptr memoryManager)
+Cpu::Cpu(MemoryManager* memoryManager)
{
_memoryManager = memoryManager;
_state = {};
@@ -338,7 +338,9 @@ uint8_t Cpu::GetOpCode()
void Cpu::Idle()
{
+#ifndef DUMMYCPU
_memoryManager->IncrementMasterClockValue<6>();
+#endif
}
uint8_t Cpu::ReadOperandByte()
@@ -361,10 +363,22 @@ uint32_t Cpu::ReadOperandLong()
return (b3 << 16) | (b2 << 8) | b1;
}
-uint8_t Cpu::ReadCode(uint16_t addr, MemoryOperationType type)
+uint8_t Cpu::Read(uint32_t addr, MemoryOperationType type)
{
_state.CycleCount++;
- return _memoryManager->Read((_state.K << 16) | addr, type);
+
+#ifdef DUMMYCPU
+ uint8_t value = _memoryManager->Peek(addr);
+ LogRead(addr, value);
+ return value;
+#else
+ return _memoryManager->Read(addr, type);
+#endif
+}
+
+uint8_t Cpu::ReadCode(uint16_t addr, MemoryOperationType type)
+{
+ return Read((_state.K << 16) | addr, type);
}
uint16_t Cpu::ReadCodeWord(uint16_t addr, MemoryOperationType type)
@@ -376,8 +390,7 @@ uint16_t Cpu::ReadCodeWord(uint16_t addr, MemoryOperationType type)
uint8_t Cpu::ReadData(uint32_t addr, MemoryOperationType type)
{
- _state.CycleCount++;
- return _memoryManager->Read(addr & 0xFFFFFF, type);
+ return Read(addr & 0xFFFFFF, type);
}
uint16_t Cpu::ReadDataWord(uint32_t addr, MemoryOperationType type)
@@ -398,7 +411,12 @@ uint32_t Cpu::ReadDataLong(uint32_t addr, MemoryOperationType type)
void Cpu::Write(uint32_t addr, uint8_t value, MemoryOperationType type)
{
_state.CycleCount++;
+
+#ifdef DUMMYCPU
+ LogWrite(addr, value);
+#else
_memoryManager->Write(addr, value, type);
+#endif
}
void Cpu::WriteWord(uint32_t addr, uint16_t value, MemoryOperationType type)
diff --git a/Core/Cpu.h b/Core/Cpu.h
index bbf7d38..f25703b 100644
--- a/Core/Cpu.h
+++ b/Core/Cpu.h
@@ -1,4 +1,10 @@
-#pragma once
+#if (defined(DUMMYCPU) && !defined(__DUMMYCPU__H)) || (!defined(DUMMYCPU) && !defined(__CPU__H))
+#ifdef DUMMYCPU
+#define __DUMMYCPU__H
+#else
+#define __CPU__H
+#endif
+
#include "stdafx.h"
#include "CpuTypes.h"
@@ -25,7 +31,7 @@ private:
typedef void(Cpu::*Func)();
- shared_ptr _memoryManager;
+ MemoryManager* _memoryManager;
bool _immediateMode = false;
@@ -53,6 +59,8 @@ private:
uint16_t ReadOperandWord();
uint32_t ReadOperandLong();
+ uint8_t Read(uint32_t addr, MemoryOperationType type);
+
void SetSP(uint16_t sp);
void SetPS(uint8_t ps);
@@ -285,7 +293,7 @@ private:
void AddrMode_StkRelIndIdxY();
public:
- Cpu(shared_ptr memoryManager);
+ Cpu(MemoryManager* memoryManager);
~Cpu();
void Reset();
@@ -295,4 +303,30 @@ public:
void SetIrqSource(IrqSource source);
bool CheckIrqSource(IrqSource source);
void ClearIrqSource(IrqSource source);
+
+#ifdef DUMMYCPU
+private:
+ uint32_t _writeCounter = 0;
+ uint32_t _writeAddresses[10];
+ uint8_t _writeValue[10];
+
+ uint32_t _readCounter = 0;
+ uint32_t _readAddresses[10];
+ uint8_t _readValue[10];
+
+ uint32_t _valueSize = 0;
+
+ void LogRead(uint32_t addr, uint8_t value);
+ void LogWrite(uint32_t addr, uint8_t value);
+
+public:
+ void SetDummyState(CpuState &state);
+
+ uint32_t GetWriteCount();
+ uint32_t GetReadCount();
+ void GetWriteInfo(uint32_t index, uint32_t &addr, uint8_t &value);
+ void GetReadInfo(uint32_t index, uint32_t &addr, uint8_t &value);
+#endif
};
+
+#endif
\ No newline at end of file
diff --git a/Core/DebugTypes.h b/Core/DebugTypes.h
index 566c381..64b3716 100644
--- a/Core/DebugTypes.h
+++ b/Core/DebugTypes.h
@@ -107,7 +107,8 @@ struct CodeLineData
uint8_t Flags;
int32_t EffectiveAddress;
- int32_t Value;
+ uint16_t Value;
+ uint8_t ValueSize;
uint8_t ByteCode[4];
char Text[1000];
diff --git a/Core/Debugger.cpp b/Core/Debugger.cpp
index ef36f97..d90bc4e 100644
--- a/Core/Debugger.cpp
+++ b/Core/Debugger.cpp
@@ -71,7 +71,6 @@ void Debugger::ProcessCpuRead(uint32_t addr, uint8_t value, MemoryOperationType
DebugState debugState;
GetState(&debugState);
- _traceLogger->LogEffectiveAddress(_cpu->GetLastOperand());
DisassemblyInfo disInfo = _disassembler->GetDisassemblyInfo(addressInfo);
_traceLogger->Log(debugState, disInfo);
diff --git a/Core/Disassembler.cpp b/Core/Disassembler.cpp
index 6ce6e76..3177c90 100644
--- a/Core/Disassembler.cpp
+++ b/Core/Disassembler.cpp
@@ -235,9 +235,13 @@ bool Disassembler::GetLineData(uint32_t lineIndex, CodeLineData &data)
vector> *cache;
GetSource(result.Address, &source, sourceLength, &cache);
disInfo = (*cache)[result.Address.Address];
+
+ CpuState state = _console->GetCpu()->GetState();
+ state.PC = (uint16_t)result.CpuAddress;
+ state.K = (result.CpuAddress >> 16);
if(!disInfo) {
- disInfo.reset(new DisassemblyInfo(source + result.Address.Address, 0));
+ disInfo.reset(new DisassemblyInfo(source + result.Address.Address, state.PS));
} else {
data.Flags |= (uint8_t)LineFlags::VerifiedCode;
}
@@ -247,8 +251,14 @@ bool Disassembler::GetLineData(uint32_t lineIndex, CodeLineData &data)
memcpy(data.Text, text.c_str(), std::min((int)text.size(), 1000));
data.OpSize = disInfo->GetOperandSize() + 1;
- data.EffectiveAddress = disInfo->GetEffectiveAddress();
- data.Value = _memoryManager->Peek(result.CpuAddress);
+
+ MemoryManager *memoryManager = _console->GetMemoryManager().get();
+ data.EffectiveAddress = disInfo->GetEffectiveAddress(state, memoryManager);
+ if(data.EffectiveAddress >= 0) {
+ data.Value = disInfo->GetMemoryValue(data.EffectiveAddress, memoryManager, data.ValueSize);
+ } else {
+ data.ValueSize = 0;
+ }
disInfo->GetByteCode(data.ByteCode);
data.Comment[0] = 0;
@@ -266,7 +276,7 @@ bool Disassembler::GetLineData(uint32_t lineIndex, CodeLineData &data)
return false;
}
-int32_t Disassembler::SearchCode(const char *searchString, int32_t startPosition, int32_t endPosition, bool searchBackwards)
+int32_t Disassembler::SearchDisassembly(const char *searchString, int32_t startPosition, int32_t endPosition, bool searchBackwards)
{
auto lock = _disassemblyLock.AcquireSafe();
int step = searchBackwards ? -1 : 1;
diff --git a/Core/Disassembler.h b/Core/Disassembler.h
index 065f387..eb127c0 100644
--- a/Core/Disassembler.h
+++ b/Core/Disassembler.h
@@ -46,5 +46,5 @@ public:
uint32_t GetLineCount();
uint32_t GetLineIndex(uint32_t cpuAddress);
bool GetLineData(uint32_t lineIndex, CodeLineData &data);
- int32_t SearchCode(const char* searchString, int32_t startPosition, int32_t endPosition, bool searchBackwards);
+ int32_t SearchDisassembly(const char* searchString, int32_t startPosition, int32_t endPosition, bool searchBackwards);
};
\ No newline at end of file
diff --git a/Core/DisassemblyInfo.cpp b/Core/DisassemblyInfo.cpp
index e74498f..0152510 100644
--- a/Core/DisassemblyInfo.cpp
+++ b/Core/DisassemblyInfo.cpp
@@ -3,6 +3,7 @@
#include "DisassemblyInfo.h"
#include "CpuTypes.h"
#include "MemoryManager.h"
+#include "DummyCpu.h"
#include "../Utilities/HexUtilities.h"
#include "../Utilities/FastString.h"
@@ -17,8 +18,7 @@ DisassemblyInfo::DisassemblyInfo(uint8_t *opPointer, uint8_t cpuFlags)
void DisassemblyInfo::Initialize(uint8_t *opPointer, uint8_t cpuFlags)
{
- _flags = cpuFlags;
- _effectiveAddress = -1;
+ _flags = cpuFlags & (ProcFlags::MemoryMode8 | ProcFlags::IndexMode8);
_byteCode[0] = opPointer[0];
_addrMode = DisassemblyInfo::OpMode[_byteCode[0]];
@@ -55,7 +55,7 @@ void DisassemblyInfo::GetDisassembly(string &out, uint32_t memoryAddr)
case AddrMode::AbsLng: str.Write(operand); break;
case AddrMode::AbsLngJmp: str.Write(operand); break;
case AddrMode::Acc: break;
- case AddrMode::BlkMov: str.Write(operand[1], operand[2], " -> "); str.Write(operand[3], operand[4]); break;
+ case AddrMode::BlkMov: str.Write('$', operand[1], operand[2], " -> "); str.Write('$', operand[3], operand[4]); break;
case AddrMode::DirIdxIndX: str.Write('(', operand, ",X)"); break;
case AddrMode::DirIdxX: str.Write(operand, ",X"); break;
case AddrMode::DirIdxY: str.Write(operand, ",Y"); break;
@@ -177,76 +177,36 @@ void DisassemblyInfo::GetByteCode(string &out)
out += str.ToString();
}
-void DisassemblyInfo::GetEffectiveAddressString(string &out)
+void DisassemblyInfo::GetEffectiveAddressString(string &out, CpuState &state, MemoryManager* memoryManager)
{
- int32_t effectiveAddress = GetEffectiveAddress();
+ int32_t effectiveAddress = GetEffectiveAddress(state, memoryManager);
if(effectiveAddress >= 0) {
out += " [" + HexUtilities::ToHex24(effectiveAddress) + "]";
}
}
-void DisassemblyInfo::SetEffectiveAddress(int32_t effectiveAddress)
+int32_t DisassemblyInfo::GetEffectiveAddress(CpuState &state, MemoryManager *memoryManager)
{
- _effectiveAddress = effectiveAddress;
-}
-
-int32_t DisassemblyInfo::GetEffectiveAddress()
-{
- if(_addrMode > AddrMode::ImmM && _addrMode != AddrMode::Acc && _addrMode != AddrMode::Imp && _addrMode != AddrMode::Stk) {
- return _effectiveAddress;
+ if(_addrMode > AddrMode::ImmM && _addrMode != AddrMode::Acc && _addrMode != AddrMode::Imp && _addrMode != AddrMode::Stk && _addrMode != AddrMode::Rel && _addrMode != AddrMode::RelLng && _addrMode != AddrMode::BlkMov) {
+ DummyCpu cpu(memoryManager);
+ state.PS &= ~(ProcFlags::IndexMode8 | ProcFlags::MemoryMode8);
+ state.PS |= _flags;
+ cpu.SetDummyState(state);
+ cpu.Exec();
+ return cpu.GetLastOperand();
}
return -1;
+}
- /*auto getProgramAddress = [&state](uint16_t addr) { return (state.K << 16) | addr; };
- auto getDataAddress = [&state](uint16_t addr) { return (state.DBR << 16) | addr; };
- auto getDirectAddress = [&state](uint8_t baseAddress, uint16_t offset = 0, bool allowEmulationMode = true) {
- if(allowEmulationMode && state.EmulationMode && (state.D & 0xFF) == 0) {
- //TODO: Check if new instruction or not (PEI)
- return (uint16_t)((state.D & 0xFF00) | ((baseAddress + offset) & 0xFF));
- } else {
- return (uint16_t)(state.D + baseAddress + offset);
- }
- };
-
- auto getDirectAddressIndirectWord = [&state, mm, &getDirectAddress](uint8_t baseAddress, uint16_t offset = 0, bool allowEmulationMode = true) {
- uint8_t b1 = mm->Peek(getDirectAddress(baseAddress, offset + 0));
- uint8_t b2 = mm->Peek(getDirectAddress(baseAddress, offset + 1));
- return (b2 << 8) | b1;
- };
-
- auto getDirectAddressIndirectLong = [&state, mm, &getDirectAddress](uint8_t baseAddress, uint16_t offset = 0, bool allowEmulationMode = true) {
- uint8_t b1 = mm->Peek(getDirectAddress(baseAddress, offset + 0));
- uint8_t b2 = mm->Peek(getDirectAddress(baseAddress, offset + 1));
- uint8_t b3 = mm->Peek(getDirectAddress(baseAddress, offset + 2));
- return (b3 << 16) | (b2 << 8) | b1;
- };
-
-
- uint32_t bank = (state.K << 16);
- uint32_t opAddr = GetOperandAddress(bank | state.PC);
- switch(_addrMode) {
- case AddrMode::AbsIdxX: return opAddr + state.X;
- case AddrMode::AbsIdxY: return opAddr + state.Y;
- case AddrMode::AbsLngIdxX: return opAddr + state.X;
- case AddrMode::AbsIdxXInd: return getProgramAddress(mm->PeekWord(getProgramAddress(opAddr + state.X)));
- case AddrMode::AbsInd: return getProgramAddress(mm->PeekWord(opAddr));
- case AddrMode::AbsIndLng: return mm->PeekLong(opAddr);
-
- case AddrMode::BlkMov: break; //TODO
-
- case AddrMode::Dir: return getDirectAddress(opAddr);
- case AddrMode::DirIdxX: return getDirectAddress(opAddr, state.X);
- case AddrMode::DirIdxY: return getDirectAddress(opAddr, state.Y);
-
- case AddrMode::DirInd: return getDirectAddressIndirectWord(opAddr);
- case AddrMode::DirIdxIndX: return getDirectAddressIndirectWord(opAddr, state.X);
- case AddrMode::DirIndIdxY: return getDirectAddressIndirectWord(opAddr) + state.Y;
- case AddrMode::DirIndLng: return getDirectAddressIndirectLong(opAddr);
- case AddrMode::DirIndLngIdxY: return getDirectAddressIndirectLong(opAddr) + state.Y;
-
- case AddrMode::StkRel: return opAddr + state.SP;
- case AddrMode::StkRelIndIdxY: break;
- }*/
+uint16_t DisassemblyInfo::GetMemoryValue(uint32_t effectiveAddress, MemoryManager *memoryManager, uint8_t &valueSize)
+{
+ if(_flags & ProcFlags::MemoryMode8) {
+ valueSize = 1;
+ return memoryManager->Peek(effectiveAddress);
+ } else {
+ valueSize = 2;
+ return memoryManager->PeekWord(effectiveAddress);
+ }
}
string DisassemblyInfo::OpName[256] = {
diff --git a/Core/DisassemblyInfo.h b/Core/DisassemblyInfo.h
index f6cde5d..e3b3501 100644
--- a/Core/DisassemblyInfo.h
+++ b/Core/DisassemblyInfo.h
@@ -19,7 +19,6 @@ private:
uint8_t _opSize;
AddrMode _addrMode;
uint8_t _flags;
- int32_t _effectiveAddress;
public:
DisassemblyInfo();
@@ -37,13 +36,8 @@ public:
void GetByteCode(uint8_t copyBuffer[4]);
void GetByteCode(string &out);
- void SetEffectiveAddress(int32_t effectiveAddress);
- void GetEffectiveAddressString(string &out);
- int32_t GetEffectiveAddress();
-
- /*int32_t GetMemoryValue(CpuState& cpuState, MemoryManager* memoryManager);
- uint16_t GetJumpDestination(uint16_t pc, MemoryManager* memoryManager);
- uint16_t GetIndirectJumpDestination(MemoryManager* memoryManager);
- */
+ void GetEffectiveAddressString(string &out, CpuState &state, MemoryManager* memoryManager);
+ int32_t GetEffectiveAddress(CpuState &state, MemoryManager *memoryManager);
+ uint16_t GetMemoryValue(uint32_t effectiveAddress, MemoryManager *memoryManager, uint8_t &valueSize);
};
diff --git a/Core/DummyCpu.h b/Core/DummyCpu.h
new file mode 100644
index 0000000..26705f1
--- /dev/null
+++ b/Core/DummyCpu.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#include "stdafx.h"
+
+#define DUMMYCPU
+#define Cpu DummyCpu
+#include "Cpu.h"
+#include "Cpu.cpp"
+#include "Cpu.Instructions.cpp"
+#undef Cpu
+#undef DUMMYCPU
+
+void DummyCpu::SetDummyState(CpuState &state)
+{
+ _state = state;
+
+ _writeCounter = 0;
+ _readCounter = 0;
+}
+
+uint32_t DummyCpu::GetWriteCount()
+{
+ return _writeCounter;
+}
+
+uint32_t DummyCpu::GetReadCount()
+{
+ return _readCounter;
+}
+
+void DummyCpu::LogRead(uint32_t addr, uint8_t value)
+{
+ _readAddresses[_readCounter] = addr;
+ _readValue[_readCounter] = value;
+ _readCounter++;
+}
+
+void DummyCpu::LogWrite(uint32_t addr, uint8_t value)
+{
+ _writeAddresses[_writeCounter] = addr;
+ _writeValue[_writeCounter] = value;
+ _writeCounter++;
+}
+
+void DummyCpu::GetWriteInfo(uint32_t index, uint32_t &addr, uint8_t &value)
+{
+ addr = _writeAddresses[index];
+ value = _writeValue[index];
+}
+
+void DummyCpu::GetReadInfo(uint32_t index, uint32_t &addr, uint8_t &value)
+{
+ addr = _readAddresses[index];
+ value = _readValue[index];
+}
\ No newline at end of file
diff --git a/Core/MemoryManager.cpp b/Core/MemoryManager.cpp
index 51c84f6..44b8238 100644
--- a/Core/MemoryManager.cpp
+++ b/Core/MemoryManager.cpp
@@ -185,6 +185,13 @@ uint8_t MemoryManager::Peek(uint32_t addr)
return value;
}
+uint16_t MemoryManager::PeekWord(uint32_t addr)
+{
+ uint8_t lsb = Peek(addr);
+ uint8_t msb = Peek((addr + 1) & 0xFFFFFF);
+ return (msb << 8) | lsb;
+}
+
void MemoryManager::Write(uint32_t addr, uint8_t value, MemoryOperationType type)
{
IncrementMasterClock(addr);
diff --git a/Core/MemoryManager.h b/Core/MemoryManager.h
index 26b3338..07fab1d 100644
--- a/Core/MemoryManager.h
+++ b/Core/MemoryManager.h
@@ -51,6 +51,7 @@ public:
uint8_t Read(uint32_t addr, MemoryOperationType type);
uint8_t ReadDma(uint32_t addr);
uint8_t Peek(uint32_t addr);
+ uint16_t PeekWord(uint32_t addr);
void Write(uint32_t addr, uint8_t value, MemoryOperationType type);
void WriteDma(uint32_t addr, uint8_t value);
diff --git a/Core/TraceLogger.cpp b/Core/TraceLogger.cpp
index 201758e..7248942 100644
--- a/Core/TraceLogger.cpp
+++ b/Core/TraceLogger.cpp
@@ -218,18 +218,28 @@ void TraceLogger::GetTraceRow(string &output, CpuState &cpuState, PpuState &ppuS
case RowDataType::EffectiveAddress:
{
string effectiveAddress;
- disassemblyInfo.GetEffectiveAddressString(effectiveAddress);
+ disassemblyInfo.GetEffectiveAddressString(effectiveAddress, cpuState, _memoryManager.get());
WriteValue(output, effectiveAddress, rowPart);
break;
}
case RowDataType::MemoryValue:
{
- /*int32_t value = disassemblyInfo.GetMemoryValue(cpuState, _memoryManager.get());
- if(value >= 0) {
- output += rowPart.DisplayInHex ? "= $" : "= ";
- WriteValue(output, (uint8_t)value, rowPart);
- }*/
+ int32_t address = disassemblyInfo.GetEffectiveAddress(cpuState, _memoryManager.get());
+ if(address >= 0) {
+ uint8_t valueSize;
+ uint16_t value = disassemblyInfo.GetMemoryValue(address, _memoryManager.get(), valueSize);
+ if(rowPart.DisplayInHex) {
+ output += "= $";
+ if(valueSize == 2) {
+ WriteValue(output, (uint16_t)value, rowPart);
+ } else {
+ WriteValue(output, (uint8_t)value, rowPart);
+ }
+ } else {
+ output += "= ";
+ }
+ }
break;
}
@@ -284,6 +294,14 @@ void TraceLogger::AddRow(DisassemblyInfo &disassemblyInfo, DebugState &state)
_logCount++;
}
+ if(_logToFile) {
+ GetTraceRow(_outputBuffer, _cpuStateCache[_currentPos], _ppuStateCache[_currentPos], _disassemblyCache[_currentPos]);
+ if(_outputBuffer.size() > 32768) {
+ _outputFile << _outputBuffer;
+ _outputBuffer.clear();
+ }
+ }
+
_currentPos = (_currentPos + 1) % ExecutionLogSize;
}
/*
@@ -297,25 +315,6 @@ void TraceLogger::LogNonExec(OperationInfo& operationInfo)
}
}*/
-void TraceLogger::LogEffectiveAddress(uint32_t effectiveAddress)
-{
- uint32_t pos;
- if(_currentPos > 0) {
- pos = _currentPos - 1;
- } else {
- pos = ExecutionLogSize - 1;
- }
-
- _disassemblyCache[pos].SetEffectiveAddress(effectiveAddress);
- if(_logToFile) {
- GetTraceRow(_outputBuffer, _cpuStateCache[pos], _ppuStateCache[pos], _disassemblyCache[pos]);
- if(_outputBuffer.size() > 32768) {
- _outputFile << _outputBuffer;
- _outputBuffer.clear();
- }
- }
-}
-
void TraceLogger::Log(DebugState &state, DisassemblyInfo &disassemblyInfo)
{
auto lock = _lock.AcquireSafe();
diff --git a/Core/TraceLogger.h b/Core/TraceLogger.h
index d5276a6..53f5d09 100644
--- a/Core/TraceLogger.h
+++ b/Core/TraceLogger.h
@@ -97,8 +97,6 @@ public:
TraceLogger(Debugger* debugger, shared_ptr memoryManager);
~TraceLogger();
- void LogEffectiveAddress(uint32_t effectiveAddress);
-
void Log(DebugState &state, DisassemblyInfo &disassemblyInfo);
//void LogNonExec(OperationInfo& operationInfo);
void SetOptions(TraceLoggerOptions options);
diff --git a/InteropDLL/DebugApiWrapper.cpp b/InteropDLL/DebugApiWrapper.cpp
index c41836d..9787826 100644
--- a/InteropDLL/DebugApiWrapper.cpp
+++ b/InteropDLL/DebugApiWrapper.cpp
@@ -39,7 +39,7 @@ extern "C"
DllExport void __stdcall GetDisassemblyLineData(uint32_t lineIndex, CodeLineData &data) { GetDebugger()->GetDisassembler()->GetLineData(lineIndex, data); }
DllExport uint32_t __stdcall GetDisassemblyLineCount() { return GetDebugger()->GetDisassembler()->GetLineCount(); }
DllExport uint32_t __stdcall GetDisassemblyLineIndex(uint32_t cpuAddress) { return GetDebugger()->GetDisassembler()->GetLineIndex(cpuAddress); }
- DllExport int32_t __stdcall SearchDisassembly(const char* searchString, int32_t startPosition, int32_t endPosition, bool searchBackwards) { return GetDebugger()->GetDisassembler()->SearchCode(searchString, startPosition, endPosition, searchBackwards); }
+ DllExport int32_t __stdcall SearchDisassembly(const char* searchString, int32_t startPosition, int32_t endPosition, bool searchBackwards) { return GetDebugger()->GetDisassembler()->SearchDisassembly(searchString, startPosition, endPosition, searchBackwards); }
DllExport void __stdcall SetTraceOptions(TraceLoggerOptions options) { GetDebugger()->GetTraceLogger()->SetOptions(options); }
DllExport void __stdcall StartTraceLogger(char* filename) { GetDebugger()->GetTraceLogger()->StartLogging(filename); }
diff --git a/UI/Debugger/CodeLineData.cs b/UI/Debugger/CodeLineData.cs
index 5cd22ba..ef339c5 100644
--- a/UI/Debugger/CodeLineData.cs
+++ b/UI/Debugger/CodeLineData.cs
@@ -21,11 +21,27 @@ namespace Mesen.GUI.Debugger
public string Comment;
public Int32 EffectiveAddress;
- public Int32 Value;
+ public UInt16 Value;
+ public byte ValueSize;
public string GetEffectiveAddressString()
{
- return "[" + EffectiveAddress.ToString("X6") + "]";
+ if(EffectiveAddress >= 0) {
+ return "[" + EffectiveAddress.ToString("X6") + "]";
+ } else {
+ return "";
+ }
+ }
+
+ public string GetValueString()
+ {
+ if(ValueSize == 1) {
+ return " = $" + Value.ToString("X2");
+ } else if(ValueSize == 2) {
+ return " = $" + Value.ToString("X4");
+ } else {
+ return "";
+ }
}
public int Indentation
@@ -58,6 +74,7 @@ namespace Mesen.GUI.Debugger
this.EffectiveAddress = data.EffectiveAddress;
this.Flags = (LineFlags)data.Flags;
this.Value = data.Value;
+ this.ValueSize = data.ValueSize;
}
private string ConvertString(byte[] stringArray)
@@ -81,7 +98,8 @@ namespace Mesen.GUI.Debugger
public byte Flags;
public Int32 EffectiveAddress;
- public Int32 Value;
+ public UInt16 Value;
+ public byte ValueSize;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] ByteCode;
diff --git a/UI/Debugger/Controls/ctrlTextbox.cs b/UI/Debugger/Controls/ctrlTextbox.cs
index 9e206bb..2620c1a 100644
--- a/UI/Debugger/Controls/ctrlTextbox.cs
+++ b/UI/Debugger/Controls/ctrlTextbox.cs
@@ -16,7 +16,7 @@ namespace Mesen.GUI.Debugger.Controls
{
public partial class ctrlTextbox : Control
{
- private Regex _codeRegex = new Regex("^(\\s*)([a-z]{3})([*]{0,1})($|[ ]){1}([(]{0,1})(([$][0-9a-f]*)|(#[@$:_0-9a-z]*)|([@_a-z]([@_a-z0-9])*){0,1}(\\+(\\d+)){0,1}){0,1}([)]{0,1})(,X|,Y){0,1}([)]{0,1})(.*)", RegexOptions.IgnoreCase | RegexOptions.Compiled);
+ private Regex _codeRegex = new Regex("^(\\s*)([a-z]{3})([*]{0,1})($|[ ]){1}([(\\[]{0,1})(([$][0-9a-f]*)|(#[@$:_0-9a-z]*)|([@_a-z]([@_a-z0-9])*){0,1}(\\+(\\d+)){0,1}){0,1}([)\\]]{0,1})(,X|,Y){0,1}([)\\]]{0,1})(.*)", RegexOptions.IgnoreCase | RegexOptions.Compiled);
public event EventHandler ScrollPositionChanged;
public event EventHandler SelectedLineChanged;
private bool _disableScrollPositionChangedEvent;
@@ -902,8 +902,6 @@ namespace Mesen.GUI.Debugger.Controls
private void DrawLineText(Graphics g, int currentLine, int marginLeft, int positionY, CodeLineData lineData, float codeStringLength, Color? textColor, int lineHeight)
{
string codeString = lineData.Text;
- string addressString = lineData.EffectiveAddress>= 0 ? (" [" + lineData.EffectiveAddress.ToString("X6") + "]") : "";
- float addressStringLength = g.MeasureString(addressString, this.Font, int.MaxValue, StringFormat.GenericTypographic).Width;
string commentString = lineData.Comment;
DebugInfo info = ConfigManager.Config.Debug;
@@ -962,24 +960,15 @@ namespace Mesen.GUI.Debugger.Controls
int codePartCount = colors.Count;
List parts = new List() { padding, opcode, invalidStar, " ", paren1, operand, paren2, indirect, paren3 };
- string memoryAddress = "";
- if(!string.IsNullOrWhiteSpace(addressString)) {
- colors.Add(info.CodeEffectiveAddressColor);
- parts.Add(addressString);
- memoryAddress = addressString.Substring(3).Trim();
- //Update the contents of "arrayPosition" based on the address string, rather than use the one from the original address
- int plusIndex = memoryAddress.IndexOf("+");
- arrayPosition = plusIndex >= 0 ? memoryAddress.Substring(plusIndex+1) : "";
- } else if(operand.Length > 0 && operand[0] != '#') {
- memoryAddress = operand.Trim();
+ if(lineData.EffectiveAddress >= 0) {
+ colors.Add(info.CodeEffectiveAddressColor);
+ parts.Add(" [" + lineData.EffectiveAddress.ToString("X6") + "]");
}
- if(this.ShowMemoryValues && memoryAddress.Length > 0) {
- if(lineData.Value >= 0) {
- colors.Add(defaultColor);
- parts.Add(" = $" + lineData.Value.ToString("X4"));
- }
+ if(this.ShowMemoryValues && lineData.ValueSize > 0) {
+ colors.Add(defaultColor);
+ parts.Add(lineData.GetValueString());
}
//Display the rest of the line (used by trace logger)