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

Massive refactor to accommodate RISC-V targets

Browse Source 
- Refactored entire codebase (excluding the Insight component) to accommodate multiple target architectures (no longer specific to AVR)
- Deleted 'generate SVD' GDB monitor command - I will eventually move this functionality to the Bloom website
- Added unit size property to address spaces
- Many other changes which I couldn't be bothered to describe here
This commit is contained in:
Nav
2024-07-23 21:14:22 +01:00
parent 2986934485
commit 6cdbfbe950
331 changed files with 8815 additions and 8565 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/EventManager/EventListener.cpp
View File

@@ -31,7 +31,7 @@ void EventListener::waitAndDispatch(int msTimeout) {
const auto& eventQueueByType = this->eventQueueByEventType.unsafeReference();
const auto registeredEventTypes = this->getRegisteredEventTypes();
std::optional<SharedGenericEventPointer> event;
auto event = std::optional<SharedGenericEventPointer>{};
const auto eventsFound = [&registeredEventTypes, &event, &eventQueueByType]() -> bool {
for (auto& eventQueue: eventQueueByType) {
@@ -43,7 +43,7 @@ void EventListener::waitAndDispatch(int msTimeout) {
};
if (msTimeout > 0) {
this->eventQueueByEventTypeCV.wait_for(queueLock, std::chrono::milliseconds(msTimeout), eventsFound);
this->eventQueueByEventTypeCV.wait_for(queueLock, std::chrono::milliseconds{msTimeout}, eventsFound);
} else {
this->eventQueueByEventTypeCV.wait(queueLock, eventsFound);
@@ -57,7 +57,7 @@ void EventListener::dispatchEvent(const SharedGenericEventPointer& event) {
Logger::debug("Dispatching event " + event->getName() + " (" + std::to_string(event->id) + ").");
// Dispatch the event to all registered handlers
auto callbacks = std::vector<std::function<void(const Events::Event&)>>();
auto callbacks = std::vector<std::function<void(const Events::Event&)>>{};
{
const auto callbackMappingAccessor = this->eventTypeToCallbacksMapping.accessor();
@@ -83,7 +83,7 @@ void EventListener::dispatchCurrentEvents() {
std::vector<SharedGenericEventPointer> EventListener::getEvents() {
auto eventQueueByType = this->eventQueueByEventType.accessor();
std::vector<SharedGenericEventPointer> output;
auto output = std::vector<SharedGenericEventPointer>{};
for (auto& eventQueue: *eventQueueByType) {
while (!eventQueue.second.empty()) {

26
src/EventManager/EventListener.hpp
View File

@@ -40,7 +40,9 @@
class EventListener
{
public:
explicit EventListener(std::string name): name(std::move(name)) {};
explicit EventListener(std::string name)
: name(std::move(name))
{};
std::size_t getId() const {
return this->id;
@@ -55,7 +57,7 @@ public:
bool isEventTypeRegistered(Events::EventType eventType) {
return this->registeredEventTypes.accessor()->contains(eventType);
};
}
/**
* Registers an event type for the listener.
@@ -194,13 +196,13 @@ public:
>::type
>::type;
ReturnType output = std::nullopt;
auto output = ReturnType{};
auto queueLock = this->eventQueueByEventType.lock();
auto& eventQueueByType = this->eventQueueByEventType.unsafeReference();
auto eventTypes = std::set<Events::EventType>({EventTypeA::type});
auto eventTypesToDeRegister = std::set<Events::EventType>();
auto eventTypesToDeRegister = std::set<Events::EventType>{};
if constexpr (!std::is_same_v<EventTypeA, EventTypeB>) {
static_assert(
@@ -266,23 +268,23 @@ public:
// If we're looking for multiple event types, use an std::variant.
if constexpr (!std::is_same_v<EventTypeA, EventTypeB> || !std::is_same_v<EventTypeB, EventTypeC>) {
if (foundEvent->getType() == EventTypeA::type) {
output = std::optional<typename decltype(output)::value_type>(
output = std::optional<typename decltype(output)::value_type>{
std::dynamic_pointer_cast<const EventTypeA>(foundEvent)
);
};
} else if constexpr (!std::is_same_v<EventTypeA, EventTypeB>) {
if (foundEvent->getType() == EventTypeB::type) {
output = std::optional<typename decltype(output)::value_type>(
output = std::optional<typename decltype(output)::value_type>{
std::dynamic_pointer_cast<const EventTypeB>(foundEvent)
);
};
}
}
if constexpr (!std::is_same_v<EventTypeB, EventTypeC>) {
if (foundEvent->getType() == EventTypeC::type) {
output = std::optional<typename decltype(output)::value_type>(
output = std::optional<typename decltype(output)::value_type>{
std::dynamic_pointer_cast<const EventTypeC>(foundEvent)
);
};
}
}
@@ -341,7 +343,9 @@ private:
* we perform a downcast before invoking the callback. See EventListener::registerCallbackForEventType()
* for more)
*/
Synchronised<std::map<Events::EventType, std::vector<std::function<void(const Events::Event&)>>>> eventTypeToCallbacksMapping;
Synchronised<
std::map<Events::EventType, std::vector<std::function<void(const Events::Event&)>>>
> eventTypeToCallbacksMapping;
Synchronised<std::set<Events::EventType>> registeredEventTypes;
NotifierInterface* interruptEventNotifier = nullptr;

10
src/EventManager/EventManager.cpp
View File

@@ -1,17 +1,17 @@
#include "EventManager.hpp"
void EventManager::registerListener(std::shared_ptr<EventListener> listener) {
auto registerListenersLock = std::unique_lock(EventManager::registerListenerMutex);
EventManager::registeredListeners.insert(std::pair(listener->getId(), std::move(listener)));
auto registerListenersLock = std::unique_lock{EventManager::registerListenerMutex};
EventManager::registeredListeners.emplace(listener->getId(), std::move(listener));
}
void EventManager::deregisterListener(size_t listenerId) {
auto registerListenersLock = std::unique_lock(EventManager::registerListenerMutex);
auto registerListenersLock = std::unique_lock{EventManager::registerListenerMutex};
EventManager::registeredListeners.erase(listenerId);
}
void EventManager::triggerEvent(const std::shared_ptr<const Events::Event>& event) {
auto registerListenersLock = std::unique_lock(EventManager::registerListenerMutex);
auto registerListenersLock = std::unique_lock{EventManager::registerListenerMutex};
for (const auto&[listenerId, listener] : EventManager::registeredListeners) {
if (listener->isEventTypeRegistered(event->getType())) {
@@ -21,7 +21,7 @@ void EventManager::triggerEvent(const std::shared_ptr<const Events::Event>& even
}
bool EventManager::isEventTypeListenedFor(Events::EventType eventType) {
auto registerListenersLock = std::unique_lock(EventManager::registerListenerMutex);
auto registerListenersLock = std::unique_lock{EventManager::registerListenerMutex};
for (const auto& [listenerId, listener] : EventManager::registeredListeners) {
if (listener->isEventTypeRegistered(eventType)) {

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

@@ -24,8 +24,7 @@ namespace Events
DEBUG_SERVER_THREAD_STATE_CHANGED,
SHUTDOWN_DEBUG_SERVER,
REGISTERS_WRITTEN_TO_TARGET,
TARGET_EXECUTION_RESUMED,
TARGET_EXECUTION_STOPPED,
TARGET_STATE_CHANGED,
MEMORY_WRITTEN_TO_TARGET,
TARGET_RESET,
PROGRAMMING_MODE_ENABLED,

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

@@ -12,8 +12,7 @@
#include "DebugServerThreadStateChanged.hpp"
#include "ShutdownDebugServer.hpp"
#include "RegistersWrittenToTarget.hpp"
#include "TargetExecutionResumed.hpp"
#include "TargetExecutionStopped.hpp"
#include "TargetStateChanged.hpp"
#include "MemoryWrittenToTarget.hpp"
#include "TargetReset.hpp"
#include "ProgrammingModeEnabled.hpp"

12
src/EventManager/Events/MemoryWrittenToTarget.hpp
View File

@@ -3,6 +3,9 @@
#include <string>
#include "Event.hpp"
#include "src/Targets/TargetAddressSpaceDescriptor.hpp"
#include "src/Targets/TargetMemorySegmentDescriptor.hpp"
#include "src/Targets/TargetMemory.hpp"
namespace Events
@@ -13,16 +16,19 @@ namespace Events
static constexpr EventType type = EventType::MEMORY_WRITTEN_TO_TARGET;
static const inline std::string name = "MemoryWrittenToTarget";
Targets::TargetMemoryType memoryType;
const Targets::TargetAddressSpaceDescriptor& addressSpaceDescriptor;
const Targets::TargetMemorySegmentDescriptor& memorySegmentDescriptor;
Targets::TargetMemoryAddress startAddress;
Targets::TargetMemorySize size;
MemoryWrittenToTarget(
Targets::TargetMemoryType memoryType,
const Targets::TargetAddressSpaceDescriptor& addressSpaceDescriptor,
const Targets::TargetMemorySegmentDescriptor& memorySegmentDescriptor,
Targets::TargetMemoryAddress startAddress,
Targets::TargetMemorySize size
)
: memoryType(memoryType)
: addressSpaceDescriptor(addressSpaceDescriptor)
, memorySegmentDescriptor(memorySegmentDescriptor)
, startAddress(startAddress)
, size(size)
{};

9
src/EventManager/Events/RegistersWrittenToTarget.hpp
View File

@@ -3,7 +3,8 @@
#include <string>
#include "Event.hpp"
#include "src/Targets/TargetRegister.hpp"
#include "src/Targets/TargetRegisterDescriptor.hpp"
namespace Events
{
@@ -13,7 +14,11 @@ namespace Events
static constexpr EventType type = EventType::REGISTERS_WRITTEN_TO_TARGET;
static const inline std::string name = "RegistersWrittenToTarget";
Targets::TargetRegisters registers;
Targets::TargetRegisterDescriptorAndValuePairs registers;
explicit RegistersWrittenToTarget(const Targets::TargetRegisterDescriptorAndValuePairs& registers)
: registers(registers)
{}
[[nodiscard]] EventType getType() const override {
return RegistersWrittenToTarget::type;

4
src/EventManager/Events/TargetControllerErrorOccurred.hpp
View File

@@ -15,7 +15,9 @@ namespace Events
std::string errorMessage;
TargetControllerErrorOccurred() = default;
TargetControllerErrorOccurred(const std::string& errorMessage): errorMessage(errorMessage) {};
TargetControllerErrorOccurred(const std::string& errorMessage)
: errorMessage(errorMessage)
{};
[[nodiscard]] EventType getType() const override {
return TargetControllerErrorOccurred::type;

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

@@ -1,29 +0,0 @@
#pragma once
#include <string>
#include "Event.hpp"
namespace Events
{
class TargetExecutionResumed: public Event
{
public:
static constexpr EventType type = EventType::TARGET_EXECUTION_RESUMED;
static const inline std::string name = "TargetExecutionResumed";
bool stepping = false;
explicit TargetExecutionResumed(bool stepping)
: stepping(stepping)
{};
[[nodiscard]] EventType getType() const override {
return TargetExecutionResumed::type;
}
[[nodiscard]] std::string getName() const override {
return TargetExecutionResumed::name;
}
};
}

35
src/EventManager/Events/TargetExecutionStopped.hpp
View File

@@ -1,35 +0,0 @@
#pragma once
#include <cstdint>
#include <string>
#include "Event.hpp"
#include "src/Targets/TargetBreakpoint.hpp"
#include "src/Targets/TargetMemory.hpp"
namespace Events
{
class TargetExecutionStopped: public Event
{
public:
static constexpr EventType type = EventType::TARGET_EXECUTION_STOPPED;
static const inline std::string name = "TargetExecutionStopped";
Targets::TargetMemoryAddress programCounter;
Targets::TargetBreakCause breakCause;
TargetExecutionStopped(Targets::TargetMemoryAddress programCounter, Targets::TargetBreakCause breakCause)
: programCounter(programCounter)
, breakCause(breakCause)
{}
[[nodiscard]] EventType getType() const override {
return TargetExecutionStopped::type;
}
[[nodiscard]] std::string getName() const override {
return TargetExecutionStopped::name;
}
};
}

32
src/EventManager/Events/TargetStateChanged.hpp Normal file
View File

@@ -0,0 +1,32 @@
#pragma once
#include <string>
#include "Event.hpp"
#include "src/Targets/TargetState.hpp"
namespace Events
{
class TargetStateChanged: public Event
{
public:
static constexpr EventType type = EventType::TARGET_STATE_CHANGED;
static const inline std::string name = "TargetStateChanged";
Targets::TargetState newState;
Targets::TargetState previousState;
explicit TargetStateChanged(Targets::TargetState newState, Targets::TargetState previousState)
: newState(newState)
, previousState(previousState)
{};
[[nodiscard]] EventType getType() const override {
return TargetStateChanged::type;
}
[[nodiscard]] std::string getName() const override {
return TargetStateChanged::name;
}
};
}