doryan/BloomPatched
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replaced RetrieveStackPointerFromTarget event with TC command

Browse Source
This commit is contained in:
Nav
2022-05-01 18:01:01 +01:00
parent 75d8ca68fb
commit d8af8fe1ee
11 changed files with 72 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/EventManager/Events/Event.hpp
View File

@@ -32,8 +32,6 @@ namespace Bloom::Events
EXTRACT_TARGET_DESCRIPTOR,
TARGET_DESCRIPTOR_EXTRACTED,
INSIGHT_THREAD_STATE_CHANGED,
RETRIEVE_STACK_POINTER_FROM_TARGET,
STACK_POINTER_RETRIEVED_FROM_TARGET,
TARGET_RESET,
};

2
src/EventManager/Events/Events.hpp
View File

@@ -19,8 +19,6 @@
#include "ExtractTargetDescriptor.hpp"
#include "TargetDescriptorExtracted.hpp"
#include "InsightThreadStateChanged.hpp"
#include "RetrieveStackPointerFromTarget.hpp"
#include "StackPointerRetrievedFromTarget.hpp"
#include "TargetReset.hpp"
namespace Bloom::Events

26
src/EventManager/Events/RetrieveStackPointerFromTarget.hpp
View File

@@ -1,26 +0,0 @@
#pragma once
#include <string>
#include "Event.hpp"
#include "StackPointerRetrievedFromTarget.hpp"
namespace Bloom::Events
{
class RetrieveStackPointerFromTarget: public Event
{
public:
using TargetControllerResponseType = StackPointerRetrievedFromTarget;
static constexpr 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;
}
};
}

24
src/EventManager/Events/StackPointerRetrievedFromTarget.hpp
View File

@@ -1,24 +0,0 @@
#pragma once
#include <string>
#include "Event.hpp"
namespace Bloom::Events
{
class StackPointerRetrievedFromTarget: public Event
{
public:
static constexpr 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;
}
};
}

1
src/TargetController/Commands/CommandTypes.hpp
View File

@@ -22,5 +22,6 @@ namespace Bloom::TargetController::Commands
SET_PROGRAM_COUNTER,
GET_TARGET_PIN_STATES,
SET_TARGET_PIN_STATE,
GET_TARGET_STACK_POINTER,
};
}

25
src/TargetController/Commands/GetTargetStackPointer.hpp Normal file
View File

@@ -0,0 +1,25 @@
#pragma once
#include "Command.hpp"
#include "src/TargetController/Responses/TargetStackPointer.hpp"
namespace Bloom::TargetController::Commands
{
class GetTargetStackPointer: public Command
{
public:
using SuccessResponseType = Responses::TargetStackPointer;
static constexpr CommandType type = CommandType::GET_TARGET_STACK_POINTER;
static inline const std::string name = "GetTargetStackPointer";
[[nodiscard]] CommandType getType() const override {
return GetTargetStackPointer::type;
}
[[nodiscard]] bool requiresStoppedTargetState() const override {
return true;
}
};
}

1
src/TargetController/Responses/ResponseTypes.hpp
View File

@@ -12,5 +12,6 @@ namespace Bloom::TargetController::Responses
TARGET_MEMORY_READ,
TARGET_STATE,
TARGET_PIN_STATES,
TARGET_STACK_POINTER,
};
}

24
src/TargetController/Responses/TargetStackPointer.hpp Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
#include <cstdint>
#include "Response.hpp"
namespace Bloom::TargetController::Responses
{
class TargetStackPointer: public Response
{
public:
static constexpr ResponseType type = ResponseType::TARGET_STACK_POINTER;
std::uint32_t stackPointer;
explicit TargetStackPointer(std::uint32_t stackPointer)
: stackPointer(stackPointer)
{}
[[nodiscard]] ResponseType getType() const override {
return TargetStackPointer::type;
}
};
}

34
src/TargetController/TargetControllerComponent.cpp
View File

@@ -36,11 +36,13 @@ namespace Bloom::TargetController
using Commands::SetProgramCounter;
using Commands::GetTargetPinStates;
using Commands::SetTargetPinState;
using Commands::GetTargetStackPointer;
using Responses::Response;
using Responses::TargetRegistersRead;
using Responses::TargetMemoryRead;
using Responses::TargetPinStates;
using Responses::TargetStackPointer;
TargetControllerComponent::TargetControllerComponent(
const ProjectConfig& projectConfig,
@@ -405,10 +407,10 @@ namespace Bloom::TargetController
this->deregisterCommandHandler(SetProgramCounter::type);
this->deregisterCommandHandler(GetTargetPinStates::type);
this->deregisterCommandHandler(SetTargetPinState::type);
this->deregisterCommandHandler(GetTargetStackPointer::type);
this->eventListener->deregisterCallbacksForEventType<Events::DebugSessionFinished>();
this->eventListener->deregisterCallbacksForEventType<Events::ExtractTargetDescriptor>();
this->eventListener->deregisterCallbacksForEventType<Events::RetrieveStackPointerFromTarget>();
this->lastTargetState = TargetState::UNKNOWN;
this->cachedTargetDescriptor = std::nullopt;
@@ -481,6 +483,10 @@ namespace Bloom::TargetController
std::bind(&TargetControllerComponent::handleSetTargetPinState, this, std::placeholders::_1)
);
this->registerCommandHandler<GetTargetStackPointer>(
std::bind(&TargetControllerComponent::handleGetTargetStackPointer, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<Events::DebugSessionFinished>(
std::bind(&TargetControllerComponent::onDebugSessionFinishedEvent, this, std::placeholders::_1)
);
@@ -489,10 +495,6 @@ namespace Bloom::TargetController
std::bind(&TargetControllerComponent::onExtractTargetDescriptor, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<Events::RetrieveStackPointerFromTarget>(
std::bind(&TargetControllerComponent::onRetrieveStackPointerEvent, this, std::placeholders::_1)
);
TargetControllerComponent::state = TargetControllerState::ACTIVE;
EventManager::triggerEvent(
std::make_shared<TargetControllerStateChanged>(TargetControllerComponent::state)
@@ -889,23 +891,9 @@ namespace Bloom::TargetController
return std::make_unique<Response>();
}
void TargetControllerComponent::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();
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());
}
std::unique_ptr<TargetStackPointer> TargetControllerComponent::handleGetTargetStackPointer(
GetTargetStackPointer& command
) {
return std::make_unique<TargetStackPointer>(this->target->getStackPointer());
}
}

13
src/TargetController/TargetControllerComponent.hpp
View File

@@ -32,6 +32,7 @@
#include "Commands/SetProgramCounter.hpp"
#include "Commands/GetTargetPinStates.hpp"
#include "Commands/SetTargetPinState.hpp"
#include "Commands/GetTargetStackPointer.hpp"
// Responses
#include "Responses/Response.hpp"
@@ -39,6 +40,7 @@
#include "Responses/TargetRegistersRead.hpp"
#include "Responses/TargetMemoryRead.hpp"
#include "Responses/TargetPinStates.hpp"
#include "Responses/TargetStackPointer.hpp"
#include "TargetControllerState.hpp"
@@ -317,13 +319,8 @@ namespace Bloom::TargetController
std::unique_ptr<Responses::Response> handleSetProgramCounter(Commands::SetProgramCounter& command);
std::unique_ptr<Responses::TargetPinStates> handleGetTargetPinStates(Commands::GetTargetPinStates& command);
std::unique_ptr<Responses::Response> handleSetTargetPinState(Commands::SetTargetPinState& command);
/**
* 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);
std::unique_ptr<Responses::TargetStackPointer> handleGetTargetStackPointer(
Commands::GetTargetStackPointer& command
);
};
}

7
src/TargetController/TargetControllerConsole.cpp
View File

@@ -19,6 +19,7 @@
#include "Commands/SetProgramCounter.hpp"
#include "Commands/GetTargetPinStates.hpp"
#include "Commands/SetTargetPinState.hpp"
#include "Commands/GetTargetStackPointer.hpp"
#include "src/Logger/Logger.hpp"
@@ -42,6 +43,7 @@ namespace Bloom::TargetController
using Commands::SetProgramCounter;
using Commands::GetTargetPinStates;
using Commands::SetTargetPinState;
using Commands::GetTargetStackPointer;
TargetControllerConsole::TargetControllerConsole(EventListener& eventListener)
: eventListener(eventListener)
@@ -184,8 +186,9 @@ namespace Bloom::TargetController
}
std::uint32_t TargetControllerConsole::getStackPointer() {
return this->triggerTargetControllerEventAndWaitForResponse(
std::make_shared<RetrieveStackPointerFromTarget>()
return this->commandManager.sendCommandAndWaitForResponse(
std::make_unique<GetTargetStackPointer>(),
this->defaultTimeout
)->stackPointer;
}