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

Replaced SetBreakpointOnTarget event with TC command

Browse Source
This commit is contained in:
Nav
2022-04-30 22:03:28 +01:00
parent 226b663aea
commit f7619f475b
9 changed files with 48 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/EventManager/Events/BreakpointSetOnTarget.hpp
View File

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

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

@@ -29,9 +29,7 @@ namespace Bloom::Events
TARGET_EXECUTION_RESUMED,
TARGET_EXECUTION_STOPPED,
MEMORY_WRITTEN_TO_TARGET,
SET_BREAKPOINT_ON_TARGET,
REMOVE_BREAKPOINT_ON_TARGET,
BREAKPOINT_SET_ON_TARGET,
BREAKPOINT_REMOVED_ON_TARGET,
SET_PROGRAM_COUNTER_ON_TARGET,
PROGRAM_COUNTER_SET_ON_TARGET,

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

@@ -16,9 +16,7 @@
#include "TargetExecutionResumed.hpp"
#include "TargetExecutionStopped.hpp"
#include "MemoryWrittenToTarget.hpp"
#include "SetBreakpointOnTarget.hpp"
#include "RemoveBreakpointOnTarget.hpp"
#include "BreakpointSetOnTarget.hpp"
#include "BreakpointRemovedOnTarget.hpp"
#include "SetProgramCounterOnTarget.hpp"
#include "ProgramCounterSetOnTarget.hpp"

29
src/EventManager/Events/SetBreakpointOnTarget.hpp
View File

@@ -1,29 +0,0 @@
#pragma once
#include <cstdint>
#include <string>
#include "Event.hpp"
#include "BreakpointSetOnTarget.hpp"
#include "src/Targets/TargetBreakpoint.hpp"
namespace Bloom::Events
{
class SetBreakpointOnTarget: public Event
{
public:
using TargetControllerResponseType = BreakpointSetOnTarget;
static constexpr EventType type = EventType::SET_BREAKPOINT_ON_TARGET;
static inline const std::string name = "SetBreakpointOnTarget";
Targets::TargetBreakpoint breakpoint;
[[nodiscard]] EventType getType() const override {
return SetBreakpointOnTarget::type;
}
[[nodiscard]] std::string getName() const override {
return SetBreakpointOnTarget::name;
}
};
}

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

@@ -17,5 +17,6 @@ namespace Bloom::TargetController::Commands
GET_TARGET_STATE,
STEP_TARGET_EXECUTION,
WRITE_TARGET_MEMORY,
SET_BREAKPOINT,
};
}

30
src/TargetController/Commands/SetBreakpoint.hpp Normal file
View File

@@ -0,0 +1,30 @@
#pragma once
#include "Command.hpp"
#include "src/Targets/TargetBreakpoint.hpp"
namespace Bloom::TargetController::Commands
{
class SetBreakpoint: public Command
{
public:
static constexpr CommandType type = CommandType::SET_BREAKPOINT;
static inline const std::string name = "SetBreakpoint";
Targets::TargetBreakpoint breakpoint;
SetBreakpoint() = default;
explicit SetBreakpoint(const Targets::TargetBreakpoint& breakpoint)
: breakpoint(breakpoint)
{};
[[nodiscard]] CommandType getType() const override {
return SetBreakpoint::type;
}
[[nodiscard]] bool requiresStoppedTargetState() const override {
return true;
}
};
}

26
src/TargetController/TargetControllerComponent.cpp
View File

@@ -31,6 +31,7 @@ namespace Bloom::TargetController
using Commands::ReadTargetMemory;
using Commands::WriteTargetMemory;
using Commands::StepTargetExecution;
using Commands::SetBreakpoint;
using Responses::Response;
using Responses::TargetRegistersRead;
@@ -393,10 +394,10 @@ namespace Bloom::TargetController
this->deregisterCommandHandler(ReadTargetMemory::type);
this->deregisterCommandHandler(WriteTargetMemory::type);
this->deregisterCommandHandler(StepTargetExecution::type);
this->deregisterCommandHandler(SetBreakpoint::type);
this->eventListener->deregisterCallbacksForEventType<Events::DebugSessionFinished>();
this->eventListener->deregisterCallbacksForEventType<Events::ExtractTargetDescriptor>();
this->eventListener->deregisterCallbacksForEventType<Events::SetBreakpointOnTarget>();
this->eventListener->deregisterCallbacksForEventType<Events::RemoveBreakpointOnTarget>();
this->eventListener->deregisterCallbacksForEventType<Events::SetProgramCounterOnTarget>();
this->eventListener->deregisterCallbacksForEventType<Events::InsightThreadStateChanged>();
@@ -455,6 +456,10 @@ namespace Bloom::TargetController
std::bind(&TargetControllerComponent::handleStepTargetExecution, this, std::placeholders::_1)
);
this->registerCommandHandler<SetBreakpoint>(
std::bind(&TargetControllerComponent::handleSetBreakpoint, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<Events::DebugSessionFinished>(
std::bind(&TargetControllerComponent::onDebugSessionFinishedEvent, this, std::placeholders::_1)
);
@@ -463,10 +468,6 @@ namespace Bloom::TargetController
std::bind(&TargetControllerComponent::onExtractTargetDescriptor, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<Events::SetBreakpointOnTarget>(
std::bind(&TargetControllerComponent::onSetBreakpointEvent, this, std::placeholders::_1)
);
this->eventListener->registerCallbackForEventType<Events::RemoveBreakpointOnTarget>(
std::bind(&TargetControllerComponent::onRemoveBreakpointEvent, this, std::placeholders::_1)
);
@@ -859,18 +860,9 @@ namespace Bloom::TargetController
return std::make_unique<Response>();
}
void TargetControllerComponent::onSetBreakpointEvent(const Events::SetBreakpointOnTarget& event) {
try {
this->target->setBreakpoint(event.breakpoint.address);
auto breakpointSetEvent = std::make_shared<Events::BreakpointSetOnTarget>();
breakpointSetEvent->correlationId = event.id;
EventManager::triggerEvent(breakpointSetEvent);
} catch (const TargetOperationFailure& exception) {
Logger::error("Failed to set breakpoint on target - " + exception.getMessage());
this->emitErrorEvent(event.id, exception.getMessage());
}
std::unique_ptr<Response> TargetControllerComponent::handleSetBreakpoint(SetBreakpoint& command) {
this->target->setBreakpoint(command.breakpoint.address);
return std::make_unique<Response>();
}
void TargetControllerComponent::onRemoveBreakpointEvent(const Events::RemoveBreakpointOnTarget& event) {

10
src/TargetController/TargetControllerComponent.hpp
View File

@@ -27,6 +27,7 @@
#include "Commands/ReadTargetMemory.hpp"
#include "Commands/WriteTargetMemory.hpp"
#include "Commands/StepTargetExecution.hpp"
#include "Commands/SetBreakpoint.hpp"
// Responses
#include "Responses/Response.hpp"
@@ -306,14 +307,7 @@ namespace Bloom::TargetController
std::unique_ptr<Responses::TargetMemoryRead> handleReadTargetMemory(Commands::ReadTargetMemory& command);
std::unique_ptr<Responses::Response> handleWriteTargetMemory(Commands::WriteTargetMemory& command);
std::unique_ptr<Responses::Response> handleStepTargetExecution(Commands::StepTargetExecution& command);
/**
* Will attempt to set the specific breakpoint on the target. On success, the BreakpointSetOnTarget event will
* be emitted.
*
* @param event
*/
void onSetBreakpointEvent(const Events::SetBreakpointOnTarget& event);
std::unique_ptr<Responses::Response> handleSetBreakpoint(Commands::SetBreakpoint& command);
/**
* Will attempt to remove a breakpoint at the specified address, on the target. On success, the

10
src/TargetController/TargetControllerConsole.cpp
View File

@@ -14,6 +14,7 @@
#include "Commands/ReadTargetMemory.hpp"
#include "Commands/WriteTargetMemory.hpp"
#include "Commands/StepTargetExecution.hpp"
#include "Commands/SetBreakpoint.hpp"
#include "src/Logger/Logger.hpp"
@@ -32,6 +33,7 @@ namespace Bloom::TargetController
using Commands::ReadTargetMemory;
using Commands::WriteTargetMemory;
using Commands::StepTargetExecution;
using Commands::SetBreakpoint;
TargetControllerConsole::TargetControllerConsole(EventListener& eventListener)
: eventListener(eventListener)
@@ -139,10 +141,10 @@ namespace Bloom::TargetController
}
void TargetControllerConsole::setBreakpoint(TargetBreakpoint breakpoint) {
auto event = std::make_shared<SetBreakpointOnTarget>();
event->breakpoint = breakpoint;
this->triggerTargetControllerEventAndWaitForResponse(event);
this->commandManager.sendCommandAndWaitForResponse(
std::make_unique<SetBreakpoint>(breakpoint),
this->defaultTimeout
);
}
void TargetControllerConsole::removeBreakpoint(TargetBreakpoint breakpoint) {