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

Retrieving AVR8 target registers and including them in the TargetDescriptor

Browse Source
This commit is contained in:
Nav
2021-08-07 17:15:48 +01:00
parent fd719f1cda
commit d709c8aac9
8 changed files with 205 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
src/Targets/Microchip/AVR/AVR8/Avr8.cpp
View File

@@ -39,6 +39,78 @@ void Avr8::initFromTargetDescriptionFile() {
this->targetParameters = this->targetDescriptionFile->getTargetParameters();
this->padDescriptorsByName = this->targetDescriptionFile->getPadDescriptorsMappedByName();
this->targetVariantsById = this->targetDescriptionFile->getVariantsMappedById();
if (!this->targetParameters->stackPointerRegisterLowAddress.has_value()) {
throw Exception("Failed to load sufficient AVR8 target paramters - missting stack pointer start address");
}
if (!this->targetParameters->statusRegisterStartAddress.has_value()) {
throw Exception("Failed to load sufficient AVR8 target parameters - missting status register start address");
}
this->loadTargetRegisterDescriptors();
}
void Avr8::loadTargetRegisterDescriptors() {
this->targetRegisterDescriptorsByType = this->targetDescriptionFile->getRegisterDescriptorsMappedByType();
/*
* All AVR8 targets possess 32 general purpose CPU registers. These are not described in the TDF, so we
* construct the descriptors for them here.
*/
for (std::uint8_t i = 0; i <= 31; i++) {
auto generalPurposeRegisterDescriptor = TargetRegisterDescriptor();
generalPurposeRegisterDescriptor.id = i;
generalPurposeRegisterDescriptor.startAddress =
this->targetParameters->gpRegisterStartAddress.value_or(0) + i;
generalPurposeRegisterDescriptor.size = 1;
generalPurposeRegisterDescriptor.type = TargetRegisterType::GENERAL_PURPOSE_REGISTER;
generalPurposeRegisterDescriptor.name = "R" + std::to_string(i);
generalPurposeRegisterDescriptor.groupName = "General Purpose CPU Registers";
this->targetRegisterDescriptorsByType[generalPurposeRegisterDescriptor.type].emplace_back(
generalPurposeRegisterDescriptor
);
}
/*
* The SP and SREG registers are described in the TDF, so we could just use the descriptors extracted from the
* TDF. The problem with that is, sometimes the SP register consists of two bytes; an SPL and an SPH. These need
* to be combined into one register descriptor. This is why we just use what we already have in
* this->targetParameters.
*/
auto stackPointerRegisterDescriptor = TargetRegisterDescriptor();
stackPointerRegisterDescriptor.type = TargetRegisterType::STACK_POINTER;
stackPointerRegisterDescriptor.startAddress = this->targetParameters->stackPointerRegisterLowAddress.value();
stackPointerRegisterDescriptor.size = this->targetParameters->stackPointerRegisterSize.value();
stackPointerRegisterDescriptor.name = "SP";
stackPointerRegisterDescriptor.groupName = "CPU";
stackPointerRegisterDescriptor.description = "Stack Pointer Register";
auto statusRegisterDescriptor = TargetRegisterDescriptor();
statusRegisterDescriptor.type = TargetRegisterType::STATUS_REGISTER;
statusRegisterDescriptor.startAddress = this->targetParameters->statusRegisterStartAddress.value();
statusRegisterDescriptor.size = this->targetParameters->statusRegisterSize.value();
statusRegisterDescriptor.name = "SREG";
statusRegisterDescriptor.groupName = "CPU";
statusRegisterDescriptor.description = "Status Register";
auto programCounterRegisterDescriptor = TargetRegisterDescriptor();
programCounterRegisterDescriptor.type = TargetRegisterType::PROGRAM_COUNTER;
programCounterRegisterDescriptor.size = 4;
programCounterRegisterDescriptor.name = "PC";
programCounterRegisterDescriptor.groupName = "CPU";
programCounterRegisterDescriptor.description = "Program Counter";
this->targetRegisterDescriptorsByType[stackPointerRegisterDescriptor.type].emplace_back(
stackPointerRegisterDescriptor
);
this->targetRegisterDescriptorsByType[statusRegisterDescriptor.type].emplace_back(
statusRegisterDescriptor
);
this->targetRegisterDescriptorsByType[programCounterRegisterDescriptor.type].emplace_back(
programCounterRegisterDescriptor
);
}
TargetSignature Avr8::getId() {
@@ -153,6 +225,7 @@ TargetDescriptor Avr8Bit::Avr8::getDescriptor() {
descriptor.id = this->getHumanReadableId();
descriptor.name = this->getName();
descriptor.ramSize = this->targetParameters.value().ramSize.value_or(0);
descriptor.registerDescriptorsByType = this->targetRegisterDescriptorsByType;
std::transform(
this->targetVariantsById.begin(),

7
src/Targets/Microchip/AVR/AVR8/Avr8.hpp
View File

@@ -29,6 +29,7 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit
std::optional<TargetParameters> targetParameters;
std::map<std::string, PadDescriptor> padDescriptorsByName;
std::map<int, TargetVariant> targetVariantsById;
std::map<TargetRegisterType, std::vector<TargetRegisterDescriptor>> targetRegisterDescriptorsByType;
/**
* Resolves the appropriate TDF for the AVR8 target and populates this->targetDescriptionFile.
@@ -40,6 +41,12 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit
*/
void initFromTargetDescriptionFile();
/**
* Populates this->targetRegisterDescriptorsByType with registers extracted from the TDF, as well as general
* purpose and other CPU registers.
*/
void loadTargetRegisterDescriptors();
/**
* Extracts the ID from the target's memory.
*

63
src/Targets/Microchip/AVR/AVR8/TargetDescription/TargetDescriptionFile.cpp
View File

@@ -17,6 +17,7 @@ using Bloom::Targets::TargetDescription::MemorySegment;
using Bloom::Targets::TargetDescription::MemorySegmentType;
using Bloom::Targets::TargetDescription::Register;
using Bloom::Targets::TargetVariant;
using Bloom::Targets::TargetRegisterDescriptor;
TargetDescriptionFile::TargetDescriptionFile(
const TargetSignature& targetSignature,
@@ -93,6 +94,7 @@ void TargetDescriptionFile::init(const QDomDocument& xml) {
this->loadDebugPhysicalInterfaces();
this->loadPadDescriptors();
this->loadTargetVariants();
this->loadTargetRegisterDescriptors();
}
QJsonObject TargetDescriptionFile::getTargetDescriptionMapping() {
@@ -460,6 +462,34 @@ void TargetDescriptionFile::loadTargetVariants() {
}
}
void TargetDescriptionFile::loadTargetRegisterDescriptors() {
auto& modulesByName = this->modulesMappedByName;
auto& peripheralModulesByName = this->peripheralModulesMappedByName;
for (const auto& [moduleName, module] : modulesByName) {
auto moduleRegisterAddressOffset = this->getRegisterAddressOffsetByModuleName(moduleName);
for (const auto& [registerGroupName, registerGroup] : module.registerGroupsMappedByName) {
for (const auto& [moduleRegisterName, moduleRegister] : registerGroup.registersMappedByName) {
if (moduleRegister.size < 1) {
continue;
}
auto registerDescriptor = TargetRegisterDescriptor();
registerDescriptor.type = TargetRegisterType::OTHER;
registerDescriptor.name = moduleRegisterName;
registerDescriptor.groupName = registerGroupName;
registerDescriptor.size = moduleRegister.size;
registerDescriptor.startAddress = moduleRegister.offset + moduleRegisterAddressOffset;
if (moduleRegister.caption.has_value() && !moduleRegister.caption->empty()) {
registerDescriptor.description = moduleRegister.caption;
}
this->targetRegisterDescriptorsByType[registerDescriptor.type].emplace_back(registerDescriptor);
}
}
}
}
std::optional<MemorySegment> TargetDescriptionFile::getFlashMemorySegment() const {
auto& addressMapping = this->addressSpacesMappedById;
@@ -1068,3 +1098,36 @@ void TargetDescriptionFile::loadUpdiTargetParameters(TargetParameters& targetPar
targetParameters.lockbitsSegmentStartAddress = lockbitsMemorySegment->startAddress;
}
}
std::uint32_t TargetDescriptionFile::getRegisterAddressOffsetByModuleName(const std::string& moduleName) const {
if (this->peripheralModulesMappedByName.contains(moduleName)) {
auto& peripheralModule = this->peripheralModulesMappedByName.at(moduleName);
if (peripheralModule.instancesMappedByName.contains(moduleName)) {
auto& moduleInstance = peripheralModule.instancesMappedByName.at(moduleName);
if (moduleInstance.registerGroupsMappedByName.contains(moduleName)) {
auto& registerGroup = moduleInstance.registerGroupsMappedByName.at(moduleName);
if (!registerGroup.moduleName.has_value() || registerGroup.moduleName.value() == moduleName) {
return registerGroup.offset.value_or(0);
}
}
/*
* If we get here, that means we couldn't find the right register group by module name. This will happen
* if the register group name doesn't match the module name attribute ("name-in-module") against the
* register group node, in the TDF.
*
* As a final attempt, we'll brute force search all register groups in the module instance.
*/
for (const auto& [registerGroupName, registerGroup] : moduleInstance.registerGroupsMappedByName) {
if (registerGroup.moduleName.has_value() && registerGroup.moduleName.value() == moduleName) {
return registerGroup.offset.value_or(0);
}
}
}
}
return 0;
}

26
src/Targets/Microchip/AVR/AVR8/TargetDescription/TargetDescriptionFile.hpp
View File

@@ -55,6 +55,8 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription
std::map<std::string, PadDescriptor> padDescriptorsByName;
std::map<int, TargetVariant> targetVariantsById;
std::map<TargetRegisterType, TargetRegisterDescriptors> targetRegisterDescriptorsByType;
/**
* Populates this->supportedDebugPhysicalInterfaces with physical interfaces defined in the TDF.
*/
@@ -70,6 +72,11 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription
*/
void loadTargetVariants();
/**
* Loads all register descriptors from the TDF, and populates this->targetRegisterDescriptorsByType.
*/
void loadTargetRegisterDescriptors();
[[nodiscard]] std::optional<Targets::TargetDescription::MemorySegment> getFlashMemorySegment() const;
[[nodiscard]] std::optional<Targets::TargetDescription::MemorySegment> getRamMemorySegment() const;
[[nodiscard]] std::optional<Targets::TargetDescription::MemorySegment> getIoMemorySegment() const;
@@ -117,6 +124,14 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription
*/
virtual void loadUpdiTargetParameters(TargetParameters& targetParameters) const;
/**
* Extracts the register address offset, for registers from a particular module.
*
* @param moduleName
* @return
*/
[[nodiscard]] virtual std::uint32_t getRegisterAddressOffsetByModuleName(const std::string& moduleName) const;
public:
/**
* Will resolve the target description file using the target description JSON mapping and a given target signature.
@@ -177,6 +192,15 @@ namespace Bloom::Targets::Microchip::Avr::Avr8Bit::TargetDescription
[[nodiscard]] const auto& getVariantsMappedById() const {
return this->targetVariantsById;
};
}
/**
* Returns a mapping of all target register descriptors extracted from the TDF, by type.
*
* @return
*/
[[nodiscard]] const auto& getRegisterDescriptorsMappedByType() const {
return this->targetRegisterDescriptorsByType;
}
};
}