From b3fb3f09551f7cc23452d3349021d43bcd587962 Mon Sep 17 00:00:00 2001 From: Nav Date: Sat, 3 Dec 2022 22:16:21 +0000 Subject: [PATCH] Lots of tidying --- src/Application.cpp | 10 +- src/DebugServer/DebugServerComponent.cpp | 10 +- .../Gdb/AvrGdb/CommandPackets/ReadMemory.cpp | 5 +- .../Gdb/AvrGdb/CommandPackets/WriteMemory.cpp | 5 +- .../Gdb/AvrGdb/TargetDescriptor.cpp | 31 +- .../EDBG/AVR/EdbgAvr8Interface.cpp | 33 +- .../AVR/Exceptions/Avr8CommandFailure.hpp | 24 +- src/EventManager/EventListener.cpp | 60 +- src/EventManager/EventListener.hpp | 10 +- src/Helpers/BiMap.hpp | 20 +- src/Helpers/Process.cpp | 5 +- .../InsightWindow/InsightWindow.cpp | 67 +- .../UserInterfaces/InsightWindow/UiLoader.cpp | 6 +- .../HexViewerWidget/ByteItemGraphicsScene.cpp | 11 +- .../MemoryRegionManager/FocusedRegionItem.cpp | 28 +- .../MemoryRegionManager/RegionItem.cpp | 9 +- .../TargetMemoryInspectionPane.cpp | 6 +- .../TargetRegistersPaneWidget.cpp | 8 +- .../TargetWidgets/TargetPackageWidget.cpp | 7 +- src/SignalHandler/SignalHandler.cpp | 5 +- .../TargetControllerComponent.cpp | 59 +- src/Targets/Microchip/AVR/AVR8/Avr8.cpp | 37 +- src/Targets/Microchip/AVR/AVR8/Avr8.hpp | 6 +- .../Microchip/AVR/AVR8/Avr8TargetConfig.cpp | 7 +- .../TargetDescriptionFile.cpp | 816 ++++++++++-------- src/Targets/Microchip/AVR/Target.hpp | 8 +- 26 files changed, 743 insertions(+), 550 deletions(-) diff --git a/src/Application.cpp b/src/Application.cpp index b2e4c3f1..ba1905e5 100644 --- a/src/Application.cpp +++ b/src/Application.cpp @@ -28,10 +28,11 @@ namespace Bloom if (this->arguments.size() > 1) { auto& firstArg = this->arguments.at(1); const auto commandHandlersByCommandName = this->getCommandHandlersByCommandName(); + const auto commandHandlerIt = commandHandlersByCommandName.find(firstArg); - if (commandHandlersByCommandName.contains(firstArg)) { + if (commandHandlerIt != commandHandlersByCommandName.end()) { // User has passed an argument that maps to a command callback - invoke the callback and shutdown - const auto returnValue = commandHandlersByCommandName.at(firstArg)(); + const auto returnValue = commandHandlerIt->second(); this->shutdown(); return returnValue; @@ -272,13 +273,14 @@ namespace Bloom } // Validate the selected environment - if (!this->projectConfig->environments.contains(this->selectedEnvironmentName)) { + const auto selectedEnvironmentIt = this->projectConfig->environments.find(this->selectedEnvironmentName); + if (selectedEnvironmentIt == this->projectConfig->environments.end()) { throw InvalidConfig( "Environment (\"" + this->selectedEnvironmentName + "\") not found in configuration." ); } - this->environmentConfig = this->projectConfig->environments.at(this->selectedEnvironmentName); + this->environmentConfig = selectedEnvironmentIt->second; if (this->environmentConfig->insightConfig.has_value()) { this->insightConfig = this->environmentConfig->insightConfig.value(); diff --git a/src/DebugServer/DebugServerComponent.cpp b/src/DebugServer/DebugServerComponent.cpp index e4edd590..247ea5de 100644 --- a/src/DebugServer/DebugServerComponent.cpp +++ b/src/DebugServer/DebugServerComponent.cpp @@ -66,13 +66,13 @@ namespace Bloom::DebugServer ); static const auto availableServersByName = this->getAvailableServersByName(); - if (!availableServersByName.contains(this->debugServerConfig.name)) { - throw Exceptions::InvalidConfig( - "DebugServer \"" + this->debugServerConfig.name + "\" not found." - ); + const auto selectedServerIt = availableServersByName.find(this->debugServerConfig.name); + + if (selectedServerIt == availableServersByName.end()) { + throw Exceptions::InvalidConfig("DebugServer \"" + this->debugServerConfig.name + "\" not found."); } - this->server = availableServersByName.at(this->debugServerConfig.name)(); + this->server = selectedServerIt->second(); Logger::info("Selected DebugServer: " + this->server->getName()); this->server->init(); diff --git a/src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadMemory.cpp b/src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadMemory.cpp index aced4312..401897a4 100644 --- a/src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadMemory.cpp +++ b/src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadMemory.cpp @@ -65,8 +65,9 @@ namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets try { const auto& memoryDescriptorsByType = debugSession.gdbTargetDescriptor.targetDescriptor.memoryDescriptorsByType; + const auto memoryDescriptorIt = memoryDescriptorsByType.find(this->memoryType); - if (!memoryDescriptorsByType.contains(this->memoryType)) { + if (memoryDescriptorIt == memoryDescriptorsByType.end()) { throw Exception("Target does not support the requested memory type."); } @@ -75,7 +76,7 @@ namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets return; } - const auto& memoryDescriptor = memoryDescriptorsByType.at(this->memoryType); + const auto& memoryDescriptor = memoryDescriptorIt->second; /* * In AVR targets, RAM is mapped to many registers and peripherals - we don't want to block GDB from diff --git a/src/DebugServer/Gdb/AvrGdb/CommandPackets/WriteMemory.cpp b/src/DebugServer/Gdb/AvrGdb/CommandPackets/WriteMemory.cpp index 9fdf3649..b446c3f6 100644 --- a/src/DebugServer/Gdb/AvrGdb/CommandPackets/WriteMemory.cpp +++ b/src/DebugServer/Gdb/AvrGdb/CommandPackets/WriteMemory.cpp @@ -73,8 +73,9 @@ namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets try { const auto& memoryDescriptorsByType = debugSession.gdbTargetDescriptor.targetDescriptor.memoryDescriptorsByType; + const auto memoryDescriptorIt = memoryDescriptorsByType.find(this->memoryType); - if (!memoryDescriptorsByType.contains(this->memoryType)) { + if (memoryDescriptorIt == memoryDescriptorsByType.end()) { throw Exception("Target does not support the requested memory type."); } @@ -98,7 +99,7 @@ namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets return; } - const auto& memoryDescriptor = memoryDescriptorsByType.at(this->memoryType); + const auto& memoryDescriptor = memoryDescriptorIt->second; /* * In AVR targets, RAM is mapped to many registers and peripherals - we don't want to block GDB from diff --git a/src/DebugServer/Gdb/AvrGdb/TargetDescriptor.cpp b/src/DebugServer/Gdb/AvrGdb/TargetDescriptor.cpp index 19c443a1..45b18221 100644 --- a/src/DebugServer/Gdb/AvrGdb/TargetDescriptor.cpp +++ b/src/DebugServer/Gdb/AvrGdb/TargetDescriptor.cpp @@ -31,23 +31,29 @@ namespace Bloom::DebugServer::Gdb::AvrGdb } const RegisterDescriptor& TargetDescriptor::getRegisterDescriptorFromNumber(GdbRegisterNumber number) const { - if (this->registerDescriptorsByGdbNumber.contains(number)) { - return this->registerDescriptorsByGdbNumber.at(number); + const auto registerDescriptorIt = this->registerDescriptorsByGdbNumber.find(number); + if (registerDescriptorIt.has_value()) { + return (*registerDescriptorIt)->second; } - throw Exception("Unknown register from GDB - register number (" + std::to_string(number) - + ") not mapped to any GDB register descriptor."); + throw Exception( + "Unknown register from GDB - register number (" + std::to_string(number) + + ") not mapped to any GDB register descriptor." + ); } const TargetRegisterDescriptor& TargetDescriptor::getTargetRegisterDescriptorFromNumber( GdbRegisterNumber number ) const { - if (this->targetRegisterDescriptorsByGdbNumber.contains(number)) { - return this->targetRegisterDescriptorsByGdbNumber.at(number); + const auto targetRegisterDescriptorIt = this->targetRegisterDescriptorsByGdbNumber.find(number); + if (targetRegisterDescriptorIt.has_value()) { + return (*targetRegisterDescriptorIt)->second; } - throw Exception("Unknown register from GDB - register number (" + std::to_string(number) - + ") not mapped to any target register descriptor."); + throw Exception( + "Unknown register from GDB - register number (" + std::to_string(number) + + ") not mapped to any target register descriptor." + ); } const std::vector& TargetDescriptor::getRegisterNumbers() const { @@ -55,7 +61,7 @@ namespace Bloom::DebugServer::Gdb::AvrGdb } void TargetDescriptor::loadRegisterMappings() { - auto& registerDescriptorsByType = this->targetDescriptor.registerDescriptorsByType; + const auto& registerDescriptorsByType = this->targetDescriptor.registerDescriptorsByType; if (!registerDescriptorsByType.contains(TargetRegisterType::STATUS_REGISTER)) { throw Exception("Missing status register descriptor"); } @@ -68,7 +74,8 @@ namespace Bloom::DebugServer::Gdb::AvrGdb throw Exception("Missing program counter register descriptor"); } - if (!registerDescriptorsByType.contains(TargetRegisterType::GENERAL_PURPOSE_REGISTER) + if ( + !registerDescriptorsByType.contains(TargetRegisterType::GENERAL_PURPOSE_REGISTER) || registerDescriptorsByType.at(TargetRegisterType::GENERAL_PURPOSE_REGISTER).size() != 32 ) { throw Exception("Unexpected general purpose register count"); @@ -136,9 +143,7 @@ namespace Bloom::DebugServer::Gdb::AvrGdb "Stack Pointer Register" ); - this->registerDescriptorsByGdbNumber.insert( - std::pair(stackPointerDescriptor.number, stackPointerDescriptor) - ); + this->registerDescriptorsByGdbNumber.insert(std::pair(stackPointerDescriptor.number, stackPointerDescriptor)); this->targetRegisterDescriptorsByGdbNumber.insert(std::pair( stackPointerDescriptor.number, *(registerDescriptorsByType.at(TargetRegisterType::STACK_POINTER).begin()) diff --git a/src/DebugToolDrivers/Protocols/CMSIS-DAP/VendorSpecific/EDBG/AVR/EdbgAvr8Interface.cpp b/src/DebugToolDrivers/Protocols/CMSIS-DAP/VendorSpecific/EDBG/AVR/EdbgAvr8Interface.cpp index 5296fa6d..d2dd1ea5 100644 --- a/src/DebugToolDrivers/Protocols/CMSIS-DAP/VendorSpecific/EDBG/AVR/EdbgAvr8Interface.cpp +++ b/src/DebugToolDrivers/Protocols/CMSIS-DAP/VendorSpecific/EDBG/AVR/EdbgAvr8Interface.cpp @@ -477,14 +477,13 @@ namespace Bloom::DebugToolDrivers::Protocols::CmsisDap::Edbg::Avr const auto startAddress = descriptor.startAddress.value(); const auto endAddress = startAddress + (descriptor.size - 1); - if (!addressRangeByType.contains(descriptor.type)) { - auto addressRange = AddressRange(); - addressRange.first = startAddress; - addressRange.second = endAddress; - addressRangeByType[descriptor.type] = addressRange; + const auto addressRangeit = addressRangeByType.find(descriptor.type); + + if (addressRangeit == addressRangeByType.end()) { + addressRangeByType[descriptor.type] = AddressRange(startAddress, endAddress); } else { - auto& addressRange = addressRangeByType[descriptor.type]; + auto& addressRange = addressRangeit->second; if (startAddress < addressRange.first) { addressRange.first = startAddress; @@ -869,14 +868,17 @@ namespace Bloom::DebugToolDrivers::Protocols::CmsisDap::Edbg::Avr std::optional EdbgAvr8Interface::resolveConfigVariant() { if (this->family.has_value()) { - auto configVariantsByFamily = EdbgAvr8Interface::getConfigVariantsByFamilyAndPhysicalInterface(); + const auto configVariantsByFamily = EdbgAvr8Interface::getConfigVariantsByFamilyAndPhysicalInterface(); + const auto configVariantsByPhysicalInterfaceIt = configVariantsByFamily.find(*(this->family)); - if (configVariantsByFamily.contains(this->family.value())) { - auto configVariantsByPhysicalInterface = configVariantsByFamily - .at(this->family.value()); + if (configVariantsByPhysicalInterfaceIt != configVariantsByFamily.end()) { + const auto& configVariantsByPhysicalInterface = configVariantsByPhysicalInterfaceIt->second; + const auto configVariantIt = configVariantsByPhysicalInterface.find( + this->targetConfig->physicalInterface + ); - if (configVariantsByPhysicalInterface.contains(this->targetConfig->physicalInterface)) { - return configVariantsByPhysicalInterface.at(this->targetConfig->physicalInterface); + if (configVariantIt != configVariantsByPhysicalInterface.end()) { + return configVariantIt->second; } } @@ -894,14 +896,15 @@ namespace Bloom::DebugToolDrivers::Protocols::CmsisDap::Edbg::Avr * variant. Users are required to specify the exact target name in their config, when using the JTAG * physical interface. That way, this->family will be set by the time resolveConfigVariant() is called. */ - static std::map physicalInterfacesToConfigVariants = { + static const std::map physicalInterfacesToConfigVariants = { {PhysicalInterface::DEBUG_WIRE, Avr8ConfigVariant::DEBUG_WIRE}, {PhysicalInterface::PDI, Avr8ConfigVariant::XMEGA}, {PhysicalInterface::UPDI, Avr8ConfigVariant::UPDI}, }; + const auto configVariantIt = physicalInterfacesToConfigVariants.find(this->targetConfig->physicalInterface); - if (physicalInterfacesToConfigVariants.contains(this->targetConfig->physicalInterface)) { - return physicalInterfacesToConfigVariants.at(this->targetConfig->physicalInterface); + if (configVariantIt != physicalInterfacesToConfigVariants.end()) { + return configVariantIt->second; } } diff --git a/src/DebugToolDrivers/Protocols/CMSIS-DAP/VendorSpecific/EDBG/AVR/Exceptions/Avr8CommandFailure.hpp b/src/DebugToolDrivers/Protocols/CMSIS-DAP/VendorSpecific/EDBG/AVR/Exceptions/Avr8CommandFailure.hpp index fbc89819..6a227886 100644 --- a/src/DebugToolDrivers/Protocols/CMSIS-DAP/VendorSpecific/EDBG/AVR/Exceptions/Avr8CommandFailure.hpp +++ b/src/DebugToolDrivers/Protocols/CMSIS-DAP/VendorSpecific/EDBG/AVR/Exceptions/Avr8CommandFailure.hpp @@ -74,20 +74,28 @@ namespace Bloom::DebugToolDrivers::Protocols::CmsisDap::Edbg::Avr explicit Avr8CommandFailure( const std::string& message, const ResponseFrames::Avr8Generic::Avr8GenericResponseFrame& responseFrame - ): TargetOperationFailure(message) { + ) + : TargetOperationFailure(message) + { this->message = message; - if ( - responseFrame.payload.size() == 3 - && this->failureCodeToDescription.contains(static_cast(responseFrame.payload[2])) - ) { - this->code = static_cast(responseFrame.payload[2]); - this->message += " - Failure reason: " + this->failureCodeToDescription.at(*(this->code)); + if (responseFrame.payload.size() == 3) { + /* + * The response includes a failure code - lookup the corresponding description and append it to the + * exception message. + */ + const auto failureCode = static_cast(responseFrame.payload[2]); + const auto failureCodeDescriptionIt = this->failureCodeToDescription.find(failureCode); + + if (failureCodeDescriptionIt != this->failureCodeToDescription.end()) { + this->code = failureCode; + this->message += " - Failure reason: " + failureCodeDescriptionIt->second; + } } } private: - static inline auto failureCodeToDescription = std::map({ + static const inline auto failureCodeToDescription = std::map({ {Avr8CommandFailureCode::DEBUGWIRE_PHYSICAL_ERROR, "debugWIRE physical error"}, {Avr8CommandFailureCode::JTAGM_FAILED_TO_INITIALISE, "JTAGM failed to initialise"}, {Avr8CommandFailureCode::UNKNOWN_JTAG_ERROR, "JTAGM did something strange"}, diff --git a/src/EventManager/EventListener.cpp b/src/EventManager/EventListener.cpp index a6aae34a..791ede17 100644 --- a/src/EventManager/EventListener.cpp +++ b/src/EventManager/EventListener.cpp @@ -7,14 +7,17 @@ namespace Bloom using namespace Bloom::Events; std::set EventListener::getRegisteredEventTypes() { - auto lock = this->registeredEventTypes.acquireLock(); + const auto lock = this->registeredEventTypes.acquireLock(); return this->registeredEventTypes.getValue(); } void EventListener::registerEvent(SharedGenericEventPointer event) { - Logger::debug("Event \"" + event->getName() + "\" (" + std::to_string(event->id) - + ") registered for listener " + this->name); - auto queueLock = this->eventQueueByEventType.acquireLock(); + Logger::debug( + "Event \"" + event->getName() + "\" (" + std::to_string(event->id) + ") registered for listener " + + this->name + ); + + const auto queueLock = this->eventQueueByEventType.acquireLock(); auto& eventQueueByType = this->eventQueueByEventType.getValue(); eventQueueByType[event->getType()].push(std::move(event)); @@ -26,33 +29,29 @@ namespace Bloom } void EventListener::waitAndDispatch(int msTimeout) { - auto queueLock = this->eventQueueByEventType.acquireLock(); - auto& eventQueueByType = this->eventQueueByEventType.getValue(); - auto registeredEventTypes = this->getRegisteredEventTypes(); - std::optional event; + { + auto queueLock = this->eventQueueByEventType.acquireLock(); + const auto& eventQueueByType = this->eventQueueByEventType.getValue(); + const auto registeredEventTypes = this->getRegisteredEventTypes(); + std::optional event; - auto eventsFound = [®isteredEventTypes, &event, &eventQueueByType]() -> bool { - for (auto& eventQueue: eventQueueByType) { - if (registeredEventTypes.contains(eventQueue.first) && !eventQueue.second.empty()) { - return true; + const auto eventsFound = [®isteredEventTypes, &event, &eventQueueByType]() -> bool { + for (auto& eventQueue: eventQueueByType) { + if (registeredEventTypes.contains(eventQueue.first) && !eventQueue.second.empty()) { + return true; + } } + return false; + }; + + if (msTimeout > 0) { + this->eventQueueByEventTypeCV.wait_for(queueLock, std::chrono::milliseconds(msTimeout), eventsFound); + + } else { + this->eventQueueByEventTypeCV.wait(queueLock, eventsFound); } - return false; - }; - - if (msTimeout > 0) { - this->eventQueueByEventTypeCV.wait_for(queueLock, std::chrono::milliseconds(msTimeout), eventsFound); - - } else { - this->eventQueueByEventTypeCV.wait(queueLock, eventsFound); } - /* - * We don't want the dispatch to block other threads from registering more events. We don't need the - * lock anymore so it's fine to release it here. - */ - queueLock.unlock(); - this->dispatchCurrentEvents(); } @@ -60,9 +59,8 @@ namespace Bloom Logger::debug("Dispatching event " + event->getName() + " (" + std::to_string(event->id) + ")."); // Dispatch the event to all registered handlers - auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock(); - auto& callbacks = this->eventTypeToCallbacksMapping.getValue().find(event->getType())->second; - mappingLock.unlock(); + const auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock(); + const auto& callbacks = this->eventTypeToCallbacksMapping.getValue().find(event->getType())->second; for (auto& callback : callbacks) { callback(*(event.get())); @@ -78,7 +76,7 @@ namespace Bloom } std::vector EventListener::getEvents() { - auto queueLock = this->eventQueueByEventType.acquireLock(); + const auto queueLock = this->eventQueueByEventType.acquireLock(); auto& eventQueueByType = this->eventQueueByEventType.getValue(); std::vector output; @@ -101,7 +99,7 @@ namespace Bloom } void EventListener::clearAllCallbacks() { - auto lock = this->eventTypeToCallbacksMapping.acquireLock(); + const auto lock = this->eventTypeToCallbacksMapping.acquireLock(); this->eventTypeToCallbacksMapping.getValue().clear(); } } diff --git a/src/EventManager/EventListener.hpp b/src/EventManager/EventListener.hpp index 279e3a30..505118d9 100644 --- a/src/EventManager/EventListener.hpp +++ b/src/EventManager/EventListener.hpp @@ -75,13 +75,13 @@ namespace Bloom */ template void registerEventType() { - auto registeredEventTypesLock = this->registeredEventTypes.acquireLock(); + const auto registeredEventTypesLock = this->registeredEventTypes.acquireLock(); this->registeredEventTypes.getValue().insert(EventType::type); } template void deRegisterEventType() { - auto registeredEventTypesLock = this->registeredEventTypes.acquireLock(); + const auto registeredEventTypesLock = this->registeredEventTypes.acquireLock(); this->registeredEventTypes.getValue().erase(EventType::type); } @@ -117,7 +117,7 @@ namespace Bloom } ; - auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock(); + const auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock(); auto& mapping = this->eventTypeToCallbacksMapping.getValue(); mapping[EventType::type].push_back(parentCallback); @@ -137,7 +137,7 @@ namespace Bloom ); { - auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock(); + const auto mappingLock = this->eventTypeToCallbacksMapping.acquireLock(); auto& mapping = this->eventTypeToCallbacksMapping.getValue(); if (mapping.contains(EventType::type)) { @@ -150,7 +150,7 @@ namespace Bloom this->registeredEventTypes.getValue().erase(EventType::type); } - auto queueLock = this->eventQueueByEventType.acquireLock(); + const auto queueLock = this->eventQueueByEventType.acquireLock(); auto& eventQueueByType = this->eventQueueByEventType.getValue(); if (eventQueueByType.contains(EventType::type)) { diff --git a/src/Helpers/BiMap.hpp b/src/Helpers/BiMap.hpp index 8ff7033e..8f9011fc 100644 --- a/src/Helpers/BiMap.hpp +++ b/src/Helpers/BiMap.hpp @@ -37,11 +37,22 @@ namespace Bloom return this->flippedMap.find(key) != this->flippedMap.end(); } + auto find(const TypeA& key) const { + const auto valueIt = this->map.find(key); + return valueIt != this->map.end() ? std::optional(valueIt) : std::nullopt; + } + + auto find(const TypeB& key) const { + const auto valueIt = this->flippedMap.find(key); + return valueIt != this->flippedMap.end() ? std::optional(valueIt) : std::nullopt; + } + std::optional valueAt(const TypeA& key) const { std::optional output; - if (this->contains(key)) { - output = this->map.find(key)->second; + const auto valueIt = this->map.find(key); + if (valueIt != this->map.end()) { + output = valueIt->second; } return output; @@ -50,8 +61,9 @@ namespace Bloom std::optional valueAt(const TypeB& key) const { std::optional output; - if (this->contains(key)) { - output = this->flippedMap.find(key)->second; + const auto valueIt = this->flippedMap.find(key); + if (valueIt != this->flippedMap.end()) { + output = valueIt->second; } return output; diff --git a/src/Helpers/Process.cpp b/src/Helpers/Process.cpp index dd1453b0..23020363 100644 --- a/src/Helpers/Process.cpp +++ b/src/Helpers/Process.cpp @@ -42,9 +42,10 @@ namespace Bloom } static auto cachedResultsByProcessId = std::map<::pid_t, bool>(); + const auto cachedResultIt = cachedResultsByProcessId.find(*processId); - if (cachedResultsByProcessId.contains(*processId)) { - return cachedResultsByProcessId.at(*processId); + if (cachedResultIt != cachedResultsByProcessId.end()) { + return cachedResultIt->second; } // Start with the parent process and walk the tree until we find CLion diff --git a/src/Insight/UserInterfaces/InsightWindow/InsightWindow.cpp b/src/Insight/UserInterfaces/InsightWindow/InsightWindow.cpp index bb84f88e..dd3aab5a 100644 --- a/src/Insight/UserInterfaces/InsightWindow/InsightWindow.cpp +++ b/src/Insight/UserInterfaces/InsightWindow/InsightWindow.cpp @@ -480,35 +480,41 @@ namespace Bloom return; } - std::optional previouslySelectedVariantName = (this->previouslySelectedVariant.has_value()) ? - std::optional(QString::fromStdString(this->previouslySelectedVariant->name).toLower()) + std::optional previouslySelectedVariantName = (this->previouslySelectedVariant.has_value()) + ? std::optional(QString::fromStdString(this->previouslySelectedVariant->name).toLower()) : std::nullopt; - if ( - previouslySelectedVariantName.has_value() - && this->supportedVariantsByName.contains(previouslySelectedVariantName.value()) - ) { - this->selectVariant(&(this->supportedVariantsByName.at(previouslySelectedVariantName.value()))); + if (previouslySelectedVariantName.has_value()) { + const auto previouslySelectedVariantIt = this->supportedVariantsByName.find(*previouslySelectedVariantName); - } else if (this->targetConfig.variantName.has_value()) { - auto selectedVariantName = QString::fromStdString(this->targetConfig.variantName.value()); - if (this->supportedVariantsByName.contains(selectedVariantName)) { - // The user has specified a valid variant name in their config file, so use that as the default - this->selectVariant(&(this->supportedVariantsByName.at(selectedVariantName))); - - } else { - Logger::error("Invalid target variant name \"" + this->targetConfig.variantName.value() - + "\" - no such variant with the given name was found."); + if (previouslySelectedVariantIt != this->supportedVariantsByName.end()) { + this->selectVariant(&(previouslySelectedVariantIt->second)); + return; } } - if (this->selectedVariant == nullptr) { - /* - * Given that we haven't been able to select a variant at this point, we will just fall back to the first - * one that is available. - */ - this->selectVariant(&(this->supportedVariantsByName.begin()->second)); + if (this->targetConfig.variantName.has_value()) { + const auto variantIt = this->supportedVariantsByName.find( + QString::fromStdString(*this->targetConfig.variantName) + ); + + if (variantIt != this->supportedVariantsByName.end()) { + // The user has specified a valid variant name in their config file, so use that as the default + this->selectVariant(&(variantIt->second)); + + } else { + Logger::error( + "Invalid target variant name \"" + this->targetConfig.variantName.value() + + "\" - no such variant with the given name was found." + ); + } } + + /* + * Given that we haven't been able to select a variant at this point, we will just fall back to the first + * one that is available. + */ + this->selectVariant(&(this->supportedVariantsByName.begin()->second)); } void InsightWindow::selectVariant(const TargetVariant* variant) { @@ -598,19 +604,22 @@ namespace Bloom // Target memory inspection panes auto* bottomPanelLayout = this->bottomPanel->layout(); - if (this->targetDescriptor.memoryDescriptorsByType.contains(TargetMemoryType::RAM)) { + + // We only support inspection of RAM and EEPROM, for now. + const auto ramDescriptorIt = this->targetDescriptor.memoryDescriptorsByType.find(TargetMemoryType::RAM); + const auto eepromDescriptorIt = this->targetDescriptor.memoryDescriptorsByType.find(TargetMemoryType::EEPROM); + + if (ramDescriptorIt != this->targetDescriptor.memoryDescriptorsByType.end()) { if (!this->insightProjectSettings.ramInspectionPaneState.has_value()) { this->insightProjectSettings.ramInspectionPaneState = PaneState(false, true, std::nullopt); } - auto& ramDescriptor = this->targetDescriptor.memoryDescriptorsByType.at(TargetMemoryType::RAM); - if (!memoryInspectionPaneSettingsByMemoryType.contains(TargetMemoryType::RAM)) { memoryInspectionPaneSettingsByMemoryType[TargetMemoryType::RAM] = TargetMemoryInspectionPaneSettings(); } this->ramInspectionPane = new TargetMemoryInspectionPane( - ramDescriptor, + ramDescriptorIt->second, memoryInspectionPaneSettingsByMemoryType[TargetMemoryType::RAM], *(this->insightProjectSettings.ramInspectionPaneState), this->bottomPanel @@ -641,19 +650,17 @@ namespace Bloom this->onRamInspectionPaneStateChanged(); } - if (this->targetDescriptor.memoryDescriptorsByType.contains(TargetMemoryType::EEPROM)) { + if (eepromDescriptorIt != this->targetDescriptor.memoryDescriptorsByType.end()) { if (!this->insightProjectSettings.eepromInspectionPaneState.has_value()) { this->insightProjectSettings.eepromInspectionPaneState = PaneState(false, true, std::nullopt); } - auto& eepromDescriptor = this->targetDescriptor.memoryDescriptorsByType.at(TargetMemoryType::EEPROM); - if (!memoryInspectionPaneSettingsByMemoryType.contains(TargetMemoryType::EEPROM)) { memoryInspectionPaneSettingsByMemoryType[TargetMemoryType::EEPROM] = TargetMemoryInspectionPaneSettings(); } this->eepromInspectionPane = new TargetMemoryInspectionPane( - eepromDescriptor, + eepromDescriptorIt->second, memoryInspectionPaneSettingsByMemoryType[TargetMemoryType::EEPROM], *(this->insightProjectSettings.eepromInspectionPaneState), this->bottomPanel diff --git a/src/Insight/UserInterfaces/InsightWindow/UiLoader.cpp b/src/Insight/UserInterfaces/InsightWindow/UiLoader.cpp index b9f932b1..93348ce7 100644 --- a/src/Insight/UserInterfaces/InsightWindow/UiLoader.cpp +++ b/src/Insight/UserInterfaces/InsightWindow/UiLoader.cpp @@ -94,9 +94,11 @@ namespace Bloom } QWidget* UiLoader::createWidget(const QString& className, QWidget* parent, const QString& name) { - if (this->customWidgetConstructorsByWidgetName.contains(className)) { + const auto widgetContructorIt = this->customWidgetConstructorsByWidgetName.find(className); + + if (widgetContructorIt != this->customWidgetConstructorsByWidgetName.end()) { // This is a custom widget - call the mapped constructor - return this->customWidgetConstructorsByWidgetName.at(className)(parent, name); + return widgetContructorIt->second(parent, name); } return QUiLoader::createWidget(className, parent, name); diff --git a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/HexViewerWidget/ByteItemGraphicsScene.cpp b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/HexViewerWidget/ByteItemGraphicsScene.cpp index b1f49dbe..0a7a0995 100644 --- a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/HexViewerWidget/ByteItemGraphicsScene.cpp +++ b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/HexViewerWidget/ByteItemGraphicsScene.cpp @@ -312,8 +312,9 @@ namespace Bloom::Widgets } QPointF ByteItemGraphicsScene::getByteItemPositionByAddress(std::uint32_t address) { - if (this->byteItemsByAddress.contains(address)) { - return this->byteItemsByAddress.at(address)->pos(); + const auto byteItemIt = this->byteItemsByAddress.find(address); + if (byteItemIt != this->byteItemsByAddress.end()) { + return byteItemIt->second->pos(); } return QPointF(); @@ -623,12 +624,13 @@ namespace Bloom::Widgets } for (auto* annotationItem : this->annotationItems) { - if (!this->byteItemsByAddress.contains(annotationItem->startAddress)) { + const auto firstByteItemIt = this->byteItemsByAddress.find(annotationItem->startAddress); + if (firstByteItemIt == this->byteItemsByAddress.end()) { annotationItem->hide(); continue; } - const auto firstByteItemPosition = this->byteItemsByAddress.at(annotationItem->startAddress)->pos(); + const auto firstByteItemPosition = firstByteItemIt->second->pos(); if (annotationItem->position == AnnotationItemPosition::TOP) { annotationItem->setPos( @@ -646,7 +648,6 @@ namespace Bloom::Widgets } void ByteItemGraphicsScene::onTargetStateChanged(Targets::TargetState newState) { - using Targets::TargetState; this->targetState = newState; } diff --git a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/MemoryRegionManager/FocusedRegionItem.cpp b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/MemoryRegionManager/FocusedRegionItem.cpp index cc3ac15a..860dc118 100644 --- a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/MemoryRegionManager/FocusedRegionItem.cpp +++ b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/MemoryRegionManager/FocusedRegionItem.cpp @@ -42,22 +42,24 @@ namespace Bloom::Widgets this->endAddressInput->text().toUInt(nullptr, 16) ); this->memoryRegion.addressRangeInputType = this->getSelectedAddressInputType(); - this->memoryRegion.addressRange = - this->memoryRegion.addressRangeInputType == AddressType::RELATIVE ? - this->convertRelativeToAbsoluteAddressRange(inputAddressRange) : inputAddressRange; + this->memoryRegion.addressRange = this->memoryRegion.addressRangeInputType == AddressType::RELATIVE + ? this->convertRelativeToAbsoluteAddressRange(inputAddressRange) + : inputAddressRange; - auto selectedDataTypeOptionName = this->dataTypeInput->currentData().toString(); - if (FocusedRegionItem::dataTypeOptionsByName.contains(selectedDataTypeOptionName)) { - this->memoryRegion.dataType = FocusedRegionItem::dataTypeOptionsByName.at( - selectedDataTypeOptionName - ).dataType; + const auto selectedDataTypeIt = FocusedRegionItem::dataTypeOptionsByName.find( + this->dataTypeInput->currentData().toString() + ); + + if (selectedDataTypeIt != FocusedRegionItem::dataTypeOptionsByName.end()) { + this->memoryRegion.dataType = selectedDataTypeIt->second.dataType; } - auto selectedEndiannessOptionName = this->endiannessInput->currentData().toString(); - if (FocusedRegionItem::endiannessOptionsByName.contains(selectedEndiannessOptionName)) { - this->memoryRegion.endianness = FocusedRegionItem::endiannessOptionsByName.at( - selectedEndiannessOptionName - ).endianness; + const auto selectedEndiannessIt = FocusedRegionItem::endiannessOptionsByName.find( + this->endiannessInput->currentData().toString() + ); + + if (selectedEndiannessIt != FocusedRegionItem::endiannessOptionsByName.end()) { + this->memoryRegion.endianness = selectedEndiannessIt->second.endianness; } } diff --git a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/MemoryRegionManager/RegionItem.cpp b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/MemoryRegionManager/RegionItem.cpp index 9e5c181f..683a4ea4 100644 --- a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/MemoryRegionManager/RegionItem.cpp +++ b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/MemoryRegionManager/RegionItem.cpp @@ -176,9 +176,12 @@ namespace Bloom::Widgets } AddressType RegionItem::getSelectedAddressInputType() const { - auto selectedAddressTypeOptionName = this->addressTypeInput->currentData().toString(); - if (RegionItem::addressRangeTypeOptionsByName.contains(selectedAddressTypeOptionName)) { - return RegionItem::addressRangeTypeOptionsByName.at(selectedAddressTypeOptionName).addressType; + const auto selectedAddressTypeIt = RegionItem::addressRangeTypeOptionsByName.find( + this->addressTypeInput->currentData().toString() + ); + + if (selectedAddressTypeIt != RegionItem::addressRangeTypeOptionsByName.end()) { + return selectedAddressTypeIt->second.addressType; } return AddressType::ABSOLUTE; diff --git a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/TargetMemoryInspectionPane.cpp b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/TargetMemoryInspectionPane.cpp index c7f3a73c..54976f15 100644 --- a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/TargetMemoryInspectionPane.cpp +++ b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetMemoryInspectionPane/TargetMemoryInspectionPane.cpp @@ -395,7 +395,8 @@ namespace Bloom::Widgets }; for (const auto& focusedRegion : this->settings.focusedMemoryRegions) { - if (!this->targetMemoryDescriptor.addressRange.contains(focusedRegion.addressRange) + if ( + !this->targetMemoryDescriptor.addressRange.contains(focusedRegion.addressRange) || regionIntersects(focusedRegion) ) { continue; @@ -405,7 +406,8 @@ namespace Bloom::Widgets } for (const auto& excludedRegion : this->settings.excludedMemoryRegions) { - if (!this->targetMemoryDescriptor.addressRange.contains(excludedRegion.addressRange) + if ( + !this->targetMemoryDescriptor.addressRange.contains(excludedRegion.addressRange) || regionIntersects(excludedRegion) ) { continue; diff --git a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.cpp b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.cpp index 868e1c47..c411d7c5 100644 --- a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.cpp +++ b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.cpp @@ -243,10 +243,10 @@ namespace Bloom::Widgets const auto& descriptor = targetRegister.descriptor; for (const auto& registerGroupWidget : this->registerGroupWidgets) { - if (registerGroupWidget->registerWidgetsMappedByDescriptor.contains(descriptor)) { - registerGroupWidget->registerWidgetsMappedByDescriptor.at( - descriptor - )->setRegisterValue(targetRegister); + const auto registerWidgetit = registerGroupWidget->registerWidgetsMappedByDescriptor.find(descriptor); + + if (registerWidgetit != registerGroupWidget->registerWidgetsMappedByDescriptor.end()) { + registerWidgetit->second->setRegisterValue(targetRegister); break; } } diff --git a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetWidgets/TargetPackageWidget.cpp b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetWidgets/TargetPackageWidget.cpp index eb9cc154..288a3b43 100644 --- a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetWidgets/TargetPackageWidget.cpp +++ b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetWidgets/TargetPackageWidget.cpp @@ -73,9 +73,10 @@ namespace Bloom::Widgets::InsightTargetWidgets void TargetPackageWidget::updatePinStates(const Targets::TargetPinStateMapping& pinStatesByNumber) { for (auto& pinWidget : this->pinWidgets) { - auto pinNumber = pinWidget->getPinNumber(); - if (pinStatesByNumber.contains(pinNumber)) { - pinWidget->updatePinState(pinStatesByNumber.at(pinNumber)); + const auto pinStateIt = pinStatesByNumber.find(pinWidget->getPinNumber()); + + if (pinStateIt != pinStatesByNumber.end()) { + pinWidget->updatePinState(pinStateIt->second); } } diff --git a/src/SignalHandler/SignalHandler.cpp b/src/SignalHandler/SignalHandler.cpp index 4d786598..76ee14b9 100644 --- a/src/SignalHandler/SignalHandler.cpp +++ b/src/SignalHandler/SignalHandler.cpp @@ -19,9 +19,10 @@ namespace Bloom if (::sigwait(&signalSet, &signalNumber) == 0) { Logger::debug("SIGNAL " + std::to_string(signalNumber) + " received"); - if (this->handlersBySignalNum.contains(signalNumber)) { + const auto handlerIt = this->handlersBySignalNum.find(signalNumber); + if (handlerIt != this->handlersBySignalNum.end()) { // We have a registered handler for this signal. - this->handlersBySignalNum.at(signalNumber)(); + handlerIt->second(); } } } diff --git a/src/TargetController/TargetControllerComponent.cpp b/src/TargetController/TargetControllerComponent.cpp index 89e6bc20..d0959fbb 100644 --- a/src/TargetController/TargetControllerComponent.cpp +++ b/src/TargetController/TargetControllerComponent.cpp @@ -355,12 +355,12 @@ namespace Bloom::TargetController for (auto mapIt = avr8PdMapping.begin(); mapIt != avr8PdMapping.end(); mapIt++) { // Each target signature maps to an array of targets, as numerous targets can possess the same signature. - auto targets = mapIt.value().toArray(); + const auto targets = mapIt.value().toArray(); for (auto targetIt = targets.begin(); targetIt != targets.end(); targetIt++) { - auto targetName = targetIt->toObject().find("targetName").value().toString() + const auto targetName = targetIt->toObject().find("targetName").value().toString() .toLower().toStdString(); - auto targetSignatureHex = mapIt.key().toLower().toStdString(); + const auto targetSignatureHex = mapIt.key().toLower().toStdString(); if (!mapping.contains(targetName)) { mapping.insert({ @@ -395,7 +395,9 @@ namespace Bloom::TargetController const auto commandType = command->getType(); try { - if (!this->commandHandlersByCommandType.contains(commandType)) { + const auto commandHandlerIt = this->commandHandlersByCommandType.find(commandType); + + if (commandHandlerIt == this->commandHandlersByCommandType.end()) { throw Exception("No handler registered for this command."); } @@ -415,10 +417,7 @@ namespace Bloom::TargetController } } - this->registerCommandResponse( - commandId, - this->commandHandlersByCommandType.at(commandType)(*(command.get())) - ); + this->registerCommandResponse(commandId, commandHandlerIt->second(*(command.get()))); } catch (const Exception& exception) { this->registerCommandResponse( @@ -543,23 +542,26 @@ namespace Bloom::TargetController auto debugToolName = this->environmentConfig.debugToolConfig.name; auto targetName = this->environmentConfig.targetConfig.name; - static auto supportedDebugTools = this->getSupportedDebugTools(); - static auto supportedTargets = this->getSupportedTargets(); + static const auto supportedDebugTools = this->getSupportedDebugTools(); + static const auto supportedTargets = this->getSupportedTargets(); - if (!supportedDebugTools.contains(debugToolName)) { + const auto debugToolIt = supportedDebugTools.find(debugToolName); + const auto targetIt = supportedTargets.find(targetName); + + if (debugToolIt == supportedDebugTools.end()) { throw Exceptions::InvalidConfig( "Debug tool name (\"" + debugToolName + "\") not recognised. Please check your configuration!" ); } - if (!supportedTargets.contains(targetName)) { + if (targetIt == supportedTargets.end()) { throw Exceptions::InvalidConfig( "Target name (\"" + targetName + "\") not recognised. Please check your configuration!" ); } // Initiate debug tool and target - this->debugTool = supportedDebugTools.at(debugToolName)(); + this->debugTool = debugToolIt->second(); Logger::info("Connecting to debug tool"); this->debugTool->init(); @@ -568,7 +570,7 @@ namespace Bloom::TargetController Logger::info("Debug tool name: " + this->debugTool->getName()); Logger::info("Debug tool serial: " + this->debugTool->getSerialNumber()); - this->target = supportedTargets.at(targetName)(); + this->target = targetIt->second(); if (!this->target->isDebugToolSupported(this->debugTool.get())) { throw Exceptions::InvalidConfig( @@ -634,16 +636,17 @@ namespace Bloom::TargetController auto startAddress = registerDescriptor.startAddress.value_or(0); auto endAddress = startAddress + (registerDescriptor.size - 1); - if (!this->registerAddressRangeByMemoryType.contains(registerDescriptor.memoryType)) { - auto addressRange = TargetMemoryAddressRange(); - addressRange.startAddress = startAddress; - addressRange.endAddress = endAddress; + const auto registerAddressRangeIt = this->registerAddressRangeByMemoryType.find( + registerDescriptor.memoryType + ); + + if (registerAddressRangeIt == this->registerAddressRangeByMemoryType.end()) { this->registerAddressRangeByMemoryType.insert( - std::pair(registerDescriptor.memoryType, addressRange) + std::pair(registerDescriptor.memoryType, TargetMemoryAddressRange(startAddress, endAddress)) ); } else { - auto& addressRange = this->registerAddressRangeByMemoryType.at(registerDescriptor.memoryType); + auto& addressRange = registerAddressRangeIt->second; if (startAddress < addressRange.startAddress) { addressRange.startAddress = startAddress; @@ -666,24 +669,28 @@ namespace Bloom::TargetController ) { auto output = TargetRegisterDescriptors(); - if (this->registerAddressRangeByMemoryType.contains(memoryType) - && this->registerDescriptorsByMemoryType.contains(memoryType) + const auto registerAddressRangeIt = this->registerAddressRangeByMemoryType.find(memoryType); + const auto registerDescriptorsIt = this->registerDescriptorsByMemoryType.find(memoryType); + + if ( + registerAddressRangeIt != this->registerAddressRangeByMemoryType.end() + && registerDescriptorsIt != this->registerDescriptorsByMemoryType.end() ) { - auto& registersAddressRange = this->registerAddressRangeByMemoryType.at(memoryType); + const auto& registersAddressRange = registerAddressRangeIt->second; if ( (startAddress <= registersAddressRange.startAddress && endAddress >= registersAddressRange.startAddress) || (startAddress <= registersAddressRange.endAddress && endAddress >= registersAddressRange.startAddress) ) { - auto& registerDescriptors = this->registerDescriptorsByMemoryType.at(memoryType); + const auto& registerDescriptors = this->registerDescriptorsByMemoryType.at(memoryType); for (const auto& registerDescriptor : registerDescriptors) { if (!registerDescriptor.startAddress.has_value() || registerDescriptor.size < 1) { continue; } - auto registerStartAddress = registerDescriptor.startAddress.value(); - auto registerEndAddress = registerStartAddress + registerDescriptor.size; + const auto registerStartAddress = registerDescriptor.startAddress.value(); + const auto registerEndAddress = registerStartAddress + registerDescriptor.size; if ( (startAddress <= registerStartAddress && endAddress >= registerStartAddress) diff --git a/src/Targets/Microchip/AVR/AVR8/Avr8.cpp b/src/Targets/Microchip/AVR/AVR8/Avr8.cpp index 7cc10630..7c1072bc 100644 --- a/src/Targets/Microchip/AVR/AVR8/Avr8.cpp +++ b/src/Targets/Microchip/AVR/AVR8/Avr8.cpp @@ -454,12 +454,14 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit } std::map Avr8::getPinStates(int variantId) { - if (!this->targetVariantsById.contains(variantId)) { + const auto targetVariantIt = this->targetVariantsById.find(variantId); + + if (targetVariantIt == this->targetVariantsById.end()) { throw Exception("Invalid target variant ID"); } std::map output; - auto& variant = this->targetVariantsById.at(variantId); + const auto& variant = targetVariantIt->second; /* * To prevent the number of memory reads we perform here, we cache the data and map it by start address. @@ -471,24 +473,28 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit * will be considered when the need for it becomes apparent. */ std::map cachedMemoryByStartAddress; - auto readMemoryBitset = [this, &cachedMemoryByStartAddress] (std::uint16_t startAddress) { - if (!cachedMemoryByStartAddress.contains(startAddress)) { - cachedMemoryByStartAddress.insert( + const auto readMemoryBitset = [this, &cachedMemoryByStartAddress] (std::uint16_t startAddress) { + auto cachedByteIt = cachedMemoryByStartAddress.find(startAddress); + + if (cachedByteIt == cachedMemoryByStartAddress.end()) { + cachedByteIt = cachedMemoryByStartAddress.insert( std::pair( startAddress, this->readMemory(TargetMemoryType::RAM, startAddress, 1) ) - ); + ).first; } return std::bitset::digits>( - cachedMemoryByStartAddress.at(startAddress).at(0) + cachedByteIt->second.at(0) ); }; for (const auto& [pinNumber, pinDescriptor] : variant.pinDescriptorsByNumber) { - if (this->padDescriptorsByName.contains(pinDescriptor.padName)) { - auto& pad = this->padDescriptorsByName.at(pinDescriptor.padName); + const auto padIt = this->padDescriptorsByName.find(pinDescriptor.padName); + + if (padIt != this->padDescriptorsByName.end()) { + const auto& pad = padIt->second; if (!pad.gpioPinNumber.has_value()) { continue; @@ -526,12 +532,15 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit } void Avr8::setPinState(const TargetPinDescriptor& pinDescriptor, const TargetPinState& state) { - auto variantId = pinDescriptor.variantId; - if (!this->targetVariantsById.contains(variantId)) { + const auto targetVariantIt = this->targetVariantsById.find(pinDescriptor.variantId); + + if (targetVariantIt == this->targetVariantsById.end()) { throw Exception("Invalid target variant ID"); } - if (!this->padDescriptorsByName.contains(pinDescriptor.padName)) { + const auto padDescriptorIt = this->padDescriptorsByName.find(pinDescriptor.padName); + + if (padDescriptorIt == this->padDescriptorsByName.end()) { throw Exception("Unknown pad"); } @@ -539,8 +548,8 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit throw Exception("Missing IO direction state"); } - const auto& variant = this->targetVariantsById.at(variantId); - const auto& padDescriptor = this->padDescriptorsByName.at(pinDescriptor.padName); + const auto& variant = targetVariantIt->second; + const auto& padDescriptor = padDescriptorIt->second; auto ioState = state.ioState; if (state.ioDirection == TargetPinState::IoDirection::INPUT) { diff --git a/src/Targets/Microchip/AVR/AVR8/Avr8.hpp b/src/Targets/Microchip/AVR/AVR8/Avr8.hpp index 8205d7ff..ce3f7021 100644 --- a/src/Targets/Microchip/AVR/AVR8/Avr8.hpp +++ b/src/Targets/Microchip/AVR/AVR8/Avr8.hpp @@ -28,8 +28,10 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit { public: explicit Avr8() = default; - Avr8(std::string name, const TargetSignature& signature): name(std::move(name)) { - this->id = signature; + Avr8(std::string name, const TargetSignature& signature) + : name(std::move(name)) + , Target(signature) + { this->initFromTargetDescriptionFile(); }; diff --git a/src/Targets/Microchip/AVR/AVR8/Avr8TargetConfig.cpp b/src/Targets/Microchip/AVR/AVR8/Avr8TargetConfig.cpp index c775abc7..6154d592 100644 --- a/src/Targets/Microchip/AVR/AVR8/Avr8TargetConfig.cpp +++ b/src/Targets/Microchip/AVR/AVR8/Avr8TargetConfig.cpp @@ -18,8 +18,11 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit } const auto physicalInterfaceName = String::asciiToLower(targetNode["physicalInterface"].as()); + const auto physicalInterfaceIt = Avr8TargetConfig::debugPhysicalInterfacesByConfigName.find( + physicalInterfaceName + ); - if (!Avr8TargetConfig::debugPhysicalInterfacesByConfigName.contains(physicalInterfaceName)) { + if (physicalInterfaceIt == Avr8TargetConfig::debugPhysicalInterfacesByConfigName.end()) { throw InvalidConfig( "Invalid physical interface provided (\"" + physicalInterfaceName + "\") for AVR8 target. " "See " + Paths::homeDomainName() + "/docs/configuration/avr8-physical-interfaces for valid physical " @@ -27,7 +30,7 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit ); } - this->physicalInterface = Avr8TargetConfig::debugPhysicalInterfacesByConfigName.at(physicalInterfaceName); + this->physicalInterface = physicalInterfaceIt->second; // The 'manageDwenFuseBit' param used to be 'updateDwenFuseBit' - we still support the old, for now. if (targetNode["updateDwenFuseBit"]) { diff --git a/src/Targets/Microchip/AVR/AVR8/TargetDescription/TargetDescriptionFile.cpp b/src/Targets/Microchip/AVR/AVR8/TargetDescription/TargetDescriptionFile.cpp index 365d30bd..c0d977ae 100644 --- a/src/Targets/Microchip/AVR/AVR8/TargetDescription/TargetDescriptionFile.cpp +++ b/src/Targets/Microchip/AVR/AVR8/TargetDescription/TargetDescriptionFile.cpp @@ -26,71 +26,66 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription const TargetSignature& targetSignature, std::optional targetName ) { - auto targetSignatureHex = targetSignature.toHex(); - auto mapping = TargetDescriptionFile::getTargetDescriptionMapping(); - auto qTargetSignatureHex = QString::fromStdString(targetSignatureHex).toLower(); + const auto targetSignatureHex = targetSignature.toHex(); + const auto mapping = TargetDescriptionFile::getTargetDescriptionMapping(); + const auto descriptionFiles = mapping.find(QString::fromStdString(targetSignatureHex).toLower())->toArray(); - if (mapping.contains(qTargetSignatureHex)) { - // We have a match for the target signature. - auto descriptionFilesJsonArray = mapping.find(qTargetSignatureHex).value().toArray(); - auto matchingDescriptionFiles = std::vector(); - std::copy_if( - descriptionFilesJsonArray.begin(), - descriptionFilesJsonArray.end(), - std::back_inserter(matchingDescriptionFiles), - [&targetName] (const QJsonValue& value) { - auto pdTargetName = value.toObject().find("targetName")->toString().toLower().toStdString(); - return !targetName.has_value() || (targetName.has_value() && targetName.value() == pdTargetName); + if (descriptionFiles.empty()) { + throw Exception( + "Failed to resolve target description file for target \"" + targetSignatureHex + + "\" - unknown target signature." + ); + } + + if (descriptionFiles.size() > 1 && !targetName.has_value()) { + /* + * There are numerous target description files mapped to this target signature and we don't have a target + * name to filter by. There's really not much we can do at this point, so we'll just instruct the user to + * provide a specific target name. + */ + auto targetNames = QStringList(); + std::transform( + descriptionFiles.begin(), + descriptionFiles.end(), + std::back_inserter(targetNames), + [] (const QJsonValue& descriptionFile) { + return QString( + "\"" + descriptionFile.toObject().find("targetName")->toString().toLower() + "\"" + ); } ); - if (targetName.has_value() && matchingDescriptionFiles.empty()) { - throw Exception("Failed to resolve target description file for target \"" + targetName.value() - + "\" - target signature \"" + targetSignatureHex + "\" does not belong to target with name \"" + - targetName.value() + "\". Please review your bloom.yaml configuration."); - } - - if (matchingDescriptionFiles.size() == 1) { - // Attempt to load the XML target description file - auto descriptionFilePath = QString::fromStdString(Paths::applicationDirPath()) + "/" - + matchingDescriptionFiles.front().toObject().find("targetDescriptionFilePath")->toString(); - - Logger::debug("Loading AVR8 target description file: " + descriptionFilePath.toStdString()); - Targets::TargetDescription::TargetDescriptionFile::init(descriptionFilePath); - - } else if (matchingDescriptionFiles.size() > 1) { - /* - * There are numerous target description files mapped to this target signature. There's really not - * much we can do at this point, so we'll just instruct the user to use a more specific target name. - */ - QStringList targetNames; - std::transform( - matchingDescriptionFiles.begin(), - matchingDescriptionFiles.end(), - std::back_inserter(targetNames), - [] (const QJsonValue& descriptionFile) { - return QString( - "\"" + descriptionFile.toObject().find("targetName")->toString().toLower() + "\"" - ); - } - ); - - throw Exception("Failed to resolve target description file for target \"" - + targetSignatureHex + "\" - ambiguous signature.\nThe signature is mapped to numerous targets: " - + targetNames.join(", ").toStdString() + ".\n\nPlease update the target name in your Bloom " + - "configuration to one of the above." - ); - - } else { - throw Exception("Failed to resolve target description file for target \"" - + targetSignatureHex + "\" - invalid AVR8 target description mapping." - ); - } - - } else { - throw Exception("Failed to resolve target description file for target \"" - + targetSignatureHex + "\" - unknown target signature."); + throw Exception( + "Failed to resolve target description file for target \"" + targetSignatureHex + + "\" - ambiguous signature.\nThe signature is mapped to numerous targets: " + + targetNames.join(", ").toStdString() + ".\n\nPlease update the target name in your Bloom " + + "configuration file, to one of the above." + ); } + + for (const auto& mappingJsonValue : descriptionFiles) { + const auto mappingObject = mappingJsonValue.toObject(); + + if ( + targetName.has_value() + && *targetName != mappingObject.find("targetName")->toString().toLower().toStdString() + ) { + continue; + } + + const auto descriptionFilePath = QString::fromStdString(Paths::applicationDirPath()) + "/" + + mappingObject.find("targetDescriptionFilePath")->toString(); + + Logger::debug("Loading AVR8 target description file: " + descriptionFilePath.toStdString()); + Targets::TargetDescription::TargetDescriptionFile::init(descriptionFilePath); + return; + } + + throw Exception( + "Failed to resolve target description file for target \"" + *targetName + + "\" - target signature \"" + targetSignatureHex + "\" does not belong to target with name \"" + + *targetName + "\". Please review your bloom.yaml configuration." + ); } void TargetDescriptionFile::init(const QDomDocument& xml) { @@ -117,34 +112,30 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription TargetSignature TargetDescriptionFile::getTargetSignature() const { const auto& propertyGroups = this->propertyGroupsMappedByName; - auto signaturePropertyGroupIt = propertyGroups.find("signatures"); + const auto signaturePropertyGroupIt = propertyGroups.find("signatures"); if (signaturePropertyGroupIt == propertyGroups.end()) { throw TargetDescriptionParsingFailureException("Signature property group not found"); } - auto signaturePropertyGroup = signaturePropertyGroupIt->second; - const auto& signatureProperties = signaturePropertyGroup.propertiesMappedByName; + const auto& signatureProperties = signaturePropertyGroupIt->second.propertiesMappedByName; std::optional signatureByteZero; std::optional signatureByteOne; std::optional signatureByteTwo; - if (signatureProperties.contains("signature0")) { - signatureByteZero = static_cast( - signatureProperties.at("signature0").value.toShort(nullptr, 16) - ); + const auto signatureZeroIt = signatureProperties.find("signature0"); + if (signatureZeroIt != signatureProperties.end()) { + signatureByteZero = static_cast(signatureZeroIt->second.value.toShort(nullptr, 16)); } - if (signatureProperties.contains("signature1")) { - signatureByteOne = static_cast( - signatureProperties.at("signature1").value.toShort(nullptr, 16) - ); + const auto signatureOneIt = signatureProperties.find("signature1"); + if (signatureOneIt != signatureProperties.end()) { + signatureByteOne = static_cast(signatureOneIt->second.value.toShort(nullptr, 16)); } - if (signatureProperties.contains("signature2")) { - signatureByteTwo = static_cast( - signatureProperties.at("signature2").value.toShort(nullptr, 16) - ); + const auto signatureTwoIt = signatureProperties.find("signature2"); + if (signatureTwoIt != signatureProperties.end()) { + signatureByteTwo = static_cast(signatureTwoIt->second.value.toShort(nullptr, 16)); } if (signatureByteZero.has_value() && signatureByteOne.has_value() && signatureByteTwo.has_value()) { @@ -157,8 +148,9 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } Family TargetDescriptionFile::getFamily() const { - static auto familyNameToEnums = TargetDescriptionFile::getFamilyNameToEnumMapping(); - auto familyName = this->deviceElement.attributes().namedItem( + static const auto targetFamiliesByName = TargetDescriptionFile::getFamilyNameToEnumMapping(); + + const auto familyName = this->deviceElement.attributes().namedItem( "family" ).nodeValue().toLower().toStdString(); @@ -166,11 +158,13 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription throw Exception("Could not find target family name in target description file."); } - if (!familyNameToEnums.contains(familyName)) { + const auto familyIt = targetFamiliesByName.find(familyName); + + if (familyIt == targetFamiliesByName.end()) { throw Exception("Unknown family name in target description file."); } - return familyNameToEnums.at(familyName); + return familyIt->second; } TargetParameters TargetDescriptionFile::getTargetParameters() const { @@ -192,25 +186,25 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } } - auto ramMemorySegment = this->getRamMemorySegment(); + const auto ramMemorySegment = this->getRamMemorySegment(); if (ramMemorySegment.has_value()) { targetParameters.ramSize = ramMemorySegment->size; targetParameters.ramStartAddress = ramMemorySegment->startAddress; } - auto ioMemorySegment = this->getIoMemorySegment(); + const auto ioMemorySegment = this->getIoMemorySegment(); if (ioMemorySegment.has_value()) { targetParameters.mappedIoSegmentSize = ioMemorySegment->size; targetParameters.mappedIoSegmentStartAddress = ioMemorySegment->startAddress; } - auto registerMemorySegment = this->getRegisterMemorySegment(); + const auto registerMemorySegment = this->getRegisterMemorySegment(); if (registerMemorySegment.has_value()) { targetParameters.gpRegisterSize = registerMemorySegment->size; targetParameters.gpRegisterStartAddress = registerMemorySegment->startAddress; } - auto eepromMemorySegment = this->getEepromMemorySegment(); + const auto eepromMemorySegment = this->getEepromMemorySegment(); if (eepromMemorySegment.has_value()) { targetParameters.eepromSize = eepromMemorySegment->size; targetParameters.eepromStartAddress = eepromMemorySegment->startAddress; @@ -220,7 +214,7 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } } - auto firstBootSectionMemorySegment = this->getFirstBootSectionMemorySegment(); + const auto firstBootSectionMemorySegment = this->getFirstBootSectionMemorySegment(); if (firstBootSectionMemorySegment.has_value()) { targetParameters.bootSectionStartAddress = firstBootSectionMemorySegment->startAddress / 2; targetParameters.bootSectionSize = firstBootSectionMemorySegment->size; @@ -228,33 +222,36 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription std::uint32_t cpuRegistersOffset = 0; - if (peripheralModules.contains("cpu")) { - auto cpuPeripheralModule = peripheralModules.at("cpu"); + const auto cpuPeripheralModuleIt = peripheralModules.find("cpu"); + if (cpuPeripheralModuleIt != peripheralModules.end()) { + const auto& cpuPeripheralModule = cpuPeripheralModuleIt->second; - if (cpuPeripheralModule.instancesMappedByName.contains("cpu")) { - auto cpuInstance = cpuPeripheralModule.instancesMappedByName.at("cpu"); + const auto cpuInstanceIt = cpuPeripheralModule.instancesMappedByName.find("cpu"); + if (cpuInstanceIt != cpuPeripheralModule.instancesMappedByName.end()) { + const auto& cpuInstance = cpuInstanceIt->second; - if (cpuInstance.registerGroupsMappedByName.contains("cpu")) { - cpuRegistersOffset = cpuInstance.registerGroupsMappedByName.at("cpu").offset.value_or(0); + const auto cpuRegisterGroupIt = cpuInstance.registerGroupsMappedByName.find("cpu"); + if (cpuRegisterGroupIt != cpuInstance.registerGroupsMappedByName.end()) { + cpuRegistersOffset = cpuRegisterGroupIt->second.offset.value_or(0); } } } - auto statusRegister = this->getStatusRegister(); + const auto statusRegister = this->getStatusRegister(); if (statusRegister.has_value()) { targetParameters.statusRegisterStartAddress = cpuRegistersOffset + statusRegister->offset; targetParameters.statusRegisterSize = statusRegister->size; } - auto stackPointerRegister = this->getStackPointerRegister(); + const auto stackPointerRegister = this->getStackPointerRegister(); if (stackPointerRegister.has_value()) { targetParameters.stackPointerRegisterLowAddress = cpuRegistersOffset + stackPointerRegister->offset; targetParameters.stackPointerRegisterSize = stackPointerRegister->size; } else { // Sometimes the SP register is split into two register nodes, one for low, the other for high - auto stackPointerLowRegister = this->getStackPointerLowRegister(); - auto stackPointerHighRegister = this->getStackPointerHighRegister(); + const auto stackPointerLowRegister = this->getStackPointerLowRegister(); + const auto stackPointerHighRegister = this->getStackPointerHighRegister(); if (stackPointerLowRegister.has_value()) { targetParameters.stackPointerRegisterLowAddress = cpuRegistersOffset @@ -272,7 +269,8 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription const auto& supportedPhysicalInterfaces = this->getSupportedPhysicalInterfaces(); - if (supportedPhysicalInterfaces.contains(PhysicalInterface::DEBUG_WIRE) + if ( + supportedPhysicalInterfaces.contains(PhysicalInterface::DEBUG_WIRE) || supportedPhysicalInterfaces.contains(PhysicalInterface::JTAG) ) { this->loadDebugWireAndJtagTargetParameters(targetParameters); @@ -406,91 +404,125 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription }); for (const auto& [interfaceName, interface]: this->interfacesByName) { - if (interfaceNamesToInterfaces.contains(interfaceName)) { - this->supportedPhysicalInterfaces.insert(interfaceNamesToInterfaces.at(interfaceName)); + const auto interfaceIt = interfaceNamesToInterfaces.find(interfaceName); + if (interfaceIt != interfaceNamesToInterfaces.end()) { + this->supportedPhysicalInterfaces.insert(interfaceIt->second); } } } void TargetDescriptionFile::loadPadDescriptors() { const auto& modules = this->getModulesMappedByName(); - const auto portModule = (modules.contains("port")) ? std::optional(modules.find("port")->second) - : std::nullopt; + + const auto portModuleIt = modules.find("port"); + const auto portModule = (portModuleIt != modules.end()) ? std::optional(portModuleIt->second) : std::nullopt; + const auto& peripheralModules = this->getPeripheralModulesMappedByName(); - if (peripheralModules.contains("port")) { - auto portPeripheralModule = peripheralModules.find("port")->second; + const auto portPeripheralModuleIt = peripheralModules.find("port"); + if (portPeripheralModuleIt == peripheralModules.end()) { + return; + } - for (const auto& [instanceName, instance] : portPeripheralModule.instancesMappedByName) { - if (instanceName.find("port") == 0) { - auto portPeripheralRegisterGroup = (portPeripheralModule.registerGroupsMappedByName.contains(instanceName)) ? - std::optional(portPeripheralModule.registerGroupsMappedByName.find(instanceName)->second) : - std::nullopt; + const auto& portPeripheralModule = portPeripheralModuleIt->second; - for (const auto& signal : instance.instanceSignals) { - if (!signal.index.has_value()) { + for (const auto& [instanceName, instance] : portPeripheralModule.instancesMappedByName) { + if (instanceName.find("port") != 0) { + continue; + } + + const auto portPeripheralRegisterGroupIt = portPeripheralModule.registerGroupsMappedByName.find( + instanceName + ); + + const auto portPeripheralRegisterGroup = + portPeripheralRegisterGroupIt != portPeripheralModule.registerGroupsMappedByName.end() + ? std::optional(portPeripheralRegisterGroupIt->second) + : std::nullopt; + + for (const auto& signal : instance.instanceSignals) { + if (!signal.index.has_value()) { + continue; + } + + auto& padDescriptor = this->padDescriptorsByName.insert( + std::pair(signal.padName, PadDescriptor()) + ).first->second; + + padDescriptor.name = signal.padName; + padDescriptor.gpioPinNumber = signal.index.value(); + + if (!portModule.has_value()) { + continue; + } + + const auto instanceRegisterGroupIt = portModule->registerGroupsMappedByName.find(instanceName); + if (instanceRegisterGroupIt != portModule->registerGroupsMappedByName.end()) { + // We have register information for this port + const auto& registerGroup = instanceRegisterGroupIt->second; + + for (const auto& [registerName, portRegister] : registerGroup.registersMappedByName) { + if (registerName.find("port") == 0) { + // This is the data register for the port + padDescriptor.gpioPortAddress = portRegister.offset; continue; } - auto padDescriptor = PadDescriptor(); - padDescriptor.name = signal.padName; - padDescriptor.gpioPinNumber = signal.index.value(); - - if (portModule.has_value() && portModule->registerGroupsMappedByName.contains(instanceName)) { - // We have register information for this port - auto registerGroup = portModule->registerGroupsMappedByName.find(instanceName)->second; - - for (const auto& [registerName, portRegister] : registerGroup.registersMappedByName) { - if (registerName.find("port") == 0) { - // This is the data register for the port - padDescriptor.gpioPortAddress = portRegister.offset; - - } else if (registerName.find("pin") == 0) { - // This is the input data register for the port - padDescriptor.gpioPortInputAddress = portRegister.offset; - - } else if (registerName.find("ddr") == 0) { - // This is the data direction register for the port - padDescriptor.gpioDdrAddress = portRegister.offset; - } - } - - } else if (portModule.has_value() && portModule->registerGroupsMappedByName.contains("port")) { - // We have generic register information for all ports on the target - auto registerGroup = portModule->registerGroupsMappedByName.find("port")->second; - - for (const auto& [registerName, portRegister] : registerGroup.registersMappedByName) { - if (registerName == "out") { - // Include the port register offset - padDescriptor.gpioPortAddress = ( - portPeripheralRegisterGroup.has_value() - && portPeripheralRegisterGroup->offset.has_value() - ) - ? portPeripheralRegisterGroup->offset.value_or(0) + portRegister.offset - : 0 + portRegister.offset; - - - } else if (registerName == "dir") { - padDescriptor.gpioDdrAddress = ( - portPeripheralRegisterGroup.has_value() - && portPeripheralRegisterGroup->offset.has_value() - ) - ? portPeripheralRegisterGroup->offset.value_or(0) + portRegister.offset - : 0 + portRegister.offset; - - } else if (registerName == "in") { - padDescriptor.gpioPortInputAddress = ( - portPeripheralRegisterGroup.has_value() - && portPeripheralRegisterGroup->offset.has_value() - ) - ? portPeripheralRegisterGroup->offset.value_or(0) + portRegister.offset - : 0 + portRegister.offset; - } - } + if (registerName.find("pin") == 0) { + // This is the input data register for the port + padDescriptor.gpioPortInputAddress = portRegister.offset; + continue; } - this->padDescriptorsByName.insert(std::pair(padDescriptor.name, padDescriptor)); + if (registerName.find("ddr") == 0) { + // This is the data direction register for the port + padDescriptor.gpioDdrAddress = portRegister.offset; + continue; + } } + + continue; + } + + const auto portRegisterGroupIt = portModule->registerGroupsMappedByName.find("port"); + if (portRegisterGroupIt != portModule->registerGroupsMappedByName.end()) { + // We have generic register information for all ports on the target + const auto& registerGroup = portRegisterGroupIt->second; + + for (const auto& [registerName, portRegister] : registerGroup.registersMappedByName) { + if (registerName == "out") { + // Include the port register offset + padDescriptor.gpioPortAddress = ( + portPeripheralRegisterGroup.has_value() + && portPeripheralRegisterGroup->offset.has_value() + ) + ? portPeripheralRegisterGroup->offset.value_or(0) + portRegister.offset + : 0 + portRegister.offset; + continue; + } + + if (registerName == "dir") { + padDescriptor.gpioDdrAddress = ( + portPeripheralRegisterGroup.has_value() + && portPeripheralRegisterGroup->offset.has_value() + ) + ? portPeripheralRegisterGroup->offset.value_or(0) + portRegister.offset + : 0 + portRegister.offset; + continue; + } + + if (registerName == "in") { + padDescriptor.gpioPortInputAddress = ( + portPeripheralRegisterGroup.has_value() + && portPeripheralRegisterGroup->offset.has_value() + ) + ? portPeripheralRegisterGroup->offset.value_or(0) + portRegister.offset + : 0 + portRegister.offset; + continue; + } + } + + continue; } } } @@ -527,12 +559,13 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription targetVariant.package = TargetPackage::SSOP; } - if (!tdPinoutsByName.contains(tdVariant.pinoutName)) { + const auto tdPinoutIt = tdPinoutsByName.find(tdVariant.pinoutName); + if (tdPinoutIt == tdPinoutsByName.end()) { // Missing pinouts in the target description file continue; } - auto tdPinout = tdPinoutsByName.find(tdVariant.pinoutName)->second; + const auto& tdPinout = tdPinoutIt->second; for (const auto& tdPin : tdPinout.pins) { auto targetPin = TargetPinDescriptor(); targetPin.name = tdPin.pad; @@ -554,8 +587,9 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription targetPin.type = TargetPinType::GND; } - if (this->padDescriptorsByName.contains(targetPin.padName)) { - const auto& pad = this->padDescriptorsByName.at(targetPin.padName); + const auto padIt = this->padDescriptorsByName.find(targetPin.padName); + if (padIt != this->padDescriptorsByName.end()) { + const auto& pad = padIt->second; if (pad.gpioPortAddress.has_value() && pad.gpioDdrAddress.has_value()) { targetPin.type = TargetPinType::GPIO; } @@ -574,9 +608,13 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription for (const auto& [moduleName, module] : modulesByName) { for (const auto& [registerGroupName, registerGroup] : module.registerGroupsMappedByName) { - if (this->peripheralRegisterGroupsMappedByModuleRegisterGroupName.contains(registerGroupName)) { - const auto& peripheralRegisterGroups = this->peripheralRegisterGroupsMappedByModuleRegisterGroupName - .at(registerGroupName); + const auto peripheralRegisterGroupsIt = this->peripheralRegisterGroupsMappedByModuleRegisterGroupName.find( + registerGroupName + ); + + if (peripheralRegisterGroupsIt != this->peripheralRegisterGroupsMappedByModuleRegisterGroupName.end()) { + const auto& peripheralRegisterGroups = peripheralRegisterGroupsIt->second; + for (const auto& peripheralRegisterGroup : peripheralRegisterGroups) { if (peripheralRegisterGroup.addressSpaceId.value_or("") != "data") { // Currently, we only deal with registers in the data address space. @@ -627,17 +665,21 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription std::optional TargetDescriptionFile::getFuseBitsDescriptorByName( const std::string& fuseBitName ) const { - if (!this->modulesMappedByName.contains("fuse")) { + const auto fuseModuleIt = this->modulesMappedByName.find("fuse"); + + if (fuseModuleIt == this->modulesMappedByName.end()) { return std::nullopt; } - const auto& fuseModule = this->modulesMappedByName.at("fuse"); + const auto& fuseModule = fuseModuleIt->second; - if (!fuseModule.registerGroupsMappedByName.contains("fuse")) { + const auto fuseRegisterGroupIt = fuseModule.registerGroupsMappedByName.find("fuse"); + + if (fuseRegisterGroupIt == fuseModule.registerGroupsMappedByName.end()) { return std::nullopt; } - const auto& fuseRegisterGroup = fuseModule.registerGroupsMappedByName.at("fuse"); + const auto& fuseRegisterGroup = fuseRegisterGroupIt->second; static const auto fuseTypesByName = std::map({ {"low", FuseType::LOW}, @@ -646,15 +688,18 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription }); for (const auto&[fuseTypeName, fuse] : fuseRegisterGroup.registersMappedByName) { - if (!fuseTypesByName.contains(fuseTypeName)) { + const auto fuseTypeIt = fuseTypesByName.find(fuseTypeName); + if (fuseTypeIt == fuseTypesByName.end()) { // Unknown fuse type name continue; } - if (fuse.bitFieldsMappedByName.contains(fuseBitName)) { + const auto fuseBitFieldIt = fuse.bitFieldsMappedByName.find(fuseBitName); + + if (fuseBitFieldIt != fuse.bitFieldsMappedByName.end()) { return FuseBitsDescriptor( - fuseTypesByName.at(fuseTypeName), - fuse.bitFieldsMappedByName.at(fuseBitName).mask + fuseTypeIt->second, + fuseBitFieldIt->second.mask ); } } @@ -663,8 +708,10 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } std::optional TargetDescriptionFile::getProgramMemoryAddressSpace() const { - if (this->addressSpacesMappedById.contains("prog")) { - return this->addressSpacesMappedById.at("prog"); + const auto programAddressSpaceIt = this->addressSpacesMappedById.find("prog"); + + if (programAddressSpaceIt != this->addressSpacesMappedById.end()) { + return programAddressSpaceIt->second; } return std::nullopt; @@ -719,15 +766,15 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } std::optional TargetDescriptionFile::getIoMemorySegment() const { - const auto& addressMapping = this->addressSpacesMappedById; + const auto dataAddressMappingIt = this->addressSpacesMappedById.find("data"); - if (addressMapping.contains("data")) { - const auto& dataAddressSpace = addressMapping.at("data"); - const auto& dataMemorySegments = dataAddressSpace.memorySegmentsByTypeAndName; + if (dataAddressMappingIt != this->addressSpacesMappedById.end()) { + const auto& dataAddressSpace = dataAddressMappingIt->second; + const auto ioMemorySegmentsIt = dataAddressSpace.memorySegmentsByTypeAndName.find(MemorySegmentType::IO); - if (dataMemorySegments.contains(MemorySegmentType::IO)) { - const auto& ramMemorySegments = dataMemorySegments.at(MemorySegmentType::IO); - auto ramMemorySegmentIt = ramMemorySegments.begin(); + if (ioMemorySegmentsIt != dataAddressSpace.memorySegmentsByTypeAndName.end()) { + const auto& ramMemorySegments = ioMemorySegmentsIt->second; + const auto ramMemorySegmentIt = ramMemorySegments.begin(); if (ramMemorySegmentIt != ramMemorySegments.end()) { return ramMemorySegmentIt->second; @@ -762,23 +809,36 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } std::optional TargetDescriptionFile::getEepromMemorySegment() const { - const auto& addressMapping = this->addressSpacesMappedById; + const auto eepromAddressSpaceIt = this->addressSpacesMappedById.find("eeprom"); - if (addressMapping.contains("eeprom")) { - const auto& eepromAddressSpace = addressMapping.at("eeprom"); - const auto& eepromAddressSpaceSegments = eepromAddressSpace.memorySegmentsByTypeAndName; + if (eepromAddressSpaceIt != this->addressSpacesMappedById.end()) { + const auto& eepromAddressSpace = eepromAddressSpaceIt->second; + const auto eepromSegmentsIt = eepromAddressSpace.memorySegmentsByTypeAndName.find( + MemorySegmentType::EEPROM + ); - if (eepromAddressSpaceSegments.contains(MemorySegmentType::EEPROM)) { - return eepromAddressSpaceSegments.at(MemorySegmentType::EEPROM).begin()->second; + if ( + eepromSegmentsIt != eepromAddressSpace.memorySegmentsByTypeAndName.end() + && !eepromSegmentsIt->second.empty() + ) { + return eepromSegmentsIt->second.begin()->second; } } else { // The EEPROM memory segment may be part of the data address space - if (addressMapping.contains("data")) { - auto dataAddressSpace = addressMapping.at("data"); + const auto dataAddressSpaceIt = this->addressSpacesMappedById.find("data"); - if (dataAddressSpace.memorySegmentsByTypeAndName.contains(MemorySegmentType::EEPROM)) { - return dataAddressSpace.memorySegmentsByTypeAndName.at(MemorySegmentType::EEPROM).begin()->second; + if (dataAddressSpaceIt != this->addressSpacesMappedById.end()) { + const auto& dataAddressSpace = dataAddressSpaceIt->second; + const auto eepromSegmentsIt = dataAddressSpace.memorySegmentsByTypeAndName.find( + MemorySegmentType::EEPROM + ); + + if ( + eepromSegmentsIt != dataAddressSpace.memorySegmentsByTypeAndName.end() + && !eepromSegmentsIt->second.empty() + ) { + return eepromSegmentsIt->second.begin()->second; } } } @@ -787,21 +847,25 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } std::optional TargetDescriptionFile::getFirstBootSectionMemorySegment() const { - const auto& addressMapping = this->addressSpacesMappedById; - auto programAddressSpaceIt = addressMapping.find("prog"); + const auto programAddressSpaceIt = this->addressSpacesMappedById.find("prog"); - if (programAddressSpaceIt != addressMapping.end()) { + if (programAddressSpaceIt != this->addressSpacesMappedById.end()) { const auto& programAddressSpace = programAddressSpaceIt->second; const auto& programMemorySegments = programAddressSpace.memorySegmentsByTypeAndName; - if (programMemorySegments.find(MemorySegmentType::FLASH) != programMemorySegments.end()) { - const auto& flashMemorySegments = programMemorySegments.find(MemorySegmentType::FLASH)->second; + const auto flashMemorySegmentsit = programMemorySegments.find(MemorySegmentType::FLASH); - if (flashMemorySegments.contains("boot_section_1")) { - return flashMemorySegments.at("boot_section_1"); + if (flashMemorySegmentsit != programMemorySegments.end()) { + const auto& flashMemorySegments = flashMemorySegmentsit->second; - } else if (flashMemorySegments.contains("boot_section")) { - return flashMemorySegments.at("boot_section"); + auto bootSectionSegmentIt = flashMemorySegments.find("boot_section_1"); + if (bootSectionSegmentIt != flashMemorySegments.end()) { + return bootSectionSegmentIt->second; + } + + bootSectionSegmentIt = flashMemorySegments.find("boot_section"); + if (bootSectionSegmentIt != flashMemorySegments.end()) { + return bootSectionSegmentIt->second; } } } @@ -810,26 +874,35 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } std::optional TargetDescriptionFile::getSignatureMemorySegment() const { - if (this->addressSpacesMappedById.contains("signatures")) { - const auto& signaturesAddressSpace = this->addressSpacesMappedById.at("signatures"); + const auto signatureAddressSpaceIt = this->addressSpacesMappedById.find("signatures"); + if (signatureAddressSpaceIt != this->addressSpacesMappedById.end()) { + const auto& signaturesAddressSpace = signatureAddressSpaceIt->second; const auto& signaturesAddressSpaceSegments = signaturesAddressSpace.memorySegmentsByTypeAndName; + const auto signatureMemorySegmentsIt = signaturesAddressSpaceSegments.find(MemorySegmentType::SIGNATURES); - if (signaturesAddressSpaceSegments.contains(MemorySegmentType::SIGNATURES)) { - return signaturesAddressSpaceSegments.at(MemorySegmentType::SIGNATURES).begin()->second; + if ( + signatureMemorySegmentsIt != signaturesAddressSpaceSegments.end() + && !signatureMemorySegmentsIt->second.empty() + ) { + return signatureMemorySegmentsIt->second.begin()->second; } } else { // The signatures memory segment may be part of the data address space - if (this->addressSpacesMappedById.contains("data")) { - auto dataAddressSpace = this->addressSpacesMappedById.at("data"); + const auto dataAddressSpaceIt = this->addressSpacesMappedById.find("data"); - if (dataAddressSpace.memorySegmentsByTypeAndName.contains(MemorySegmentType::SIGNATURES)) { - const auto& signatureSegmentsByName = dataAddressSpace.memorySegmentsByTypeAndName.at( - MemorySegmentType::SIGNATURES - ); + if (dataAddressSpaceIt != this->addressSpacesMappedById.end()) { + const auto& dataAddressSpace = dataAddressSpaceIt->second; + const auto signatureSegmentsIt = dataAddressSpace.memorySegmentsByTypeAndName.find( + MemorySegmentType::SIGNATURES + ); - if (signatureSegmentsByName.contains("signatures")) { - return signatureSegmentsByName.at("signatures"); + if (signatureSegmentsIt != dataAddressSpace.memorySegmentsByTypeAndName.end()) { + const auto& signatureSegmentsByName = signatureSegmentsIt->second; + const auto signatureSegmentIt = signatureSegmentsByName.find("signatures"); + + if (signatureSegmentIt != signatureSegmentsByName.end()) { + return signatureSegmentIt->second; } } } @@ -839,13 +912,20 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } std::optional TargetDescriptionFile::getFuseMemorySegment() const { - if (this->addressSpacesMappedById.contains("data")) { - auto dataAddressSpace = this->addressSpacesMappedById.at("data"); + const auto dataAddressSpaceIt = this->addressSpacesMappedById.find("data"); - if (dataAddressSpace.memorySegmentsByTypeAndName.contains(MemorySegmentType::FUSES)) { - return dataAddressSpace.memorySegmentsByTypeAndName.at( - MemorySegmentType::FUSES - ).begin()->second; + if (dataAddressSpaceIt != this->addressSpacesMappedById.end()) { + const auto& dataAddressSpace = dataAddressSpaceIt->second; + + const auto fuseMemorySegmentsIt = dataAddressSpace.memorySegmentsByTypeAndName.find( + MemorySegmentType::FUSES + ); + + if ( + fuseMemorySegmentsIt != dataAddressSpace.memorySegmentsByTypeAndName.end() + && !fuseMemorySegmentsIt->second.empty() + ) { + return fuseMemorySegmentsIt->second.begin()->second; } } @@ -853,13 +933,20 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } std::optional TargetDescriptionFile::getLockbitsMemorySegment() const { - if (this->addressSpacesMappedById.contains("data")) { - auto dataAddressSpace = this->addressSpacesMappedById.at("data"); + const auto dataAddressSpaceIt = this->addressSpacesMappedById.find("data"); - if (dataAddressSpace.memorySegmentsByTypeAndName.contains(MemorySegmentType::LOCKBITS)) { - return dataAddressSpace.memorySegmentsByTypeAndName.at( - MemorySegmentType::LOCKBITS - ).begin()->second; + if (dataAddressSpaceIt != this->addressSpacesMappedById.end()) { + const auto& dataAddressSpace = dataAddressSpaceIt->second; + + const auto lockbitsMemorySegmentsIt = dataAddressSpace.memorySegmentsByTypeAndName.find( + MemorySegmentType::LOCKBITS + ); + + if ( + lockbitsMemorySegmentsIt != dataAddressSpace.memorySegmentsByTypeAndName.end() + && !lockbitsMemorySegmentsIt->second.empty() + ) { + return lockbitsMemorySegmentsIt->second.begin()->second; } } @@ -868,10 +955,11 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription std::optional TargetDescriptionFile::getCpuRegisterGroup() const { const auto& modulesByName = this->modulesMappedByName; + const auto cpuModuleIt = modulesByName.find("cpu"); - if (modulesByName.find("cpu") != modulesByName.end()) { - auto cpuModule = modulesByName.find("cpu")->second; - auto cpuRegisterGroupIt = cpuModule.registerGroupsMappedByName.find("cpu"); + if (cpuModuleIt != modulesByName.end()) { + const auto& cpuModule = cpuModuleIt->second; + const auto cpuRegisterGroupIt = cpuModule.registerGroupsMappedByName.find("cpu"); if (cpuRegisterGroupIt != cpuModule.registerGroupsMappedByName.end()) { return cpuRegisterGroupIt->second; @@ -882,10 +970,10 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } std::optional TargetDescriptionFile::getBootLoadRegisterGroup() const { - const auto& modulesByName = this->modulesMappedByName; + const auto bootLoadModuleIt = this->modulesMappedByName.find("boot_load"); - if (modulesByName.contains("boot_load")) { - const auto& bootLoadModule = modulesByName.at("boot_load"); + if (bootLoadModuleIt != this->modulesMappedByName.end()) { + const auto& bootLoadModule = bootLoadModuleIt->second; auto bootLoadRegisterGroupIt = bootLoadModule.registerGroupsMappedByName.find("boot_load"); if (bootLoadRegisterGroupIt != bootLoadModule.registerGroupsMappedByName.end()) { @@ -973,20 +1061,29 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription if (cpuRegisterGroup.has_value()) { const auto& cpuRegisters = cpuRegisterGroup->registersMappedByName; - if (cpuRegisters.contains("osccal")) { - return cpuRegisters.at("osccal"); + auto osccalRegisterIt = cpuRegisters.find("osccal"); + if (osccalRegisterIt != cpuRegisters.end()) { + return osccalRegisterIt->second; + } - } else if (cpuRegisters.contains("osccal0")) { - return cpuRegisters.at("osccal0"); + osccalRegisterIt = cpuRegisters.find("osccal0"); + if (osccalRegisterIt != cpuRegisters.end()) { + return osccalRegisterIt->second; + } - } else if (cpuRegisters.contains("osccal1")) { - return cpuRegisters.at("osccal1"); + osccalRegisterIt = cpuRegisters.find("osccal1"); + if (osccalRegisterIt != cpuRegisters.end()) { + return osccalRegisterIt->second; + } - } else if (cpuRegisters.contains("fosccal")) { - return cpuRegisters.at("fosccal"); + osccalRegisterIt = cpuRegisters.find("fosccal"); + if (osccalRegisterIt != cpuRegisters.end()) { + return osccalRegisterIt->second; + } - } else if (cpuRegisters.contains("sosccala")) { - return cpuRegisters.at("sosccala"); + osccalRegisterIt = cpuRegisters.find("sosccala"); + if (osccalRegisterIt != cpuRegisters.end()) { + return osccalRegisterIt->second; } } @@ -994,18 +1091,23 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } std::optional TargetDescriptionFile::getSpmcsRegister() const { - auto cpuRegisterGroup = this->getCpuRegisterGroup(); + const auto cpuRegisterGroup = this->getCpuRegisterGroup(); - if (cpuRegisterGroup.has_value() && cpuRegisterGroup->registersMappedByName.contains("spmcsr")) { - return cpuRegisterGroup->registersMappedByName.at("spmcsr"); + if (cpuRegisterGroup.has_value()) { + const auto spmcsRegisterIt = cpuRegisterGroup->registersMappedByName.find("spmcsr"); - } else { - auto bootLoadRegisterGroup = this->getBootLoadRegisterGroup(); + if (spmcsRegisterIt != cpuRegisterGroup->registersMappedByName.end()) { + return spmcsRegisterIt->second; + } + } - if (bootLoadRegisterGroup.has_value() - && bootLoadRegisterGroup->registersMappedByName.contains("spmcsr") - ) { - return bootLoadRegisterGroup->registersMappedByName.at("spmcsr"); + const auto bootLoadRegisterGroup = this->getBootLoadRegisterGroup(); + + if (bootLoadRegisterGroup.has_value()) { + const auto spmcsRegisterIt = bootLoadRegisterGroup->registersMappedByName.find("spmcsr"); + + if (spmcsRegisterIt != bootLoadRegisterGroup->registersMappedByName.end()) { + return spmcsRegisterIt->second; } } @@ -1013,16 +1115,23 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } std::optional TargetDescriptionFile::getSpmcRegister() const { - auto bootLoadRegisterGroup = this->getBootLoadRegisterGroup(); + const auto cpuRegisterGroup = this->getCpuRegisterGroup(); - if (bootLoadRegisterGroup.has_value() && bootLoadRegisterGroup->registersMappedByName.contains("spmcr")) { - return bootLoadRegisterGroup->registersMappedByName.at("spmcr"); + if (cpuRegisterGroup.has_value()) { + const auto spmcRegisterIt = cpuRegisterGroup->registersMappedByName.find("spmcr"); - } else { - auto cpuRegisterGroup = this->getCpuRegisterGroup(); + if (spmcRegisterIt != cpuRegisterGroup->registersMappedByName.end()) { + return spmcRegisterIt->second; + } + } - if (cpuRegisterGroup.has_value() && cpuRegisterGroup->registersMappedByName.contains("spmcr")) { - return cpuRegisterGroup->registersMappedByName.at("spmcr"); + const auto bootLoadRegisterGroup = this->getBootLoadRegisterGroup(); + + if (bootLoadRegisterGroup.has_value()) { + const auto spmcRegisterIt = bootLoadRegisterGroup->registersMappedByName.find("spmcr"); + + if (spmcRegisterIt != bootLoadRegisterGroup->registersMappedByName.end()) { + return spmcRegisterIt->second; } } @@ -1104,44 +1213,45 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription const auto& propertyGroups = this->getPropertyGroupsMappedByName(); // OCD attributes can be found in property groups - if (propertyGroups.contains("ocd")) { - const auto& ocdProperties = propertyGroups.at("ocd").propertiesMappedByName; + const auto ocdPropertyGroupIt = propertyGroups.find("ocd"); + if (ocdPropertyGroupIt != propertyGroups.end()) { + const auto& ocdProperties = ocdPropertyGroupIt->second.propertiesMappedByName; - if (ocdProperties.find("ocd_revision") != ocdProperties.end()) { - targetParameters.ocdRevision = ocdProperties.find("ocd_revision") - ->second.value.toUShort(nullptr, 10); + const auto ocdRevisionPropertyIt = ocdProperties.find("ocd_revision"); + if (ocdRevisionPropertyIt != ocdProperties.end()) { + targetParameters.ocdRevision = ocdRevisionPropertyIt->second.value.toUShort(nullptr, 10); } - if (ocdProperties.find("ocd_datareg") != ocdProperties.end()) { - targetParameters.ocdDataRegister = ocdProperties.find("ocd_datareg") - ->second.value.toUShort(nullptr, 16); + const auto ocdDataRegPropertyIt = ocdProperties.find("ocd_datareg"); + if (ocdDataRegPropertyIt != ocdProperties.end()) { + targetParameters.ocdDataRegister = ocdDataRegPropertyIt->second.value.toUShort(nullptr, 16); } } - auto spmcsRegister = this->getSpmcsRegister(); + const auto spmcsRegister = this->getSpmcsRegister(); if (spmcsRegister.has_value()) { targetParameters.spmcRegisterStartAddress = spmcsRegister->offset; } else { - auto spmcRegister = this->getSpmcRegister(); + const auto spmcRegister = this->getSpmcRegister(); if (spmcRegister.has_value()) { targetParameters.spmcRegisterStartAddress = spmcRegister->offset; } } - auto osccalRegister = this->getOscillatorCalibrationRegister(); + const auto osccalRegister = this->getOscillatorCalibrationRegister(); if (osccalRegister.has_value()) { targetParameters.osccalAddress = osccalRegister->offset; } - auto eepromAddressRegister = this->getEepromAddressRegister(); + const auto eepromAddressRegister = this->getEepromAddressRegister(); if (eepromAddressRegister.has_value()) { targetParameters.eepromAddressRegisterLow = eepromAddressRegister->offset; targetParameters.eepromAddressRegisterHigh = (eepromAddressRegister->size == 2) ? eepromAddressRegister->offset + 1 : eepromAddressRegister->offset; } else { - auto eepromAddressLowRegister = this->getEepromAddressLowRegister(); + const auto eepromAddressLowRegister = this->getEepromAddressLowRegister(); if (eepromAddressLowRegister.has_value()) { targetParameters.eepromAddressRegisterLow = eepromAddressLowRegister->offset; auto eepromAddressHighRegister = this->getEepromAddressHighRegister(); @@ -1155,12 +1265,12 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription } } - auto eepromDataRegister = this->getEepromDataRegister(); + const auto eepromDataRegister = this->getEepromDataRegister(); if (eepromDataRegister.has_value()) { targetParameters.eepromDataRegisterAddress = eepromDataRegister->offset; } - auto eepromControlRegister = this->getEepromControlRegister(); + const auto eepromControlRegister = this->getEepromControlRegister(); if (eepromControlRegister.has_value()) { targetParameters.eepromControlRegisterAddress = eepromControlRegister->offset; } @@ -1170,70 +1280,79 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription const auto& peripheralModules = this->getPeripheralModulesMappedByName(); const auto& propertyGroups = this->getPropertyGroupsMappedByName(); - if (propertyGroups.contains("pdi_interface")) { - const auto& pdiInterfaceProperties = propertyGroups.at("pdi_interface").propertiesMappedByName; + const auto pdiPropertyGroupIt = propertyGroups.find("pdi_interface"); + if (pdiPropertyGroupIt == propertyGroups.end()) { + return; + } - if (pdiInterfaceProperties.contains("app_section_offset")) { - targetParameters.appSectionPdiOffset = pdiInterfaceProperties - .at("app_section_offset").value.toUInt(nullptr, 16); - } + const auto& pdiInterfaceProperties = pdiPropertyGroupIt->second.propertiesMappedByName; - if (pdiInterfaceProperties.contains("boot_section_offset")) { - targetParameters.bootSectionPdiOffset = pdiInterfaceProperties - .at("boot_section_offset").value.toUInt(nullptr, 16); - } + const auto appOffsetPropertyIt = pdiInterfaceProperties.find("app_section_offset"); + if (appOffsetPropertyIt != pdiInterfaceProperties.end()) { + targetParameters.appSectionPdiOffset = appOffsetPropertyIt->second.value.toUInt(nullptr, 16); + } - if (pdiInterfaceProperties.contains("datamem_offset")) { - targetParameters.ramPdiOffset = pdiInterfaceProperties - .at("datamem_offset").value.toUInt(nullptr, 16); - } + const auto bootOffsetPropertyIt = pdiInterfaceProperties.find("boot_section_offset"); + if (bootOffsetPropertyIt != pdiInterfaceProperties.end()) { + targetParameters.bootSectionPdiOffset = bootOffsetPropertyIt->second.value.toUInt(nullptr, 16); + } - if (pdiInterfaceProperties.contains("eeprom_offset")) { - targetParameters.eepromPdiOffset = pdiInterfaceProperties - .at("eeprom_offset").value.toUInt(nullptr, 16); - } + const auto dataOffsetPropertyIt = pdiInterfaceProperties.find("datamem_offset"); + if (dataOffsetPropertyIt != pdiInterfaceProperties.end()) { + targetParameters.ramPdiOffset = dataOffsetPropertyIt->second.value.toUInt(nullptr, 16); + } - if (pdiInterfaceProperties.contains("user_signatures_offset")) { - targetParameters.userSignaturesPdiOffset = pdiInterfaceProperties - .at("user_signatures_offset").value.toUInt(nullptr, 16); - } + const auto eepromOffsetPropertyIt = pdiInterfaceProperties.find("eeprom_offset"); + if (eepromOffsetPropertyIt != pdiInterfaceProperties.end()) { + targetParameters.eepromPdiOffset = eepromOffsetPropertyIt->second.value.toUInt(nullptr, 16); + } - if (pdiInterfaceProperties.contains("prod_signatures_offset")) { - targetParameters.productSignaturesPdiOffset = pdiInterfaceProperties - .at("prod_signatures_offset").value.toUInt(nullptr, 16); - } + const auto userSigOffsetPropertyIt = pdiInterfaceProperties.find("user_signatures_offset"); + if (userSigOffsetPropertyIt != pdiInterfaceProperties.end()) { + targetParameters.userSignaturesPdiOffset = userSigOffsetPropertyIt->second.value.toUInt(nullptr, 16); + } - if (pdiInterfaceProperties.contains("fuse_registers_offset")) { - targetParameters.fuseRegistersPdiOffset = pdiInterfaceProperties - .at("fuse_registers_offset").value.toUInt(nullptr, 16); - } + const auto prodSigOffsetPropertyIt = pdiInterfaceProperties.find("prod_signatures_offset"); + if (prodSigOffsetPropertyIt != pdiInterfaceProperties.end()) { + targetParameters.productSignaturesPdiOffset = prodSigOffsetPropertyIt->second.value.toUInt(nullptr, 16); + } - if (pdiInterfaceProperties.contains("lock_registers_offset")) { - targetParameters.lockRegistersPdiOffset = pdiInterfaceProperties - .at("lock_registers_offset").value.toUInt(nullptr, 16); - } + const auto fuseRegOffsetPropertyIt = pdiInterfaceProperties.find("fuse_registers_offset"); + if (fuseRegOffsetPropertyIt != pdiInterfaceProperties.end()) { + targetParameters.fuseRegistersPdiOffset = fuseRegOffsetPropertyIt->second.value.toUInt(nullptr, 16); + } - if (peripheralModules.contains("nvm")) { - const auto& nvmModule = peripheralModules.at("nvm"); + const auto lockRegOffsetPropertyIt = pdiInterfaceProperties.find("lock_registers_offset"); + if (lockRegOffsetPropertyIt != pdiInterfaceProperties.end()) { + targetParameters.lockRegistersPdiOffset = lockRegOffsetPropertyIt->second.value.toUInt(nullptr, 16); + } - if (nvmModule.instancesMappedByName.contains("nvm")) { - const auto& nvmInstance = nvmModule.instancesMappedByName.at("nvm"); + const auto nvmPeripheralModuleIt = peripheralModules.find("nvm"); + if (nvmPeripheralModuleIt != peripheralModules.end()) { + const auto& nvmModule = nvmPeripheralModuleIt->second; - if (nvmInstance.registerGroupsMappedByName.contains("nvm")) { - targetParameters.nvmModuleBaseAddress = nvmInstance.registerGroupsMappedByName.at("nvm").offset; - } + const auto nvmInstanceIt = nvmModule.instancesMappedByName.find("nvm"); + if (nvmInstanceIt != nvmModule.instancesMappedByName.end()) { + const auto& nvmInstance = nvmInstanceIt->second; + + const auto nvmRegisterGroupIt = nvmInstance.registerGroupsMappedByName.find("nvm"); + if (nvmRegisterGroupIt != nvmInstance.registerGroupsMappedByName.end()) { + targetParameters.nvmModuleBaseAddress = nvmRegisterGroupIt->second.offset; } } + } - if (peripheralModules.contains("mcu")) { - const auto& mcuModule = peripheralModules.at("mcu"); + const auto mcuPeripheralModuleIt = peripheralModules.find("mcu"); + if (mcuPeripheralModuleIt != peripheralModules.end()) { + const auto& mcuModule = mcuPeripheralModuleIt->second; - if (mcuModule.instancesMappedByName.contains("mcu")) { - const auto& mcuInstance = mcuModule.instancesMappedByName.at("mcu"); + const auto mcuInstanceIt = mcuModule.instancesMappedByName.find("mcu"); + if (mcuInstanceIt != mcuModule.instancesMappedByName.end()) { + const auto& mcuInstance = mcuInstanceIt->second; - if (mcuInstance.registerGroupsMappedByName.contains("mcu")) { - targetParameters.mcuModuleBaseAddress = mcuInstance.registerGroupsMappedByName.at("mcu").offset; - } + const auto mcuRegisterGroupIt = mcuInstance.registerGroupsMappedByName.find("mcu"); + if (mcuRegisterGroupIt != mcuInstance.registerGroupsMappedByName.end()) { + targetParameters.mcuModuleBaseAddress = mcuRegisterGroupIt->second.offset; } } } @@ -1242,49 +1361,54 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription void TargetDescriptionFile::loadUpdiTargetParameters(TargetParameters& targetParameters) const { const auto& propertyGroups = this->getPropertyGroupsMappedByName(); const auto& peripheralModules = this->getPeripheralModulesMappedByName(); - auto modulesByName = this->getModulesMappedByName(); + const auto& modulesByName = this->getModulesMappedByName(); - if (peripheralModules.contains("nvmctrl")) { - const auto& nvmCtrlModule = peripheralModules.at("nvmctrl"); + const auto nvmCtrlPeripheralModuleIt = peripheralModules.find("nvmctrl"); + if (nvmCtrlPeripheralModuleIt != peripheralModules.end()) { + const auto& nvmCtrlModule = nvmCtrlPeripheralModuleIt->second; - if (nvmCtrlModule.instancesMappedByName.contains("nvmctrl")) { - const auto& nvmCtrlInstance = nvmCtrlModule.instancesMappedByName.at("nvmctrl"); + const auto nvmCtrlInstanceIt = nvmCtrlModule.instancesMappedByName.find("nvmctrl"); + if (nvmCtrlInstanceIt != nvmCtrlModule.instancesMappedByName.end()) { + const auto& nvmCtrlInstance = nvmCtrlInstanceIt->second; - if (nvmCtrlInstance.registerGroupsMappedByName.contains("nvmctrl")) { - targetParameters.nvmModuleBaseAddress = nvmCtrlInstance.registerGroupsMappedByName.at( - "nvmctrl" - ).offset; + const auto nvmCtrlRegisterGroupIt = nvmCtrlInstance.registerGroupsMappedByName.find("nvmctrl"); + if (nvmCtrlRegisterGroupIt != nvmCtrlInstance.registerGroupsMappedByName.end()) { + targetParameters.nvmModuleBaseAddress = nvmCtrlRegisterGroupIt->second.offset; } } } - if (propertyGroups.contains("updi_interface")) { - const auto& updiInterfaceProperties = propertyGroups.at("updi_interface").propertiesMappedByName; + const auto updiPropertyGroupIt = propertyGroups.find("updi_interface"); + if (updiPropertyGroupIt != propertyGroups.end()) { + const auto& updiInterfaceProperties = updiPropertyGroupIt->second.propertiesMappedByName; - if (updiInterfaceProperties.contains("ocd_base_addr")) { - targetParameters.ocdModuleAddress = updiInterfaceProperties - .at("ocd_base_addr").value.toUShort(nullptr, 16); + const auto ocdBaseAddressPropertyIt = updiInterfaceProperties.find("ocd_base_addr"); + if (ocdBaseAddressPropertyIt != updiInterfaceProperties.end()) { + targetParameters.ocdModuleAddress = ocdBaseAddressPropertyIt->second.value.toUShort(nullptr, 16); } - if (updiInterfaceProperties.contains("progmem_offset")) { - targetParameters.programMemoryUpdiStartAddress = updiInterfaceProperties - .at("progmem_offset").value.toUInt(nullptr, 16); + const auto progMemOffsetPropertyIt = updiInterfaceProperties.find("progmem_offset"); + if (progMemOffsetPropertyIt != updiInterfaceProperties.end()) { + targetParameters.programMemoryUpdiStartAddress = progMemOffsetPropertyIt->second.value.toUInt( + nullptr, + 16 + ); } } - auto signatureMemorySegment = this->getSignatureMemorySegment(); + const auto signatureMemorySegment = this->getSignatureMemorySegment(); if (signatureMemorySegment.has_value()) { targetParameters.signatureSegmentStartAddress = signatureMemorySegment->startAddress; targetParameters.signatureSegmentSize = signatureMemorySegment->size; } - auto fuseMemorySegment = this->getFuseMemorySegment(); + const auto fuseMemorySegment = this->getFuseMemorySegment(); if (fuseMemorySegment.has_value()) { targetParameters.fuseSegmentStartAddress = fuseMemorySegment->startAddress; targetParameters.fuseSegmentSize = fuseMemorySegment->size; } - auto lockbitsMemorySegment = this->getLockbitsMemorySegment(); + const auto lockbitsMemorySegment = this->getLockbitsMemorySegment(); if (lockbitsMemorySegment.has_value()) { targetParameters.lockbitsSegmentStartAddress = lockbitsMemorySegment->startAddress; } diff --git a/src/Targets/Microchip/AVR/Target.hpp b/src/Targets/Microchip/AVR/Target.hpp index e10328f7..c11e6513 100644 --- a/src/Targets/Microchip/AVR/Target.hpp +++ b/src/Targets/Microchip/AVR/Target.hpp @@ -12,7 +12,9 @@ namespace Bloom::Targets::Microchip::Avr class Target: public ::Bloom::Targets::Target { public: - explicit Target() = default; + explicit Target(std::optional id = std::nullopt) + : id(id) + {}; std::string getHumanReadableId() override { return this->getId().toHex(); @@ -21,10 +23,6 @@ namespace Bloom::Targets::Microchip::Avr protected: std::optional id; - virtual void setId(const TargetSignature& id) { - this->id = id; - } - virtual TargetSignature getId() = 0; }; }