Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

+534
View File
@@ -0,0 +1,534 @@
// Copyright 2015 by Joseph Forgione
// This file is part of VCC (Virtual Color Computer).
//
// VCC (Virtual Color Computer) is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// VCC (Virtual Color Computer) is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with VCC (Virtual Color Computer). If not, see <http://www.gnu.org/licenses/>.
//
// Debugger Interface - Part of the Debugger package for VCC
// Author: Chet Simpson
#include "Debugger.h"
#include "DebuggerUtils.h"
#include "../../src/core/MachineDefs.h"
#include <sstream>
#include <iomanip>
#include "../../src/core/tcc1014mmu.h" // FIXME: May want this decoupled from Debugger for Memory Write
#include "audio.h"
#include "Disassembler.h"
#include <assert.h>
namespace VCC::Debugger
{
void Debugger::Reset()
{
VCC::Util::section_locker lock(Section_);
ExecutionMode_ = ExecutionMode::Run;
PendingCommand_ = ExecutionMode::Halt;
HasPendingCommand_ = false;
ProcessorState_ = CPUState();
for (const auto& callback : RegisteredClients_)
{
callback.second->OnReset();
}
Decoder_ = std::make_unique<OpDecoder>();
TraceEnabled_ = false;
TraceRunning_ = false;
TraceMarks_.clear();
}
void Debugger::RegisterClient(HWND window, std::unique_ptr<Client> client)
{
VCC::Util::section_locker lock(Section_);
if (!client)
{
throw std::invalid_argument("client cannot be null");
}
if (RegisteredClients_.find(window) != RegisteredClients_.end())
{
throw std::invalid_argument("Udpate client is already registered with the debugger");
}
RegisteredClients_[window] = move(client);
}
void Debugger::RemoveClient(HWND window)
{
VCC::Util::section_locker lock(Section_);
if (RegisteredClients_.find(window) == RegisteredClients_.end())
{
throw std::invalid_argument("window is not registered with the debugger");
}
RegisteredClients_.erase(window);
}
void Debugger::Halt()
{
ExecutionMode_ = ExecutionMode::Halt;
}
bool Debugger::IsHalted() const
{
return ExecutionMode_ == ExecutionMode::Halt;
}
bool Debugger::IsHalted(unsigned short& returnPc) const
{
if (ExecutionMode_ != ExecutionMode::Halt)
{
return false;
}
{
VCC::Util::section_locker lock(Section_);
returnPc = ProcessorState_.PC;
}
return true;
}
bool Debugger::IsStepping() const
{
return ExecutionMode_ == ExecutionMode::Step;
}
CPUState Debugger::GetProcessorStateCopy() const
{
VCC::Util::section_locker lock(Section_);
return ProcessorState_;
}
bool Debugger::HasPendingCommandNoLock() const
{
return HasPendingCommand_;
}
Debugger::ExecutionMode Debugger::ConsumePendingCommandNoLock()
{
if (!HasPendingCommandNoLock())
{
throw std::runtime_error("No pending command to consume");
}
HasPendingCommand_ = false;
return PendingCommand_;
}
void Debugger::SetBreakpoints(breakpointsbuffer_type breakpoints)
{
VCC::Util::section_locker lock(Section_);
Breakpoints_ = move(breakpoints);
BreakpointsChanged_ = true;
}
bool Debugger::IsTracingEnabled() const
{
return TraceEnabled_;
}
bool Debugger::IsTracing() const
{
return TraceRunning_;
}
void Debugger::TraceCaptureInterruptRequest(unsigned char irq, long cycleTime, const CPUState& state)
{
Decoder_->CaptureInterrupt(TraceEvent::IRQRequested, Decoder_->ToIRQType(irq), cycleTime, state);
CheckStopTrace(state);
}
void Debugger::TraceCaptureInterruptMasked(unsigned char irq, long cycleTime, const CPUState& state)
{
Decoder_->CaptureInterrupt(TraceEvent::IRQMasked, Decoder_->ToIRQType(irq), cycleTime, state);
CheckStopTrace(state);
}
void Debugger::TraceCaptureInterruptServicing(unsigned char irq, long cycleTime, const CPUState& state)
{
Decoder_->CaptureInterrupt(TraceEvent::IRQServicing, Decoder_->ToIRQType(irq), cycleTime, state);
CheckStopTrace(state);
}
void Debugger::TraceCaptureInterruptExecuting(unsigned char irq, long cycleTime, const CPUState& state)
{
Decoder_->CaptureInterrupt(TraceEvent::IRQExecuting, Decoder_->ToIRQType(irq), cycleTime, state);
CheckStopTrace(state);
}
void Debugger::TraceCaptureBefore(long cycles, const CPUState& state)
{
Decoder_->CaptureBefore(cycles, state);
CheckStopTrace(state);
}
void Debugger::TraceCaptureAfter(long cycles, const CPUState& state)
{
Decoder_->CaptureAfter(cycles, state);
CheckStopTrace(state);
}
void Debugger::CheckStopTrace(CPUState state)
{
if (!TraceRunning_)
{
return;
}
// Max samples reached?
if (Decoder_->GetSampleCount() >= TraceMaxSamples_)
{
TraceRunning_ = false;
TraceEnabled_ = false;
TraceTriggerChanged_ = true;
return;
}
// Hit a Stop Address?
if (find(TraceStopTriggers_.begin(), TraceStopTriggers_.end(), state.PC) != TraceStopTriggers_.end())
{
TraceRunning_ = false;
TraceEnabled_ = false;
TraceTriggerChanged_ = true;
return;
}
}
#if USE_NEWTIMING
void Debugger::TraceCaptureScreenEvent(TraceEvent evt, double cycles, unsigned int n)
{
if (!TraceRunning_ || !TraceScreen_)
{
return;
}
Decoder_->CaptureScreenEvent(evt, cycles, n);
}
void Debugger::TraceCaptureScreenEvent(TraceEvent evt, double cycles, unsigned int n, const char* s)
{
if (!TraceRunning_ || !TraceScreen_)
{
return;
}
Decoder_->CaptureScreenEvent(evt, cycles, n, s);
}
#else
void Debugger::TraceCaptureScreenEvent(TraceEvent evt, double cycles)
{
if (!TraceRunning_ || !TraceScreen_)
{
return;
}
Decoder_->CaptureScreenEvent(evt, cycles);
}
#endif
void Debugger::TraceEmulatorCycle(TraceEvent evt, int state, double lineNS, double irqNS, double soundNS, double cycles, double drift)
{
if (!TraceRunning_ || !TraceEmulation_)
{
return;
}
Decoder_->CaptureEmulatorCycle(evt, state, lineNS, irqNS, soundNS, cycles, drift);
}
void Debugger::LockTrace() const
{
Section_.lock();
}
void Debugger::UnlockTrace() const
{
Section_.unlock();
}
void Debugger::SetTraceEnable()
{
TraceEnabled_ = true;
}
void Debugger::SetTraceDisable()
{
TraceEnabled_ = false;
TraceRunning_ = false;
}
void Debugger::TraceStart()
{
TraceRunning_ = true;
}
void Debugger::TraceStop()
{
TraceRunning_ = false;
TraceEnabled_ = false;
}
void Debugger::ResetTrace()
{
TraceEnabled_ = false;
TraceRunning_ = false;
{
VCC::Util::section_locker lock(Section_);
Decoder_->Reset(TraceMaxSamples_);
}
}
void Debugger::SetTraceMaxSamples(long samples)
{
VCC::Util::section_locker lock(Section_);
TraceMaxSamples_ = samples;
Decoder_->Reset(TraceMaxSamples_);
}
void Debugger::SetTraceStartTriggers(triggerbuffer_type startTriggers)
{
VCC::Util::section_locker lock(Section_);
TraceStartTriggers_ = move(startTriggers);
TraceTriggerChanged_ = true;
}
void Debugger::SetTraceStopTriggers(triggerbuffer_type stopTriggers)
{
VCC::Util::section_locker lock(Section_);
TraceStopTriggers_ = move(stopTriggers);
TraceTriggerChanged_ = true;
}
void Debugger::SetTraceOptions(bool screen, bool emulation)
{
VCC::Util::section_locker lock(Section_);
TraceScreen_ = screen;
TraceEmulation_ = emulation;
}
long Debugger::GetTraceSamples() const
{
VCC::Util::section_locker lock(Section_);
return Decoder_->GetSampleCount();
}
const Debugger::Debugger::tracebuffer_type& Debugger::GetTraceResult() const
{
return Decoder_->GetTrace();
}
void Debugger::SetTraceMark(int mark, long sample)
{
VCC::Util::section_locker lock(Section_);
assert(sample >= 0);
TraceMarks_[mark] = sample;
}
void Debugger::ClearTraceMarks()
{
VCC::Util::section_locker lock(Section_);
TraceMarks_.clear();
}
void Debugger::GetTraceMarkSamples(tracebuffer_type &result) const
{
VCC::Util::section_locker lock(Section_);
result.clear();
auto& trace = Decoder_->GetTrace();
for (const auto& kv: TraceMarks_)
{
result.push_back(trace[kv.second]);
}
}
void Debugger::QueueRun()
{
ApplyHaltpoints(true);
VCC::Util::section_locker lock(Section_);
PendingCommand_ = ExecutionMode::Run;
HasPendingCommand_ = true;
}
void Debugger::QueueStep()
{
VCC::Util::section_locker lock(Section_);
PendingCommand_ = ExecutionMode::Step;
HasPendingCommand_ = true;
}
void Debugger::QueueHalt()
{
ApplyHaltpoints(false);
VCC::Util::section_locker lock(Section_);
PendingCommand_ = ExecutionMode::Halt;
HasPendingCommand_ = true;
}
void Debugger::ToggleRun() {
if (IsHalted()) {
PauseAudio(0);
QueueRun();
} else {
QueueHalt();
PauseAudio(1);
}
return;
}
void Debugger::Update()
{
{
VCC::Util::section_locker lock(Section_);
ProcessorState_ = CPUGetState();
if (BreakpointsChanged_)
{
CPUSetBreakpoints(Breakpoints_);
BreakpointsChanged_ = false;
}
if (TraceTriggerChanged_)
{
CPUSetTraceTriggers(TraceStartTriggers_);
TraceTriggerChanged_ = false;
}
if (HasPendingCommandNoLock())
{
ExecutionMode_ = ProcessNewModeNoLock(ConsumePendingCommandNoLock());
}
if (HasPendingWriteNoLock())
{
ProcessWrite(ConsumePendingWriteNoLock());
}
}
for (const auto& callback : RegisteredClients_)
{
callback.second->OnUpdate();
}
}
Debugger::ExecutionMode Debugger::ProcessNewModeNoLock(ExecutionMode cpuCmd) const
{
// Run -> Halt
if (ExecutionMode_ == ExecutionMode::Run && cpuCmd == ExecutionMode::Halt)
{
return ExecutionMode::Halt;
}
// Halt -> Run
if (ExecutionMode_ == ExecutionMode::Halt && cpuCmd == ExecutionMode::Run)
{
return ExecutionMode::Run;
}
// Halt -> Step
if (ExecutionMode_ == ExecutionMode::Halt && cpuCmd == ExecutionMode::Step)
{
return ExecutionMode::Step;
}
return ExecutionMode_;
}
void Debugger::QueueWrite(unsigned short addr, unsigned char value)
{
VCC::Util::section_locker lock(Section_);
PendingWrite_ = PendingWrite(addr, value);
HasPendingWrite_ = true;
}
bool Debugger::HasPendingWriteNoLock() const
{
return HasPendingWrite_;
}
Debugger::PendingWrite Debugger::ConsumePendingWriteNoLock()
{
if (!HasPendingWriteNoLock())
{
throw std::runtime_error("No pending memory writes to consume");
}
HasPendingWrite_ = false;
return PendingWrite_;
}
void Debugger::ProcessWrite(PendingWrite memWrite)
{
MemWrite8(memWrite.value, memWrite.addr);
}
bool Debugger::Halt_Enabled() const
{
return Halt_Enabled_TF;
}
void Debugger::Enable_Halt(bool flag)
{
Halt_Enabled_TF = flag;
}
bool Debugger::Break_Enabled() const
{
return Break_Enabled_TF;
}
void Debugger::Enable_Break(bool flag)
{
Break_Enabled_TF = flag;
}
}