Added TargetMemoryAddress, TargetMemorySize, TargetProgramCounter and TargetStackPointer aliases

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

@@ -90,8 +90,8 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit
         void step() override;
         void reset() override;
 
-        void setBreakpoint(std::uint32_t address) override;
-        void removeBreakpoint(std::uint32_t address) override;
+        void setBreakpoint(TargetProgramCounter address) override;
+        void removeBreakpoint(TargetProgramCounter address) override;
         void clearAllBreakpoints() override;
 
         void writeRegisters(TargetRegisters registers) override;
@@ -99,23 +99,23 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit
 
         TargetMemoryBuffer readMemory(
             TargetMemoryType memoryType,
-            std::uint32_t startAddress,
-            std::uint32_t bytes,
+            TargetMemoryAddress startAddress,
+            TargetMemorySize bytes,
             const std::set<Targets::TargetMemoryAddressRange>& excludedAddressRanges = {}
         ) override;
         void writeMemory(
             TargetMemoryType memoryType,
-            std::uint32_t startAddress,
+            TargetMemoryAddress startAddress,
             const TargetMemoryBuffer& buffer
         ) override;
 
         TargetState getState() override;
 
-        std::uint32_t getProgramCounter() override;
+        TargetProgramCounter getProgramCounter() override;
         TargetRegister getProgramCounterRegister();
-        void setProgramCounter(std::uint32_t programCounter) override;
+        void setProgramCounter(TargetProgramCounter programCounter) override;
 
-        std::uint32_t getStackPointer() override;
+        TargetStackPointer getStackPointer() override;
 
         std::map<int, TargetPinState> getPinStates(int variantId) override;
         void setPinState(
@@ -186,6 +186,6 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit
          * @param address
          * @return
          */
-        ProgramMemorySection getProgramMemorySectionFromAddress(std::uint32_t address);
+        ProgramMemorySection getProgramMemorySectionFromAddress(TargetMemoryAddress address);
     };
 }

src/Targets/Target.hpp

@@ -202,14 +202,14 @@ namespace Bloom::Targets
          *
          * @param address
          */
-        virtual void setBreakpoint(std::uint32_t address) = 0;
+        virtual void setBreakpoint(TargetMemoryAddress address) = 0;
 
         /**
          * Should remove a breakpoint at the given address.
          *
          * @param address
          */
-        virtual void removeBreakpoint(std::uint32_t address) = 0;
+        virtual void removeBreakpoint(TargetMemoryAddress address) = 0;
 
         /**
          * Should clear all breakpoints on the target.
@@ -246,8 +246,8 @@ namespace Bloom::Targets
          */
         virtual TargetMemoryBuffer readMemory(
             TargetMemoryType memoryType,
-            std::uint32_t startAddress,
-            std::uint32_t bytes,
+            TargetMemoryAddress startAddress,
+            TargetMemorySize bytes,
             const std::set<Targets::TargetMemoryAddressRange>& excludedAddressRanges = {}
         ) = 0;
 
@@ -258,7 +258,7 @@ namespace Bloom::Targets
          * @param startAddress
          * @param buffer
          */
-        virtual void writeMemory(TargetMemoryType memoryType, std::uint32_t startAddress, const TargetMemoryBuffer& buffer) = 0;
+        virtual void writeMemory(TargetMemoryType memoryType, TargetMemoryAddress startAddress, const TargetMemoryBuffer& buffer) = 0;
 
         /**
          * Should return the current state of the target.
@@ -272,21 +272,21 @@ namespace Bloom::Targets
          *
          * @return
          */
-        virtual std::uint32_t getProgramCounter() = 0;
+        virtual TargetProgramCounter getProgramCounter() = 0;
 
         /**
          * Should update the program counter on the target.
          *
          * @param programCounter
          */
-        virtual void setProgramCounter(std::uint32_t programCounter) = 0;
+        virtual void setProgramCounter(TargetProgramCounter programCounter) = 0;
 
         /**
          * Should fetch the current stack pointer value.
          *
          * @return
          */
-        virtual std::uint32_t getStackPointer() = 0;
+        virtual TargetStackPointer getStackPointer() = 0;
 
         /**
          * Should get the current pin states for each pin on the target, mapped by pin number

src/Targets/TargetBreakpoint.hpp

@@ -2,6 +2,8 @@
 
 #include <cstdint>
 
+#include "TargetMemory.hpp"
+
 namespace Bloom::Targets
 {
     enum class TargetBreakCause: int
@@ -10,18 +12,16 @@ namespace Bloom::Targets
         UNKNOWN,
     };
 
-    using TargetBreakpointAddress = std::uint32_t;
-
     struct TargetBreakpoint
     {
         /**
          * Byte address of the breakpoint.
          */
-        TargetBreakpointAddress address = 0;
+        TargetMemoryAddress address = 0;
 
         bool disabled = false;
 
         TargetBreakpoint() = default;
-        explicit TargetBreakpoint(TargetBreakpointAddress address): address(address) {};
+        explicit TargetBreakpoint(TargetMemoryAddress address): address(address) {};
     };
 }

src/Targets/TargetMemory.hpp

@@ -6,6 +6,12 @@
 
 namespace Bloom::Targets
 {
+    using TargetMemoryAddress = std::uint32_t;
+    using TargetMemorySize = std::uint32_t;
+    using TargetProgramCounter = TargetMemoryAddress;
+    using TargetStackPointer = TargetMemoryAddress;
+    using TargetMemoryBuffer = std::vector<unsigned char>;
+
     enum class TargetMemoryEndianness: std::uint8_t
     {
         BIG,
@@ -22,11 +28,11 @@ namespace Bloom::Targets
 
     struct TargetMemoryAddressRange
     {
-        std::uint32_t startAddress = 0;
-        std::uint32_t endAddress = 0;
+        TargetMemoryAddress startAddress = 0;
+        TargetMemoryAddress endAddress = 0;
 
         TargetMemoryAddressRange() = default;
-        TargetMemoryAddressRange(std::uint32_t startAddress, std::uint32_t endAddress)
+        TargetMemoryAddressRange(TargetMemoryAddress startAddress, TargetMemoryAddress endAddress)
             : startAddress(startAddress)
             , endAddress(endAddress)
         {};
@@ -46,7 +52,7 @@ namespace Bloom::Targets
             ;
         }
 
-        [[nodiscard]] bool contains(std::uint32_t address) const {
+        [[nodiscard]] bool contains(TargetMemoryAddress address) const {
             return address >= this->startAddress && address <= this->endAddress;
         }
 
@@ -75,10 +81,8 @@ namespace Bloom::Targets
             return this->type == rhs.type && this->addressRange == rhs.addressRange;
         }
 
-        [[nodiscard]] std::uint32_t size() const {
+        [[nodiscard]] TargetMemorySize size() const {
             return (this->addressRange.endAddress - this->addressRange.startAddress) + 1;
         }
     };
-
-    using TargetMemoryBuffer = std::vector<unsigned char>;
 }

src/Targets/TargetRegister.hpp

@@ -25,8 +25,8 @@ namespace Bloom::Targets
     struct TargetRegisterDescriptor
     {
     public:
-        std::optional<std::uint32_t> startAddress;
-        std::uint32_t size = 0;
+        std::optional<TargetMemoryAddress> startAddress;
+        TargetMemorySize size = 0;
         TargetRegisterType type = TargetRegisterType::OTHER;
         TargetMemoryType memoryType = TargetMemoryType::OTHER;