Lots of tidying

- Removed generic `avr8` target
- Simplified AVR8 target construction
- Introduced register descriptor IDs
- Simplified GDB register mappings
- Simplified target interface contract
- Other bits of tidying

src/DebugServer/Gdb/TargetDescriptor.hpp

@@ -4,6 +4,7 @@
 #include <optional>
 #include <vector>
 #include <set>
+#include <map>
 
 #include "src/Helpers/BiMap.hpp"
 #include "src/Targets/TargetDescriptor.hpp"
@@ -21,21 +22,19 @@ namespace Bloom::DebugServer::Gdb
     {
     public:
         Targets::TargetDescriptor targetDescriptor;
+        std::map<GdbRegisterId, RegisterDescriptor> gdbRegisterDescriptorsById;
 
         explicit TargetDescriptor(
             const Targets::TargetDescriptor& targetDescriptor,
-            const BiMap<Targets::TargetMemoryType, std::uint32_t>& memoryOffsetsByType
-        )
-            : targetDescriptor(targetDescriptor)
-            , memoryOffsetsByType(memoryOffsetsByType)
-            , memoryOffsets(memoryOffsetsByType.getValues())
-        {}
+            const BiMap<Targets::TargetMemoryType, std::uint32_t>& memoryOffsetsByType,
+            std::map<GdbRegisterId, RegisterDescriptor> gdbRegisterDescriptorsById,
+            std::map<Targets::TargetRegisterDescriptorId, GdbRegisterId> gdbRegisterIdsByTargetRegisterDescriptorId,
+            std::map<GdbRegisterId, Targets::TargetRegisterDescriptorId> targetRegisterDescriptorIdsByGdbRegisterId
+        );
 
         virtual ~TargetDescriptor() = default;
 
-        virtual std::uint32_t getMemoryOffset(Targets::TargetMemoryType memoryType) const {
-            return this->memoryOffsetsByType.valueAt(memoryType).value_or(0);
-        }
+        std::uint32_t getMemoryOffset(Targets::TargetMemoryType memoryType) const;
 
         /**
          * Helper method to extract the target memory type (Flash, RAM, etc) from a GDB memory address.
@@ -43,58 +42,35 @@ namespace Bloom::DebugServer::Gdb
          * @param address
          * @return
          */
-        Targets::TargetMemoryType getMemoryTypeFromGdbAddress(std::uint32_t address) const {
-            // Start with the largest offset until we find a match
-            for (
-                auto memoryOffsetIt = this->memoryOffsets.rbegin();
-                memoryOffsetIt != this->memoryOffsets.rend();
-                ++memoryOffsetIt
-            ) {
-                if ((address & *memoryOffsetIt) == *memoryOffsetIt) {
-                    return this->memoryOffsetsByType.at(*memoryOffsetIt);
-                }
-            }
-
-            return Targets::TargetMemoryType::FLASH;
-        }
+        Targets::TargetMemoryType getMemoryTypeFromGdbAddress(std::uint32_t address) const;
 
         /**
-         * Should retrieve the GDB register number, given a target register descriptor. Or std::nullopt if the target
-         * register descriptor isn't mapped to any GDB register.
+         * Should retrieve the GDB register ID, given a target register descriptor ID. Or std::nullopt if the
+         * target register descriptor ID isn't mapped to any GDB register.
          *
-         * @param registerDescriptor
+         * @param registerDescriptorId
          * @return
          */
-        virtual std::optional<GdbRegisterNumber> getRegisterNumberFromTargetRegisterDescriptor(
-            const Targets::TargetRegisterDescriptor& registerDescriptor
-        ) const = 0;
+        std::optional<GdbRegisterId> getGdbRegisterIdFromTargetRegisterDescriptorId(
+            Targets::TargetRegisterDescriptorId targetRegisterDescriptorId
+        ) const;
 
         /**
-         * Should retrieve the GDB register descriptor for a given GDB register number.
+         * Should retrieve the mapped target register descriptor ID for a given GDB register ID.
          *
-         * @param number
+         * This function may return std::nullopt if the GDB register ID maps to something that isn't considered a
+         * register on our end. For example, for AVR targets, the GDB register ID 34 maps to the program counter. But
+         * the program counter is not treated like any other register in Bloom (there's no TargetRegisterDescriptor for
+         * it). So in that case, the GDB register ID is not mapped to any target register descriptor ID.
+         *
+         * @param gdbRegisterId
          * @return
          */
-        virtual const RegisterDescriptor& getRegisterDescriptorFromNumber(GdbRegisterNumber number) const = 0;
+        std::optional<Targets::TargetRegisterDescriptorId> getTargetRegisterDescriptorIdFromGdbRegisterId(
+            GdbRegisterId gdbRegisterId
+        ) const;
 
-        /**
-         * Should retrieve the mapped target register descriptor for a given GDB register number.
-         *
-         * @param number
-         * @return
-         */
-        virtual const Targets::TargetRegisterDescriptor& getTargetRegisterDescriptorFromNumber(
-            GdbRegisterNumber number
-        ) const = 0;
-
-        /**
-         * Should return all allocated GDB register numbers for the target.
-         *
-         * @return
-         */
-        virtual const std::vector<GdbRegisterNumber>& getRegisterNumbers() const = 0;
-
-    private:
+    protected:
         /**
          * When GDB sends us a memory address, the memory type (Flash, RAM, EEPROM, etc) is embedded within. This is
          * done by ORing the address with some constant. For example, for AVR targets, RAM addresses are ORed with
@@ -109,5 +85,8 @@ namespace Bloom::DebugServer::Gdb
          * Sorted set of the known memory offsets (see memoryOffsetsByType).
          */
         std::set<std::uint32_t> memoryOffsets;
+
+        std::map<Targets::TargetRegisterDescriptorId, GdbRegisterId> gdbRegisterIdsByTargetRegisterDescriptorId;
+        std::map<GdbRegisterId, Targets::TargetRegisterDescriptorId> targetRegisterDescriptorIdsByGdbRegisterId;
     };
 }