Debugger: Step Back - Allow stepping back 1 scanline/frame at a time …

…+ remove restriction that caused step back to only work for up to 30 frames

Core/Debugger/Debugger.cpp

@@ -617,7 +617,7 @@ void Debugger::Step(CpuType cpuType, int32_t stepCount, StepType type, BreakSour
 		if(type != StepType::StepBack) {
 			debugger->ResetStepBackCache();
 		} else {
-			debugger->StepBack();
+			debugger->StepBack(stepCount);
 		}
 
 		debugger->Step(stepCount, type);

Core/Debugger/IDebugger.h

@@ -39,7 +39,8 @@ class IDebugger
 	bool CheckStepBack() { return _stepBackManager->CheckStepBack(); }
 	bool IsStepBack() { return _stepBackManager->IsRewinding(); }
 	void ResetStepBackCache() { return _stepBackManager->ResetCache(); }
-	void StepBack() { return _stepBackManager->StepBack(); }
+	void StepBack(int32_t stepCount) { return _stepBackManager->StepBack((StepBackType)stepCount); }
+	virtual StepBackConfig GetStepBackConfig() { return { GetCpuCycleCount(), 0, 0 }; }
 
 	FrozenAddressManager& GetFrozenAddressManager() { return _frozenAddressManager; }
 

Core/Debugger/StepBackManager.cpp

@@ -13,10 +13,20 @@ StepBackManager::StepBackManager(Emulator* emu, IDebugger* debugger)
 	_debugger = debugger;
 }
 
-void StepBackManager::StepBack()
+void StepBackManager::StepBack(StepBackType type)
 {
 	if(!_active) {
-		_targetClock = _debugger->GetCpuCycleCount();
+		StepBackConfig cfg = _debugger->GetStepBackConfig();
+
+		int64_t target = 0;
+		switch(type) {
+			default: case StepBackType::Instruction: target = cfg.CurrentCycle; break;
+			case StepBackType::Scanline: target = (int64_t)cfg.CurrentCycle - cfg.CyclesPerScanline; break;
+			case StepBackType::Frame: target = (int64_t)cfg.CurrentCycle - cfg.CyclesPerFrame; break;
+		}
+
+		_targetClock = (uint64_t)std::max<int64_t>(0, target);
+
 		_active = true;
 		_allowRetry = true;
 		_stateClockLimit = StepBackManager::DefaultClockLimit;
@@ -29,7 +39,7 @@ bool StepBackManager::CheckStepBack()
 		return false;
 	}
 
-	uint64_t clock = _debugger->GetCpuCycleCount();
+	uint64_t clock = _debugger->GetStepBackConfig().CurrentCycle;
 
 	if(!_rewindManager->IsStepBack()) {
 		if(_cache.size() > 1) {
@@ -39,11 +49,9 @@ bool StepBackManager::CheckStepBack()
 				_cache.pop_back();
 				if(_cache.size()) {
 					//If cache isn't empty, load the last state
-					_rewindManager->SetIgnoreLoadState(true);
-					_emu->Deserialize(_cache.back().SaveState, SaveStateManager::FileFormatVersion, true);
-					_rewindManager->SetIgnoreLoadState(false);
+					_emu->Deserialize(_cache.back().SaveState, SaveStateManager::FileFormatVersion, true, std::nullopt, false);
 
-					_emu->GetRewindManager()->StopRewinding(true);
+					_emu->GetRewindManager()->StopRewinding(true, true);
 					_active = false;
 					_prevClock = clock;
 					return true;
@@ -57,7 +65,7 @@ bool StepBackManager::CheckStepBack()
 		//Start rewinding on next instruction after StepBack() is called
 		_cache.clear();
 		_rewindManager->StartRewinding(true);
-		clock = _debugger->GetCpuCycleCount();
+		clock = _debugger->GetStepBackConfig().CurrentCycle;
 	}
 
 	if(clock < _targetClock && _targetClock - clock < _stateClockLimit) {
@@ -70,10 +78,8 @@ bool StepBackManager::CheckStepBack()
 	if(clock >= _targetClock) {
 		//If the CPU is back to where it was before step back, check if the cache contains data
 		if(_cache.size() > 0) {
-			//If it does, load the last state
-			_rewindManager->SetIgnoreLoadState(true);
-			_emu->Deserialize(_cache.back().SaveState, SaveStateManager::FileFormatVersion, true);
-			_rewindManager->SetIgnoreLoadState(false);
+			_emu->Deserialize(_cache.back().SaveState, SaveStateManager::FileFormatVersion, true, std::nullopt, false);
+			_rewindManager->StopRewinding(true, true);
 		} else if(_allowRetry && clock > _prevClock && (clock - _prevClock) > StepBackManager::DefaultClockLimit) {
 			//Cache is empty, this can happen when a single instruction takes more than X clocks (e.g block transfers, dma)
 			//In this case, re-run the step back process again but start recordings state earlier
@@ -82,10 +88,10 @@ bool StepBackManager::CheckStepBack()
 			_stateClockLimit = (clock - _prevClock) + StepBackManager::DefaultClockLimit;
 			_allowRetry = false;
 			return false;
+		} else {
+			//Stop rewinding, even if the target was not found
+			_rewindManager->StopRewinding(true);
 		}
-
-		//Stop rewinding, even if the target was not found
-		_rewindManager->StopRewinding(true);
 		_active = false;
 		_prevClock = clock;
 		return true;

Core/Debugger/StepBackManager.h

@@ -11,6 +11,20 @@ struct StepBackCacheEntry
 	uint64_t Clock;
 };
 
+struct StepBackConfig
+{
+	uint64_t CurrentCycle;
+	uint32_t CyclesPerScanline;
+	uint32_t CyclesPerFrame;
+};
+
+enum class StepBackType
+{
+	Instruction,
+	Scanline,
+	Frame
+};
+
 class StepBackManager
 {
 private:
@@ -30,7 +44,7 @@ class StepBackManager
 public:
 	StepBackManager(Emulator* emu, IDebugger* debugger);
 
-	void StepBack();
+	void StepBack(StepBackType type);
 	bool CheckStepBack();
 
 	void ResetCache() { _cache.clear(); }

Core/Gameboy/Debugger/GbDebugger.cpp

@@ -239,6 +239,15 @@ void GbDebugger::Step(int32_t stepCount, StepType type)
 	_step.reset(new StepRequest(step));
 }
 
+StepBackConfig GbDebugger::GetStepBackConfig()
+{
+	return {
+		GetCpuCycleCount(),
+		456,
+		456 * 154
+	};
+}
+
 void GbDebugger::DrawPartialFrame()
 {
 	_ppu->DebugSendFrame();

Core/Gameboy/Debugger/GbDebugger.h

@@ -66,6 +66,7 @@ class GbDebugger final : public IDebugger
 
 	void Run() override;
 	void Step(int32_t stepCount, StepType type) override;
+	StepBackConfig GetStepBackConfig() override;
 
 	void DrawPartialFrame() override;
 

Core/NES/Debugger/NesDebugger.cpp

@@ -268,6 +268,15 @@ void NesDebugger::Step(int32_t stepCount, StepType type)
 	_step.reset(new StepRequest(step));
 }
 
+StepBackConfig NesDebugger::GetStepBackConfig()
+{
+	return {
+		GetCpuCycleCount(),
+		341 / 3,
+		341u * _console->GetPpu()->GetScanlineCount() / 3
+	};
+}
+
 void NesDebugger::DrawPartialFrame()
 {
 	_console->GetPpu()->DebugSendFrame();

Core/NES/Debugger/NesDebugger.h

@@ -79,6 +79,7 @@ class NesDebugger final : public IDebugger
 
 	void Run() override;
 	void Step(int32_t stepCount, StepType type) override;
+	StepBackConfig GetStepBackConfig() override;
 
 	void DrawPartialFrame() override;
 

Core/PCE/Debugger/PceDebugger.cpp

@@ -249,6 +249,15 @@ void PceDebugger::Step(int32_t stepCount, StepType type)
 	_step.reset(new StepRequest(step));
 }
 
+StepBackConfig PceDebugger::GetStepBackConfig()
+{
+	return {
+		_memoryManager->GetState().CycleCount,
+		PceConstants::ClockPerScanline,
+		PceConstants::ClockPerScanline * _vce->GetScanlineCount()
+	};
+}
+
 void PceDebugger::DrawPartialFrame()
 {
 	_vpc->DebugSendFrame();

Core/PCE/Debugger/PceDebugger.h

@@ -79,6 +79,7 @@ class PceDebugger final : public IDebugger
 
 	void Run() override;
 	void Step(int32_t stepCount, StepType type) override;
+	StepBackConfig GetStepBackConfig() override;
 
 	void DrawPartialFrame() override;
 

Core/SMS/Debugger/SmsDebugger.cpp

@@ -229,13 +229,22 @@ void SmsDebugger::Step(int32_t stepCount, StepType type)
 		case StepType::CpuCycleStep: step.CpuCycleStepCount = stepCount; break;
 		case StepType::PpuStep: step.PpuStepCount = stepCount; break;
 		case StepType::PpuScanline: step.PpuStepCount = 342 * stepCount; break;
-		case StepType::PpuFrame: step.PpuStepCount = 342 * (_console->GetModel() == SmsModel::Sms && _console->GetRegion() == ConsoleRegion::Pal ? 313 : 262) * stepCount; break;
+		case StepType::PpuFrame: step.PpuStepCount = 342 * _vdp->GetScanlineCount() * stepCount; break;
 		case StepType::SpecificScanline: step.BreakScanline = stepCount; break;
 	}
 
 	_step.reset(new StepRequest(step));
 }
 
+StepBackConfig SmsDebugger::GetStepBackConfig()
+{
+	return {
+		_cpu->GetCycleCount() * 3,
+		342 * 2,
+		342u * 2 * _vdp->GetScanlineCount()
+	};
+}
+
 void SmsDebugger::DrawPartialFrame()
 {
 	_vdp->DebugSendFrame();

Core/SMS/Debugger/SmsDebugger.h

@@ -72,6 +72,7 @@ class SmsDebugger final : public IDebugger
 
 	void Run() override;
 	void Step(int32_t stepCount, StepType type) override;
+	StepBackConfig GetStepBackConfig() override;
 
 	void DrawPartialFrame() override;
 

Core/SNES/Debugger/SnesDebugger.cpp

@@ -318,6 +318,19 @@ void SnesDebugger::Step(int32_t stepCount, StepType type)
 	_step.reset(new StepRequest(step));
 }
 
+StepBackConfig SnesDebugger::GetStepBackConfig()
+{
+	if(_cpuType == CpuType::Snes) {
+		return {
+			_memoryManager->GetMasterClock(),
+			1364,
+			1364u * (_ppu->GetVblankEndScanline() + 1)
+		};
+	} else {
+		return IDebugger::GetStepBackConfig();
+	}
+}
+
 void SnesDebugger::DrawPartialFrame()
 {
 	_ppu->DebugSendFrame();

Core/SNES/Debugger/SnesDebugger.h

@@ -99,6 +99,7 @@ class SnesDebugger final : public IDebugger
 
 	void Run() override;
 	void Step(int32_t stepCount, StepType type) override;
+	StepBackConfig GetStepBackConfig() override;
 
 	void DrawPartialFrame() override;
 

Core/Shared/Emulator.cpp

@@ -896,7 +896,7 @@ void Emulator::Serialize(ostream& out, bool includeSettings, int compressionLeve
 	s.SaveTo(out, compressionLevel);
 }
 
-bool Emulator::Deserialize(istream& in, uint32_t fileFormatVersion, bool includeSettings, optional<ConsoleType> srcConsoleType)
+bool Emulator::Deserialize(istream& in, uint32_t fileFormatVersion, bool includeSettings, optional<ConsoleType> srcConsoleType, bool sendNotification)
 {
 	Serializer s(fileFormatVersion, false);
 	if(!s.LoadFrom(in)) {
@@ -931,7 +931,9 @@ bool Emulator::Deserialize(istream& in, uint32_t fileFormatVersion, bool include
 
 	s.Stream(_console, "");
 
-	_notificationManager->SendNotification(ConsoleNotificationType::StateLoaded);
+	if(sendNotification) {
+		_notificationManager->SendNotification(ConsoleNotificationType::StateLoaded);
+	}
 	return true;
 }
 

Core/Shared/Emulator.h

@@ -180,7 +180,7 @@ class Emulator
 	void SuspendDebugger(bool release);
 
 	void Serialize(ostream& out, bool includeSettings, int compressionLevel = 1);
-	bool Deserialize(istream& in, uint32_t fileFormatVersion, bool includeSettings, optional<ConsoleType> consoleType = std::nullopt);
+	bool Deserialize(istream& in, uint32_t fileFormatVersion, bool includeSettings, optional<ConsoleType> consoleType = std::nullopt, bool sendNotification = true);
 
 	SoundMixer* GetSoundMixer() { return _soundMixer.get(); }
 	VideoRenderer* GetVideoRenderer() { return _videoRenderer.get(); }

Core/Shared/RewindData.cpp

@@ -36,7 +36,7 @@ void RewindData::ProcessXorState(T& data, deque<RewindData>& prevStates, int32_t
 	}
 }
 
-void RewindData::LoadState(Emulator* emu, deque<RewindData>& prevStates, int32_t position)
+void RewindData::LoadState(Emulator* emu, deque<RewindData>& prevStates, int32_t position, bool sendNotification)
 {
 	if(_saveStateData.size() == 0) {
 		return;
@@ -54,7 +54,7 @@ void RewindData::LoadState(Emulator* emu, deque<RewindData>& prevStates, int32_t
 	stream.write((char*)data.data(), data.size());
 	stream.seekg(0, ios::beg);
 
-	emu->Deserialize(stream, SaveStateManager::FileFormatVersion, true);
+	emu->Deserialize(stream, SaveStateManager::FileFormatVersion, true, std::nullopt, sendNotification);
 }
 
 void RewindData::SaveState(Emulator* emu, deque<RewindData>& prevStates, int32_t position)

Core/Shared/RewindData.h

@@ -22,6 +22,6 @@ class RewindData
 	void GetStateData(stringstream& stateData, deque<RewindData>& prevStates, int32_t position);
 	uint32_t GetStateSize() { return (uint32_t)_saveStateData.size(); }
 
-	void LoadState(Emulator* emu, deque<RewindData>& prevStates, int32_t position = -1);
+	void LoadState(Emulator* emu, deque<RewindData>& prevStates, int32_t position = -1, bool sendNotification = true);
 	void SaveState(Emulator* emu, deque<RewindData>& prevStates, int32_t position = -1);
 };