New TC event for retrieving current stack pointer value

src/EventManager/Events/Event.hpp

@@ -51,6 +51,8 @@ namespace Bloom::Events
         RETRIEVE_TARGET_PIN_STATES,
         TARGET_PIN_STATES_RETRIEVED,
         SET_TARGET_PIN_STATE,
+        RETRIEVE_STACK_POINTER_FROM_TARGET,
+        STACK_POINTER_RETRIEVED_FROM_TARGET,
     };
 
     class Event

src/EventManager/Events/Events.hpp

@@ -39,6 +39,8 @@
 #include "RetrieveTargetPinStates.hpp"
 #include "TargetPinStatesRetrieved.hpp"
 #include "SetTargetPinState.hpp"
+#include "RetrieveStackPointerFromTarget.hpp"
+#include "StackPointerRetrievedFromTarget.hpp"
 
 namespace Bloom::Events
 {

src/EventManager/Events/RetrieveStackPointerFromTarget.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <string>
+
+#include "Event.hpp"
+#include "StackPointerRetrievedFromTarget.hpp"
+
+namespace Bloom::Events
+{
+    class RetrieveStackPointerFromTarget: public Event
+    {
+    public:
+        using TargetControllerResponseType = StackPointerRetrievedFromTarget;
+
+        static inline EventType type = EventType::RETRIEVE_STACK_POINTER_FROM_TARGET;
+        static inline const std::string name = "RetrieveStackPointerFromTarget";
+
+        [[nodiscard]] EventType getType() const override {
+            return RetrieveStackPointerFromTarget::type;
+        }
+
+        [[nodiscard]] std::string getName() const override {
+            return RetrieveStackPointerFromTarget::name;
+        }
+    };
+}

src/EventManager/Events/StackPointerRetrievedFromTarget.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <string>
+
+#include "Event.hpp"
+
+namespace Bloom::Events
+{
+    class StackPointerRetrievedFromTarget: public Event
+    {
+    public:
+        static inline EventType type = EventType::STACK_POINTER_RETRIEVED_FROM_TARGET;
+        static inline const std::string name = "StackPointerRetrievedFromTarget";
+        std::uint32_t stackPointer = 0;
+
+        [[nodiscard]] EventType getType() const override {
+            return StackPointerRetrievedFromTarget::type;
+        }
+
+        [[nodiscard]] std::string getName() const override {
+            return StackPointerRetrievedFromTarget::name;
+        }
+    };
+}

src/TargetController/TargetController.cpp

@@ -174,6 +174,7 @@ void TargetController::suspend() {
     this->eventListener->deregisterCallbacksForEventType<Events::InsightThreadStateChanged>();
     this->eventListener->deregisterCallbacksForEventType<Events::RetrieveTargetPinStates>();
     this->eventListener->deregisterCallbacksForEventType<Events::SetTargetPinState>();
+    this->eventListener->deregisterCallbacksForEventType<Events::RetrieveStackPointerFromTarget>();
 
     this->lastTargetState = TargetState::UNKNOWN;
     this->cachedTargetDescriptor = std::nullopt;
@@ -252,6 +253,10 @@ void TargetController::resume() {
         std::bind(&TargetController::onSetPinStateEvent, this, std::placeholders::_1)
     );
 
+    this->eventListener->registerCallbackForEventType<Events::RetrieveStackPointerFromTarget>(
+        std::bind(&TargetController::onRetrieveStackPointerEvent, this, std::placeholders::_1)
+    );
+
     this->state = TargetControllerState::ACTIVE;
     this->eventManager.triggerEvent(
         std::make_shared<TargetControllerStateReported>(this->state)
@@ -769,3 +774,23 @@ void TargetController::onSetPinStateEvent(const Events::SetTargetPinState& event
         this->emitErrorEvent(event.id, exception.getMessage());
     }
 }
+
+void TargetController::onRetrieveStackPointerEvent(const Events::RetrieveStackPointerFromTarget& event) {
+    try {
+        if (this->target->getState() != TargetState::STOPPED) {
+            throw TargetOperationFailure(
+                "Invalid target state - target must be stopped before stack pointer can be retrieved"
+            );
+        }
+
+        auto stackPointerRetrieved = std::make_shared<Events::StackPointerRetrievedFromTarget>();
+        stackPointerRetrieved->correlationId = event.id;
+        stackPointerRetrieved->stackPointer = this->target->getStackPointer();
+
+        this->eventManager.triggerEvent(stackPointerRetrieved);
+
+    } catch (const TargetOperationFailure& exception) {
+        Logger::error("Failed to retrieve stack pointer value from target - " + exception.getMessage());
+        this->emitErrorEvent(event.id, exception.getMessage());
+    }
+}

src/TargetController/TargetController.hpp

@@ -401,5 +401,13 @@ namespace Bloom
          * @param event
          */
         void onSetPinStateEvent(const Events::SetTargetPinState& event);
+
+        /**
+         * Will retrieve the current stack pointer from the target. Will emit a StackPointerRetrievedFromTarget event
+         * containing the retrieved stack pointer value.
+         *
+         * @param event
+         */
+        void onRetrieveStackPointerEvent(const Events::RetrieveStackPointerFromTarget& event);
     };
 }