Support for reserved hardware breakpoint (for stepping on AVR8 targets)

src/TargetController/TargetControllerComponent.cpp

@@ -510,12 +510,23 @@ namespace TargetController
         if (!this->environmentConfig.targetConfig.hardwareBreakpoints) {
             Logger::warning("Hardware breakpoints have been disabled");
 
-        } else if (targetDescriptor.breakpointResources.maximumHardwareBreakpoints.has_value()) {
+        } else {
-            Logger::info(
+            const auto& breakpointResources = targetDescriptor.breakpointResources;
-                "Available hardware breakpoints: " + std::to_string(
+            if (breakpointResources.maximumHardwareBreakpoints.has_value()) {
-                    *(targetDescriptor.breakpointResources.maximumHardwareBreakpoints)
+                Logger::info(
-                )
+                    "Available hardware breakpoints: " + std::to_string(
-            );
+                        *(breakpointResources.maximumHardwareBreakpoints)
+                    )
+                );
+            }
+
+            if (breakpointResources.reservedHardwareBreakpoints > 0) {
+                Logger::info(
+                    "Reserved hardware breakpoints: " + std::to_string(
+                        breakpointResources.reservedHardwareBreakpoints
+                    )
+                );
+            }
         }
 
         this->programMemoryCache = std::make_unique<Targets::TargetMemoryCache>(
@@ -971,7 +982,8 @@ namespace TargetController
 
             if (
                 !targetBreakpointResources.maximumHardwareBreakpoints.has_value()
-                || this->hardwareBreakpointsByAddress.size() < *(targetBreakpointResources.maximumHardwareBreakpoints)
+                || this->hardwareBreakpointsByAddress.size() < (*(targetBreakpointResources.maximumHardwareBreakpoints)
+                    - targetBreakpointResources.reservedHardwareBreakpoints)
             ) {
                 exhaustedResourcesWarning = true;
 

src/Targets/Microchip/AVR/AVR8/Avr8.cpp

@@ -697,7 +697,7 @@ namespace Targets::Microchip::Avr::Avr8Bit
     }
 
     BreakpointResources Avr8::getBreakpointResources() {
-        auto maxHardwareBreakpoints = 0;
+        auto maxHardwareBreakpoints = static_cast<std::uint16_t>(0);
 
         switch (this->targetConfig.physicalInterface) {
             case PhysicalInterface::JTAG: {
@@ -719,7 +719,11 @@ namespace Targets::Microchip::Avr::Avr8Bit
 
         return BreakpointResources(
             maxHardwareBreakpoints,
-            std::nullopt
+            std::nullopt,
+            std::min(
+                static_cast<std::uint16_t>(this->targetConfig.reserveSteppingBreakpoint ? 1 : 0),
+                maxHardwareBreakpoints
+            )
         );
     }
 

src/Targets/Microchip/AVR/AVR8/Avr8TargetConfig.cpp

@@ -35,31 +35,51 @@ namespace Targets::Microchip::Avr::Avr8Bit
 
         // The 'manageDwenFuseBit' param used to be 'updateDwenFuseBit' - we still support the old, for now.
         if (targetNode["updateDwenFuseBit"]) {
-            this->manageDwenFuseBit = targetNode["updateDwenFuseBit"].as<bool>();
+            this->manageDwenFuseBit = targetNode["updateDwenFuseBit"].as<bool>(
+                this->manageDwenFuseBit
+            );
         }
 
         if (targetNode["manageDwenFuseBit"]) {
-            this->manageDwenFuseBit = targetNode["manageDwenFuseBit"].as<bool>();
+            this->manageDwenFuseBit = targetNode["manageDwenFuseBit"].as<bool>(
+                this->manageDwenFuseBit
+            );
         }
 
         if (targetNode["cycleTargetPowerPostDwenUpdate"]) {
-            this->cycleTargetPowerPostDwenUpdate = targetNode["cycleTargetPowerPostDwenUpdate"].as<bool>();
+            this->cycleTargetPowerPostDwenUpdate = targetNode["cycleTargetPowerPostDwenUpdate"].as<bool>(
+                this->cycleTargetPowerPostDwenUpdate
+            );
         }
 
         if (targetNode["disableDebugWirePreDisconnect"]) {
-            this->disableDebugWireOnDeactivate = targetNode["disableDebugWirePreDisconnect"].as<bool>();
+            this->disableDebugWireOnDeactivate = targetNode["disableDebugWirePreDisconnect"].as<bool>(
+                this->disableDebugWireOnDeactivate
+            );
         }
 
         if (targetNode["targetPowerCycleDelay"]) {
-            this->targetPowerCycleDelay = std::chrono::milliseconds(targetNode["targetPowerCycleDelay"].as<int>());
+            this->targetPowerCycleDelay = std::chrono::milliseconds(targetNode["targetPowerCycleDelay"].as<int>(
+                this->targetPowerCycleDelay.count()
+            ));
         }
 
         if (targetNode["manageOcdenFuseBit"]) {
-            this->manageOcdenFuseBit = targetNode["manageOcdenFuseBit"].as<bool>();
+            this->manageOcdenFuseBit = targetNode["manageOcdenFuseBit"].as<bool>(
+                this->manageOcdenFuseBit
+            );
         }
 
         if (targetNode["preserveEeprom"]) {
-            this->preserveEeprom = targetNode["preserveEeprom"].as<bool>();
+            this->preserveEeprom = targetNode["preserveEeprom"].as<bool>(
+                this->preserveEeprom
+            );
+        }
+
+        if (targetNode["reserveSteppingBreakpoint"]) {
+            this->reserveSteppingBreakpoint = targetNode["reserveSteppingBreakpoint"].as<bool>(
+                this->reserveSteppingBreakpoint
+            );
         }
     }
 }

src/Targets/Microchip/AVR/AVR8/Avr8TargetConfig.hpp

@@ -93,6 +93,11 @@ namespace Targets::Microchip::Avr::Avr8Bit
          */
         bool preserveEeprom = true;
 
+        /**
+         * Determines if Bloom will reserve a single hardware breakpoint for stepping operations.
+         */
+        bool reserveSteppingBreakpoint = true;
+
         explicit Avr8TargetConfig(const TargetConfig& targetConfig);
 
     private:

src/Targets/TargetBreakpoint.hpp

@@ -2,6 +2,7 @@
 
 #include <cstdint>
 #include <optional>
+#include <cassert>
 
 #include "TargetMemory.hpp"
 
@@ -40,13 +41,21 @@ namespace Targets
     {
         std::optional<std::uint16_t> maximumHardwareBreakpoints;
         std::optional<std::uint16_t> maximumSoftwareBreakpoints;
+        std::uint16_t reservedHardwareBreakpoints;
 
         BreakpointResources(
             std::optional<std::uint16_t> maximumHardwareBreakpoints,
-            std::optional<std::uint16_t> maximumSoftwareBreakpoints
+            std::optional<std::uint16_t> maximumSoftwareBreakpoints,
+            std::uint16_t reservedHardwareBreakpoints
         )
             : maximumHardwareBreakpoints(maximumHardwareBreakpoints)
             , maximumSoftwareBreakpoints(maximumSoftwareBreakpoints)
-        {}
+            , reservedHardwareBreakpoints(reservedHardwareBreakpoints)
+        {
+            assert(
+                !this->maximumHardwareBreakpoints.has_value()
+                || this->maximumHardwareBreakpoints >= this->reservedHardwareBreakpoints
+            );
+        }
     };
 }