Renamed GdbRsp directory to Gdb

src/DebugServer/Gdb/AvrGdb/CommandPackets/AbstractMemoryAccessPacket.cpp

@@ -0,0 +1,17 @@
+#include "AbstractMemoryAccessPacket.hpp"
+
+#include "src/DebugServer/Gdb/ResponsePackets/TargetStopped.hpp"
+#include "src/DebugServer/Gdb/ResponsePackets/ErrorResponsePacket.hpp"
+#include "src/DebugServer/Gdb/Signal.hpp"
+
+#include "src/Logger/Logger.hpp"
+#include "src/Exceptions/Exception.hpp"
+
+namespace Bloom::DebugServer::Gdb::CommandPackets
+{
+    using ResponsePackets::ErrorResponsePacket;
+
+    using Exceptions::Exception;
+
+
+}

src/DebugServer/Gdb/AvrGdb/CommandPackets/AbstractMemoryAccessPacket.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <cstdint>
+#include <optional>
+
+#include "src/DebugServer/Gdb/CommandPackets/CommandPacket.hpp"
+
+#include "src/Targets/TargetMemory.hpp"
+
+namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+{
+    /**
+     * The ReadMemory class implements a structure for "m" packets. Upon receiving these packets, the server is
+     * expected to read memory from the target and send it the client.
+     */
+    class AbstractMemoryAccessPacket: public Bloom::DebugServer::Gdb::CommandPackets::CommandPacket
+    {
+    public:
+        explicit AbstractMemoryAccessPacket(const std::vector<unsigned char>& rawPacket): CommandPacket(rawPacket) {};
+
+    protected:
+        /**
+         * The mask used by the AVR GDB client to encode the memory type into memory addresses.
+         */
+        static constexpr std::uint32_t AVR_GDB_MEMORY_ADDRESS_MASK = 0xFE0000U;
+
+        /**
+         * avr-gdb uses the most significant 15 bits in memory addresses to indicate the type of memory being
+         * addressed.
+         *
+         * @param address
+         * @return
+         */
+        Targets::TargetMemoryType getMemoryTypeFromGdbAddress(std::uint32_t address) {
+            if ((address & AbstractMemoryAccessPacket::AVR_GDB_MEMORY_ADDRESS_MASK) != 0U) {
+                return Targets::TargetMemoryType::RAM;
+            }
+
+            return Targets::TargetMemoryType::FLASH;
+        }
+
+        /**
+         * Strips the most significant 15 bits from a GDB memory address.
+         *
+         * @param address
+         * @return
+         */
+        std::uint32_t removeMemoryTypeIndicatorFromGdbAddress(std::uint32_t address) {
+            return (address & AbstractMemoryAccessPacket::AVR_GDB_MEMORY_ADDRESS_MASK) != 0U
+                ? (address & ~(AbstractMemoryAccessPacket::AVR_GDB_MEMORY_ADDRESS_MASK))
+                : address;
+        }
+    };
+}

src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadMemory.cpp

@@ -0,0 +1,70 @@
+#include "ReadMemory.hpp"
+
+#include "src/DebugServer/Gdb/ResponsePackets/ErrorResponsePacket.hpp"
+#include "src/DebugServer/Gdb/ResponsePackets/ResponsePacket.hpp"
+
+#include "src/Logger/Logger.hpp"
+#include "src/Exceptions/Exception.hpp"
+
+namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+{
+    using ResponsePackets::ErrorResponsePacket;
+    using ResponsePackets::ResponsePacket;
+
+    using Exceptions::Exception;
+
+    void ReadMemory::init() {
+        if (this->data.size() < 4) {
+            throw Exception("Invalid packet length");
+        }
+
+        auto packetString = QString::fromLocal8Bit(
+            reinterpret_cast<const char*>(this->data.data() + 1),
+            static_cast<int>(this->data.size() - 1)
+        );
+
+        /*
+         * The read memory ('m') packet consists of two segments, an address and a number of bytes to read.
+         * These are separated by a comma character.
+         */
+        auto packetSegments = packetString.split(",");
+
+        if (packetSegments.size() != 2) {
+            throw Exception(
+                "Unexpected number of segments in packet data: " + std::to_string(packetSegments.size())
+            );
+        }
+
+        bool conversionStatus = false;
+        this->startAddress = packetSegments.at(0).toUInt(&conversionStatus, 16);
+
+        if (!conversionStatus) {
+            throw Exception("Failed to parse start address from read memory packet data");
+        }
+
+        this->bytes = packetSegments.at(1).toUInt(&conversionStatus, 16);
+
+        if (!conversionStatus) {
+            throw Exception("Failed to parse read length from read memory packet data");
+        }
+    }
+
+    void ReadMemory::handle(DebugSession& debugSession, TargetControllerConsole& targetControllerConsole) {
+        Logger::debug("Handling ReadMemory packet");
+
+        try {
+            auto memoryType = this->getMemoryTypeFromGdbAddress(this->startAddress);
+            auto startAddress = this->removeMemoryTypeIndicatorFromGdbAddress(this->startAddress);
+            auto memoryBuffer = targetControllerConsole.readMemory(memoryType, startAddress, this->bytes);
+
+            auto hexMemoryBuffer = Packet::dataToHex(memoryBuffer);
+            debugSession.connection.writePacket(
+                ResponsePacket(std::vector<unsigned char>(hexMemoryBuffer.begin(), hexMemoryBuffer.end()))
+            );
+
+        } catch (const Exception& exception) {
+            Logger::error("Failed to read memory from target - " + exception.getMessage());
+            debugSession.connection.writePacket(ErrorResponsePacket());
+        }
+    }
+}

src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadMemory.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <cstdint>
+#include <optional>
+
+#include "AbstractMemoryAccessPacket.hpp"
+
+namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+{
+    /**
+     * The ReadMemory class implements a structure for "m" packets. Upon receiving these packets, the server is
+     * expected to read memory from the target and send it the client.
+     */
+    class ReadMemory: public AbstractMemoryAccessPacket
+    {
+    public:
+        /**
+         * The startAddress sent from the GDB client may include additional bits used to indicate the memory type.
+         * These bits have to be removed from the address before it can be used as a start address. This is not done
+         * here, as it's target specific.
+         *
+         * For an example of where GDB does this, see the AvrGdbRsp class.
+         */
+        std::uint32_t startAddress = 0;
+
+        /**
+         * Number of bytes to read.
+         */
+        std::uint32_t bytes = 0;
+
+        explicit ReadMemory(const std::vector<unsigned char>& rawPacket): AbstractMemoryAccessPacket(rawPacket) {
+            init();
+        };
+
+        void handle(DebugSession& debugSession, TargetControllerConsole& targetControllerConsole) override;
+
+    protected:
+        void init();
+    };
+}

src/DebugServer/Gdb/AvrGdb/CommandPackets/WriteMemory.cpp

@@ -0,0 +1,86 @@
+#include "WriteMemory.hpp"
+
+#include "src/DebugServer/Gdb/ResponsePackets/ErrorResponsePacket.hpp"
+#include "src/DebugServer/Gdb/ResponsePackets/OkResponsePacket.hpp"
+
+#include "src/Logger/Logger.hpp"
+#include "src/Exceptions/Exception.hpp"
+
+namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+{
+    using ResponsePackets::ErrorResponsePacket;
+    using ResponsePackets::OkResponsePacket;
+
+    using namespace Bloom::Exceptions;
+
+    void WriteMemory::init() {
+        if (this->data.size() < 4) {
+            throw Exception("Invalid packet length");
+        }
+
+        auto packetString = QString::fromLocal8Bit(
+            reinterpret_cast<const char*>(this->data.data() + 1),
+            static_cast<int>(this->data.size() - 1)
+        );
+
+        /*
+         * The write memory ('M') packet consists of three segments, an address, a length and a buffer.
+         * The address and length are separated by a comma character, and the buffer proceeds a colon character.
+         */
+        auto packetSegments = packetString.split(",");
+        if (packetSegments.size() != 2) {
+            throw Exception(
+                "Unexpected number of segments in packet data: " + std::to_string(packetSegments.size())
+            );
+        }
+
+        bool conversionStatus = false;
+        this->startAddress = packetSegments.at(0).toUInt(&conversionStatus, 16);
+
+        if (!conversionStatus) {
+            throw Exception("Failed to parse start address from write memory packet data");
+        }
+
+        auto lengthAndBufferSegments = packetSegments.at(1).split(":");
+        if (lengthAndBufferSegments.size() != 2) {
+            throw Exception(
+                "Unexpected number of segments in packet data: "
+                    + std::to_string(lengthAndBufferSegments.size())
+            );
+        }
+
+        auto bufferSize = lengthAndBufferSegments.at(0).toUInt(&conversionStatus, 16);
+        if (!conversionStatus) {
+            throw Exception("Failed to parse write length from write memory packet data");
+        }
+
+        this->buffer = Packet::hexToData(lengthAndBufferSegments.at(1).toStdString());
+
+        if (this->buffer.size() != bufferSize) {
+            throw Exception("Buffer size does not match length value given in write memory packet");
+        }
+    }
+
+    void WriteMemory::handle(DebugSession& debugSession, TargetControllerConsole& targetControllerConsole) {
+        Logger::debug("Handling WriteMemory packet");
+
+        try {
+            const auto memoryType = this->getMemoryTypeFromGdbAddress(this->startAddress);
+
+            if (memoryType == Targets::TargetMemoryType::FLASH) {
+                throw Exception(
+                    "GDB client requested a flash memory write - This is not currently supported by Bloom."
+                );
+            }
+
+            const auto startAddress = this->removeMemoryTypeIndicatorFromGdbAddress(this->startAddress);
+            targetControllerConsole.writeMemory(memoryType, startAddress, this->buffer);
+
+            debugSession.connection.writePacket(OkResponsePacket());
+
+        } catch (const Exception& exception) {
+            Logger::error("Failed to write memory to target - " + exception.getMessage());
+            debugSession.connection.writePacket(ErrorResponsePacket());
+        }
+    }
+}

src/DebugServer/Gdb/AvrGdb/CommandPackets/WriteMemory.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <cstdint>
+#include <optional>
+
+#include "AbstractMemoryAccessPacket.hpp"
+
+namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+{
+    /**
+     * The WriteMemory class implements the structure for "M" packets. Upon receiving this packet, the server is
+     * expected to write data to the target's memory, at the specified start address.
+     */
+    class WriteMemory: public AbstractMemoryAccessPacket
+    {
+    public:
+        /**
+         * Like with the ReadMemory command packet, the start address carries additional bits that indicate
+         * the memory type.
+         */
+        std::uint32_t startAddress = 0;
+
+        Targets::TargetMemoryBuffer buffer;
+
+        explicit WriteMemory(const std::vector<unsigned char>& rawPacket): AbstractMemoryAccessPacket(rawPacket) {
+            init();
+        };
+
+        void handle(DebugSession& debugSession, TargetControllerConsole& targetControllerConsole) override;
+
+    private:
+        void init();
+    };
+}