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

Renamed GDB & TargetConrollerConsole read & write register functions/classes to a more generic name.

Browse Source
This commit is contained in:
Nav
2021-08-07 17:07:04 +01:00
parent 3be850fbbf
commit fd719f1cda
11 changed files with 96 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@@ -100,8 +100,8 @@ add_executable(Bloom
src/DebugServers/GdbRsp/CommandPackets/CommandPacket.cpp
src/DebugServers/GdbRsp/CommandPackets/CommandPacketFactory.cpp
src/DebugServers/GdbRsp/CommandPackets/SupportedFeaturesQuery.cpp
src/DebugServers/GdbRsp/CommandPackets/ReadGeneralRegisters.cpp
src/DebugServers/GdbRsp/CommandPackets/WriteGeneralRegister.cpp
src/DebugServers/GdbRsp/CommandPackets/ReadRegisters.cpp
src/DebugServers/GdbRsp/CommandPackets/WriteRegister.cpp
src/DebugServers/GdbRsp/CommandPackets/ContinueExecution.cpp
src/DebugServers/GdbRsp/CommandPackets/StepExecution.cpp
src/DebugServers/GdbRsp/CommandPackets/InterruptExecution.cpp

4
src/DebugServers/GdbRsp/CommandPackets/CommandPacketFactory.cpp
View File

@@ -24,10 +24,10 @@ std::unique_ptr<CommandPacket> CommandPacketFactory::create(std::vector<unsigned
return std::make_unique<CommandPackets::SupportedFeaturesQuery>(rawPacket);
} else if (rawPacketString[1] == 'g' || rawPacketString[1] == 'p') {
return std::make_unique<CommandPackets::ReadGeneralRegisters>(rawPacket);
return std::make_unique<CommandPackets::ReadRegisters>(rawPacket);
} else if (rawPacketString[1] == 'P') {
return std::make_unique<CommandPackets::WriteGeneralRegister>(rawPacket);
return std::make_unique<CommandPackets::WriteRegister>(rawPacket);
} else if (rawPacketString[1] == 'c') {
return std::make_unique<CommandPackets::ContinueExecution>(rawPacket);

4
src/DebugServers/GdbRsp/CommandPackets/CommandPacketFactory.hpp
View File

@@ -7,8 +7,8 @@
#include "CommandPacket.hpp"
#include "InterruptExecution.hpp"
#include "SupportedFeaturesQuery.hpp"
#include "ReadGeneralRegisters.hpp"
#include "WriteGeneralRegister.hpp"
#include "ReadRegisters.hpp"
#include "WriteRegister.hpp"
#include "ReadMemory.hpp"
#include "WriteMemory.hpp"
#include "StepExecution.hpp"

6
src/DebugServers/GdbRsp/CommandPackets/ReadGeneralRegisters.cpp → src/DebugServers/GdbRsp/CommandPackets/ReadRegisters.cpp
View File

@@ -1,15 +1,15 @@
#include "ReadGeneralRegisters.hpp"
#include "ReadRegisters.hpp"
#include "src/DebugServers/GdbRsp/GdbRspDebugServer.hpp"
using namespace Bloom::DebugServers::Gdb::CommandPackets;
void ReadGeneralRegisters::init() {
void ReadRegisters::init() {
if (this->data.size() >= 2 && this->data.front() == 'p') {
// This command packet is requesting a specific register
this->registerNumber = static_cast<size_t>(std::stoi(std::string(this->data.begin() + 1, this->data.end())));
}
}
void ReadGeneralRegisters::dispatchToHandler(Gdb::GdbRspDebugServer& gdbRspDebugServer) {
void ReadRegisters::dispatchToHandler(Gdb::GdbRspDebugServer& gdbRspDebugServer) {
gdbRspDebugServer.handleGdbPacket(*this);
}

6
src/DebugServers/GdbRsp/CommandPackets/ReadGeneralRegisters.hpp → src/DebugServers/GdbRsp/CommandPackets/ReadRegisters.hpp
View File

@@ -7,11 +7,11 @@
namespace Bloom::DebugServers::Gdb::CommandPackets
{
/**
* The ReadGeneralRegisters class implements a structure for "g" and "p" command packets. In response to these
* The ReadRegisters class implements a structure for "g" and "p" command packets. In response to these
* packets, the server is expected to send register values for all registers (for "g" packets) or for a single
* register (for "p" packets).
*/
class ReadGeneralRegisters: public CommandPacket
class ReadRegisters: public CommandPacket
{
private:
void init();
@@ -26,7 +26,7 @@ namespace Bloom::DebugServers::Gdb::CommandPackets
*/
std::optional<int> registerNumber;
explicit ReadGeneralRegisters(const std::vector<unsigned char>& rawPacket): CommandPacket(rawPacket) {
explicit ReadRegisters(const std::vector<unsigned char>& rawPacket): CommandPacket(rawPacket) {
init();
};

6
src/DebugServers/GdbRsp/CommandPackets/WriteGeneralRegister.cpp → src/DebugServers/GdbRsp/CommandPackets/WriteRegister.cpp
View File

@@ -1,11 +1,11 @@
#include "WriteGeneralRegister.hpp"
#include "WriteRegister.hpp"
#include "src/DebugServers/GdbRsp/GdbRspDebugServer.hpp"
#include "src/Exceptions/Exception.hpp"
using namespace Bloom::DebugServers::Gdb::CommandPackets;
using namespace Bloom::Exceptions;
void WriteGeneralRegister::init() {
void WriteRegister::init() {
// The P packet updates a single register
auto packet = std::string(this->data.begin(), this->data.end());
@@ -23,6 +23,6 @@ void WriteGeneralRegister::init() {
std::reverse(this->registerValue.begin(), this->registerValue.end());
}
void WriteGeneralRegister::dispatchToHandler(Gdb::GdbRspDebugServer& gdbRspDebugServer) {
void WriteRegister::dispatchToHandler(Gdb::GdbRspDebugServer& gdbRspDebugServer) {
gdbRspDebugServer.handleGdbPacket(*this);
}

6
src/DebugServers/GdbRsp/CommandPackets/WriteGeneralRegister.hpp → src/DebugServers/GdbRsp/CommandPackets/WriteRegister.hpp
View File

@@ -8,10 +8,10 @@
namespace Bloom::DebugServers::Gdb::CommandPackets
{
/**
* The WriteGeneralRegisters class implements the structure for "P" packets. Upon receiving this packet,
* The WriteRegisters class implements the structure for "P" packets. Upon receiving this packet,
* server is expected to update a register value to the target.
*/
class WriteGeneralRegister: public CommandPacket
class WriteRegister: public CommandPacket
{
private:
void init();
@@ -20,7 +20,7 @@ namespace Bloom::DebugServers::Gdb::CommandPackets
int registerNumber = 0;
std::vector<unsigned char> registerValue;
explicit WriteGeneralRegister(const std::vector<unsigned char>& rawPacket): CommandPacket(rawPacket) {
explicit WriteRegister(const std::vector<unsigned char>& rawPacket): CommandPacket(rawPacket) {
init();
};

38
src/DebugServers/GdbRsp/GdbRspDebugServer.cpp
View File

@@ -54,19 +54,20 @@ void GdbRspDebugServer::init() {
}
if (::setsockopt(
socketFileDescriptor,
SOL_SOCKET,
SO_REUSEADDR,
&this->enableReuseAddressSocketOption,
sizeof(this->enableReuseAddressSocketOption)) < 0
socketFileDescriptor,
SOL_SOCKET,
SO_REUSEADDR,
&(this->enableReuseAddressSocketOption),
sizeof(this->enableReuseAddressSocketOption)
) < 0
) {
Logger::error("Failed to set socket SO_REUSEADDR option.");
}
if (::bind(
socketFileDescriptor,
reinterpret_cast<const sockaddr*>(&(this->socketAddress)),
sizeof(this->socketAddress)
socketFileDescriptor,
reinterpret_cast<const sockaddr*>(&(this->socketAddress)),
sizeof(this->socketAddress)
) < 0
) {
throw Exception("Failed to bind address. The selected port number ("
@@ -258,11 +259,12 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::SupportedFeaturesQuery&
this->clientConnection->writePacket(response);
}
void GdbRspDebugServer::handleGdbPacket(CommandPackets::ReadGeneralRegisters& packet) {
Logger::debug("Handling ReadGeneralRegisters packet");
void GdbRspDebugServer::handleGdbPacket(CommandPackets::ReadRegisters& packet) {
Logger::debug("Handling ReadRegisters packet");
try {
auto descriptors = TargetRegisterDescriptors();
auto registerNumberToDescriptorMapping = this->getRegisterNumberToDescriptorMapping();
if (packet.registerNumber.has_value()) {
Logger::debug("Reading register number: " + std::to_string(packet.registerNumber.value()));
@@ -270,14 +272,12 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::ReadGeneralRegisters& pa
} else {
// Read all descriptors
auto descriptorMapping = this->getRegisterNumberToDescriptorMapping();
for (auto& descriptor : descriptorMapping.getMap()) {
for (auto& descriptor : registerNumberToDescriptorMapping.getMap()) {
descriptors.push_back(descriptor.second);
}
}
auto registerSet = this->targetControllerConsole.readGeneralRegisters(descriptors);
auto registerNumberToDescriptorMapping = this->getRegisterNumberToDescriptorMapping();
auto registerSet = this->targetControllerConsole.readRegisters(descriptors);
/*
* Remove any registers that are not mapped to GDB register numbers (as we won't know where to place
@@ -332,14 +332,14 @@ void GdbRspDebugServer::handleGdbPacket(CommandPackets::ReadGeneralRegisters& pa
}
}
void GdbRspDebugServer::handleGdbPacket(CommandPackets::WriteGeneralRegister& packet) {
Logger::debug("Handling WriteGeneralRegisters packet");
void GdbRspDebugServer::handleGdbPacket(CommandPackets::WriteRegister& packet) {
Logger::debug("Handling WriteRegister packet");
try {
auto registerDescriptor = this->getRegisterDescriptorFromNumber(packet.registerNumber);
this->targetControllerConsole.writeGeneralRegisters({
TargetRegister(registerDescriptor, packet.registerValue)
});
this->targetControllerConsole.writeRegisters({
TargetRegister(registerDescriptor, packet.registerValue)
});
this->clientConnection->writePacket(ResponsePacket({'O', 'K'}));
} catch (const Exception& exception) {

8
src/DebugServers/GdbRsp/GdbRspDebugServer.hpp
View File

@@ -140,10 +140,10 @@ namespace Bloom::DebugServers::Gdb
*
* @return
*/
virtual BiMap<
virtual const BiMap<
GdbRegisterNumber,
Targets::TargetRegisterDescriptor
> getRegisterNumberToDescriptorMapping() = 0;
>& getRegisterNumberToDescriptorMapping() = 0;
/**
* Obtains the appropriate register descriptor from a register number.
@@ -197,14 +197,14 @@ namespace Bloom::DebugServers::Gdb
*
* @param packet
*/
virtual void handleGdbPacket(CommandPackets::ReadGeneralRegisters& packet);
virtual void handleGdbPacket(CommandPackets::ReadRegisters& packet);
/**
* Handles the write general register ("P") command packet.
*
* @param packet
*/
virtual void handleGdbPacket(CommandPackets::WriteGeneralRegister& packet);
virtual void handleGdbPacket(CommandPackets::WriteRegister& packet);
/**
* Handles the continue execution ("c") command packet.

106
src/TargetController/TargetControllerConsole.cpp
View File

@@ -10,20 +10,20 @@ using namespace Bloom::Events;
using namespace Bloom::Exceptions;
TargetControllerState TargetControllerConsole::getTargetControllerState() {
auto getStateEvent = std::make_shared<Events::ReportTargetControllerState>();
auto getStateEvent = std::make_shared<ReportTargetControllerState>();
this->eventManager.triggerEvent(getStateEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::TargetControllerStateReported,
Events::TargetControllerErrorOccurred
TargetControllerStateReported,
TargetControllerErrorOccurred
>(this->defaultTimeout, getStateEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<Events::TargetControllerStateReported>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<TargetControllerStateReported>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto stateReportedEvent = std::get<SharedEventPointer<Events::TargetControllerStateReported>>(responseEvent.value());
auto stateReportedEvent = std::get<SharedEventPointer<TargetControllerStateReported>>(responseEvent.value());
return stateReportedEvent->state;
}
@@ -37,41 +37,41 @@ bool TargetControllerConsole::isTargetControllerInService() noexcept {
}
Targets::TargetDescriptor TargetControllerConsole::getTargetDescriptor() {
auto extractEvent = std::make_shared<Events::ExtractTargetDescriptor>();
auto extractEvent = std::make_shared<ExtractTargetDescriptor>();
this->eventManager.triggerEvent(extractEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::TargetDescriptorExtracted,
Events::TargetControllerErrorOccurred
TargetDescriptorExtracted,
TargetControllerErrorOccurred
>(this->defaultTimeout, extractEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<Events::TargetDescriptorExtracted>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<TargetDescriptorExtracted>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto descriptorExtracted = std::get<SharedEventPointer<Events::TargetDescriptorExtracted>>(responseEvent.value());
auto descriptorExtracted = std::get<SharedEventPointer<TargetDescriptorExtracted>>(responseEvent.value());
return descriptorExtracted->targetDescriptor;
}
void TargetControllerConsole::stopTargetExecution() {
auto stopTargetEvent = std::make_shared<Events::StopTargetExecution>();
auto stopTargetEvent = std::make_shared<StopTargetExecution>();
this->eventManager.triggerEvent(stopTargetEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::TargetExecutionStopped,
Events::TargetControllerErrorOccurred
TargetExecutionStopped,
TargetControllerErrorOccurred
>(this->defaultTimeout, stopTargetEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<Events::TargetExecutionStopped>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<TargetExecutionStopped>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void TargetControllerConsole::continueTargetExecution(std::optional<std::uint32_t> fromAddress) {
auto resumeExecutionEvent = std::make_shared<Events::ResumeTargetExecution>();
auto resumeExecutionEvent = std::make_shared<ResumeTargetExecution>();
if (fromAddress.has_value()) {
resumeExecutionEvent->fromProgramCounter = fromAddress.value();
@@ -79,19 +79,19 @@ void TargetControllerConsole::continueTargetExecution(std::optional<std::uint32_
this->eventManager.triggerEvent(resumeExecutionEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::TargetExecutionResumed,
Events::TargetControllerErrorOccurred
TargetExecutionResumed,
TargetControllerErrorOccurred
>(this->defaultTimeout, resumeExecutionEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<Events::TargetExecutionResumed>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<TargetExecutionResumed>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void TargetControllerConsole::stepTargetExecution(std::optional<std::uint32_t> fromAddress) {
auto stepExecutionEvent = std::make_shared<Events::StepTargetExecution>();
auto stepExecutionEvent = std::make_shared<StepTargetExecution>();
if (fromAddress.has_value()) {
stepExecutionEvent->fromProgramCounter = fromAddress.value();
@@ -99,51 +99,51 @@ void TargetControllerConsole::stepTargetExecution(std::optional<std::uint32_t> f
this->eventManager.triggerEvent(stepExecutionEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::TargetExecutionResumed,
Events::TargetControllerErrorOccurred
TargetExecutionResumed,
TargetControllerErrorOccurred
>(this->defaultTimeout, stepExecutionEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<Events::TargetExecutionResumed>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<TargetExecutionResumed>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
TargetRegisters TargetControllerConsole::readGeneralRegisters(TargetRegisterDescriptors descriptors) {
auto readRegistersEvent = std::make_shared<Events::RetrieveRegistersFromTarget>();
TargetRegisters TargetControllerConsole::readRegisters(const TargetRegisterDescriptors& descriptors) {
auto readRegistersEvent = std::make_shared<RetrieveRegistersFromTarget>();
readRegistersEvent->descriptors = descriptors;
this->eventManager.triggerEvent(readRegistersEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::RegistersRetrievedFromTarget,
Events::TargetControllerErrorOccurred
RegistersRetrievedFromTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, readRegistersEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<Events::RegistersRetrievedFromTarget>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<RegistersRetrievedFromTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto retrievedRegistersEvent = std::get<SharedEventPointer<Events::RegistersRetrievedFromTarget>>(
auto retrievedRegistersEvent = std::get<SharedEventPointer<RegistersRetrievedFromTarget>>(
responseEvent.value()
);
return retrievedRegistersEvent->registers;
}
void TargetControllerConsole::writeGeneralRegisters(TargetRegisters registers) {
auto event = std::make_shared<Events::WriteRegistersToTarget>();
event->registers = registers;
void TargetControllerConsole::writeRegisters(const TargetRegisters& registers) {
auto event = std::make_shared<WriteRegistersToTarget>();
event->registers = std::move(registers);
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener.waitForEvent<
Events::RegistersWrittenToTarget,
Events::TargetControllerErrorOccurred
RegistersWrittenToTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<Events::RegistersWrittenToTarget>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<RegistersWrittenToTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
@@ -154,24 +154,24 @@ TargetMemoryBuffer TargetControllerConsole::readMemory(
std::uint32_t startAddress,
std::uint32_t bytes
) {
auto readMemoryEvent = std::make_shared<Events::RetrieveMemoryFromTarget>();
auto readMemoryEvent = std::make_shared<RetrieveMemoryFromTarget>();
readMemoryEvent->memoryType = memoryType;
readMemoryEvent->startAddress = startAddress;
readMemoryEvent->bytes = bytes;
this->eventManager.triggerEvent(readMemoryEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::MemoryRetrievedFromTarget,
Events::TargetControllerErrorOccurred
MemoryRetrievedFromTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, readMemoryEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<Events::MemoryRetrievedFromTarget>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<MemoryRetrievedFromTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
auto retrievedRegistersEvent = std::get<SharedEventPointer<Events::MemoryRetrievedFromTarget>>(
auto retrievedRegistersEvent = std::get<SharedEventPointer<MemoryRetrievedFromTarget>>(
responseEvent.value()
);
return retrievedRegistersEvent->data;
@@ -182,67 +182,67 @@ void TargetControllerConsole::writeMemory(
std::uint32_t startAddress,
const TargetMemoryBuffer& buffer
) {
auto writeMemoryEvent = std::make_shared<Events::WriteMemoryToTarget>();
auto writeMemoryEvent = std::make_shared<WriteMemoryToTarget>();
writeMemoryEvent->memoryType = memoryType;
writeMemoryEvent->startAddress = startAddress;
writeMemoryEvent->buffer = buffer;
this->eventManager.triggerEvent(writeMemoryEvent);
auto responseEvent = this->eventListener.waitForEvent<
Events::MemoryWrittenToTarget,
Events::TargetControllerErrorOccurred
MemoryWrittenToTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, writeMemoryEvent->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<Events::MemoryWrittenToTarget>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<MemoryWrittenToTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void TargetControllerConsole::setBreakpoint(TargetBreakpoint breakpoint) {
auto event = std::make_shared<Events::SetBreakpointOnTarget>();
auto event = std::make_shared<SetBreakpointOnTarget>();
event->breakpoint = breakpoint;
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener.waitForEvent<
Events::BreakpointSetOnTarget,
Events::TargetControllerErrorOccurred
BreakpointSetOnTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<Events::BreakpointSetOnTarget>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<BreakpointSetOnTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void TargetControllerConsole::removeBreakpoint(TargetBreakpoint breakpoint) {
auto event = std::make_shared<Events::RemoveBreakpointOnTarget>();
auto event = std::make_shared<RemoveBreakpointOnTarget>();
event->breakpoint = breakpoint;
this->eventManager.triggerEvent(event);
auto responseEvent = this->eventListener.waitForEvent<
Events::BreakpointRemovedOnTarget,
Events::TargetControllerErrorOccurred
BreakpointRemovedOnTarget,
TargetControllerErrorOccurred
>(this->defaultTimeout, event->id);
if (!responseEvent.has_value()
|| !std::holds_alternative<SharedEventPointer<Events::BreakpointRemovedOnTarget>>(responseEvent.value())
|| !std::holds_alternative<SharedEventPointer<BreakpointRemovedOnTarget>>(responseEvent.value())
) {
throw Exception("Unexpected response from TargetController");
}
}
void TargetControllerConsole::requestPinStates(int variantId) {
auto requestEvent = std::make_shared<Events::RetrieveTargetPinStates>();
auto requestEvent = std::make_shared<RetrieveTargetPinStates>();
requestEvent->variantId = variantId;
this->eventManager.triggerEvent(requestEvent);
}
void TargetControllerConsole::setPinState(int variantId, TargetPinDescriptor pinDescriptor, TargetPinState pinState) {
auto updateEvent = std::make_shared<Events::SetTargetPinState>();
auto updateEvent = std::make_shared<SetTargetPinState>();
updateEvent->variantId = variantId;
updateEvent->pinDescriptor = std::move(pinDescriptor);
updateEvent->pinState = pinState;

4
src/TargetController/TargetControllerConsole.hpp
View File

@@ -75,14 +75,14 @@ namespace Bloom
*
* @return
*/
Targets::TargetRegisters readGeneralRegisters(Targets::TargetRegisterDescriptors descriptors);
Targets::TargetRegisters readRegisters(const Targets::TargetRegisterDescriptors& descriptors);
/**
* Requests the TargetController to write register values to the target.
*
* @param registers
*/
void writeGeneralRegisters(Targets::TargetRegisters registers);
void writeRegisters(const Targets::TargetRegisters& registers);
/**
* Requests the TargetController to read memory from the target.