| /* |
| Copyright 2019 Alain Dargelas |
| |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| */ |
| |
| /* |
| * File: DesignElaboration.cpp |
| * Author: alain |
| * |
| * Created on July 12, 2017, 8:55 PM |
| */ |
| #include "Utils/StringUtils.h" |
| #include "SourceCompile/VObjectTypes.h" |
| #include "Design/VObject.h" |
| #include "Library/Library.h" |
| #include "Design/FileContent.h" |
| #include "SourceCompile/SymbolTable.h" |
| #include "ErrorReporting/Error.h" |
| #include "ErrorReporting/Location.h" |
| #include "ErrorReporting/Error.h" |
| #include "ErrorReporting/ErrorDefinition.h" |
| #include "ErrorReporting/ErrorContainer.h" |
| #include "Config/ConfigSet.h" |
| #include "CommandLine/CommandLineParser.h" |
| #include "SourceCompile/CompilationUnit.h" |
| #include "SourceCompile/PreprocessFile.h" |
| #include "SourceCompile/CompileSourceFile.h" |
| #include "SourceCompile/ParseFile.h" |
| #include "SourceCompile/Compiler.h" |
| #include "DesignCompile/CompileDesign.h" |
| #include "Testbench/Property.h" |
| #include "Design/Function.h" |
| #include "Testbench/ClassDefinition.h" |
| #include "DesignCompile/DesignElaboration.h" |
| #include <queue> |
| |
| using namespace SURELOG; |
| |
| DesignElaboration::DesignElaboration(CompileDesign* compileDesign) |
| : ElaborationStep(compileDesign) { |
| m_moduleDefFactory = NULL; |
| m_moduleInstFactory = NULL; |
| m_exprBuilder.seterrorReporting( |
| m_compileDesign->getCompiler()->getErrorContainer(), |
| m_compileDesign->getCompiler()->getSymbolTable()); |
| } |
| |
| DesignElaboration::~DesignElaboration() {} |
| |
| bool DesignElaboration::elaborate() { |
| createBuiltinPrimitives_(); |
| setupConfigurations_(); |
| identifyTopModules_(); |
| elaborateAllModules_(true); |
| elaborateAllModules_(false); |
| reduceUnnamedBlocks_(); |
| checkElaboration_(); |
| reportElaboration_(); |
| return true; |
| } |
| |
| bool DesignElaboration::setupConfigurations_() { |
| ConfigSet* configSet = |
| m_compileDesign->getCompiler()->getDesign()->getConfigSet(); |
| SymbolTable* st = |
| m_compileDesign->getCompiler()->getCommandLineParser()->getSymbolTable(); |
| std::vector<Config>& allConfigs = configSet->getAllConfigs(); |
| std::vector<SymbolId> selectedConfigIds = |
| m_compileDesign->getCompiler()->getCommandLineParser()->getUseConfigs(); |
| std::set<std::string> selectedConfigs; |
| for (auto confId : selectedConfigIds) { |
| std::string name = st->getSymbol(confId); |
| if (name.find(".") == std::string::npos) { |
| name = "work@" + name; |
| } else { |
| name = StringUtils::replaceAll(name, ".", "@"); |
| } |
| selectedConfigs.insert(name); |
| bool found = false; |
| for (auto& config : allConfigs) { |
| if (config.getName() == name) { |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| Location loc(st->registerSymbol(name)); |
| Error err(ErrorDefinition::CMD_UNDEFINED_CONFIG, loc); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err); |
| } |
| } |
| |
| std::queue<std::string> configq; |
| for (auto& config : allConfigs) { |
| if (selectedConfigs.find(config.getName()) != selectedConfigs.end()) { |
| config.setIsUsed(); |
| config.setTopLevel(true); |
| configq.push(config.getName()); |
| } |
| } |
| std::set<Config*> configS; |
| while (configq.size()) { |
| std::string configName = configq.front(); |
| configq.pop(); |
| Config* conf = configSet->getConfig(configName); |
| if (conf) { |
| if (configS.find(conf) != configS.end()) { |
| continue; |
| } |
| configS.insert(conf); |
| |
| conf->setIsUsed(); |
| for (auto& usec : conf->getInstanceUseClauses()) { |
| if (usec.second.getType() == UseClause::UseConfig) { |
| std::string confName = usec.second.getName(); |
| configq.push(confName); |
| Config* conf = configSet->getConfig(confName); |
| if (!conf) { |
| FileContent* fC = usec.second.getFileContent(); |
| Location loc( |
| st->registerSymbol(fC->getFileName(usec.second.getNodeId())), |
| fC->Line(usec.second.getNodeId()), 0, |
| st->registerSymbol(confName)); |
| Error err(ErrorDefinition::ELAB_UNDEFINED_CONFIG, loc); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err); |
| } |
| } |
| } |
| } |
| } |
| |
| std::vector<std::string> unused; |
| for (auto& config : allConfigs) { |
| std::string name = config.getName(); |
| FileContent* fC = config.getFileContent(); |
| SymbolId fid = st->registerSymbol(fC->getFileName(config.getNodeId())); |
| unsigned int line = fC->Line(config.getNodeId()); |
| Location loc(fid, line, 0, st->getId(config.getName())); |
| if (!config.isUsed()) { |
| Error err(ErrorDefinition::ELAB_CONFIGURATION_IGNORED, loc); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err); |
| unused.push_back(name); |
| } else { |
| Error err(ErrorDefinition::ELAB_CONFIGURATION_USED, loc); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err); |
| } |
| } |
| |
| // Remove unused configs from set |
| for (auto name : unused) { |
| std::vector<Config>::iterator itr; |
| for (itr = allConfigs.begin(); itr != allConfigs.end(); itr++) { |
| if ((*itr).getName() == name) { |
| allConfigs.erase(itr); |
| break; |
| } |
| } |
| } |
| |
| // Create top level module list and recurse configs |
| for (auto& config : allConfigs) { |
| if (config.isTopLevel()) { |
| std::string lib = config.getDesignLib(); |
| std::string top = config.getDesignTop(); |
| std::string name = lib + "@" + top; |
| m_toplevelConfigModules.insert(name); |
| m_instConfig.insert(std::make_pair(name, config)); |
| m_cellConfig.insert(std::make_pair(name, config)); |
| |
| for (auto& instClause : config.getInstanceUseClauses()) { |
| m_instUseClause.insert( |
| std::make_pair(lib + "@" + instClause.first, instClause.second)); |
| if (instClause.second.getType() == UseClause::UseConfig) { |
| Config* config = configSet->getConfig(instClause.second.getName()); |
| if (config) { |
| std::set<Config*> configStack; |
| recurseBuildInstanceClause_(lib + "@" + instClause.first, config, |
| configStack); |
| } |
| } |
| } |
| for (auto& cellClause : config.getCellUseClauses()) { |
| m_cellUseClause.insert( |
| std::make_pair(cellClause.first, cellClause.second)); |
| } |
| } |
| } |
| return true; |
| } |
| |
| void DesignElaboration::recurseBuildInstanceClause_( |
| std::string parentPath, Config* config, std::set<Config*>& configStack) { |
| if (configStack.find(config) != configStack.end()) { |
| return; |
| } |
| configStack.insert(config); |
| |
| ConfigSet* configSet = |
| m_compileDesign->getCompiler()->getDesign()->getConfigSet(); |
| for (auto& useClause : config->getInstanceUseClauses()) { |
| std::string inst = useClause.first; |
| std::string fullPath = parentPath + "." + inst; |
| m_instUseClause.insert(std::make_pair(fullPath, useClause.second)); |
| if (useClause.second.getType() == UseClause::UseConfig) { |
| Config* config = configSet->getConfig(useClause.second.getName()); |
| if (config) { |
| recurseBuildInstanceClause_(parentPath + "." + useClause.first, config, |
| configStack); |
| } |
| } |
| } |
| for (auto& useClause : config->getCellUseClauses()) { |
| std::string inst = useClause.first; |
| std::string fullPath = inst; |
| m_cellUseClause.insert(std::make_pair(fullPath, useClause.second)); |
| } |
| } |
| |
| bool DesignElaboration::identifyTopModules_() { |
| m_topLevelModules.clear(); |
| bool modulePresent = false; |
| bool toplevelModuleFound = false; |
| SymbolTable* st = m_compileDesign->getCompiler()->getSymbolTable(); |
| auto all_files = |
| m_compileDesign->getCompiler()->getDesign()->getAllFileContents(); |
| typedef std::multimap<std::string, std::pair<DesignElement*, FileContent*>> |
| ModuleMultiMap; |
| ModuleMultiMap all_modules; |
| for (auto file : all_files) { |
| if (m_compileDesign->getCompiler()->isLibraryFile(file.first)) continue; |
| for (DesignElement& element : file.second->getDesignElements()) { |
| std::string elemName = st->getSymbol(element.m_name); |
| if (element.m_type == DesignElement::Module) { |
| if (element.m_parent) { |
| // This is a nested element |
| continue; |
| } |
| std::string topname = file.second->getLibrary()->getName(); |
| topname += "@" + elemName; |
| |
| if (!file.second->getParent()) { |
| // Files that have parent are splited files (When a module is too |
| // large it is splited) |
| all_modules.insert( |
| std::make_pair(topname, std::make_pair(&element, file.second))); |
| } |
| |
| modulePresent = true; |
| bool used = false; |
| for (auto file1 : all_files) { |
| if (file1.second->getReferencedObjects().find(elemName) != |
| file1.second->getReferencedObjects().end()) { |
| used = true; |
| break; |
| } |
| } |
| |
| if (!used) { |
| bool isTop = true; |
| |
| if (m_toplevelConfigModules.size()) { |
| isTop = false; |
| if (m_toplevelConfigModules.find(topname) != |
| m_toplevelConfigModules.end()) { |
| isTop = true; |
| } |
| } |
| |
| if (isTop) { |
| SymbolId topid = st->registerSymbol(topname); |
| auto itr = m_uniqueTopLevelModules.find(topname); |
| Location loc( |
| st->registerSymbol(file.second->getFileName(element.m_node)), |
| element.m_line, 0, topid); |
| if (itr == m_uniqueTopLevelModules.end()) { |
| m_uniqueTopLevelModules.insert(topname); |
| m_topLevelModules.push_back(std::make_pair(topname, file.second)); |
| toplevelModuleFound = true; |
| Error err(ErrorDefinition::ELAB_TOP_LEVEL_MODULE, loc); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError( |
| err); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| // Check for multiple definition |
| std::string prevModuleName = ""; |
| DesignElement* prevModuleDefinition = NULL; |
| FileContent* prevFileContent = NULL; |
| for (ModuleMultiMap::iterator itr = all_modules.begin(); |
| itr != all_modules.end(); itr++) { |
| std::string moduleName = (*itr).first; |
| DesignElement* moduleDefinition = (*itr).second.first; |
| FileContent* fileContent = (*itr).second.second; |
| bool done = false; |
| if (moduleName == prevModuleName) { |
| FileContent* fC1 = (*itr).second.second; |
| NodeId nodeId1 = moduleDefinition->m_node; |
| std::string fileName1 = fC1->getFileName(nodeId1); |
| unsigned int line1 = fC1->Line(nodeId1); |
| Location loc1(st->registerSymbol(fileName1), line1, 0, |
| st->registerSymbol(moduleName)); |
| |
| std::vector<Location> locations; |
| |
| while (1) { |
| FileContent* fC2 = prevFileContent; |
| NodeId nodeId2 = prevModuleDefinition->m_node; |
| std::string fileName2 = fC2->getFileName(nodeId2); |
| unsigned int line2 = fC2->Line(nodeId2); |
| Location loc2(st->registerSymbol(fileName2), line2, 0, |
| st->registerSymbol(moduleName)); |
| |
| if ((fileName1 != fileName2) || (line1 != line2)) { |
| locations.push_back(loc2); |
| } |
| |
| itr++; |
| if (itr == all_modules.end()) { |
| done = true; |
| break; |
| } else { |
| std::string nextModuleName = (*itr).first; |
| DesignElement* nextModuleDefinition = (*itr).second.first; |
| FileContent* nextFileContent = (*itr).second.second; |
| prevModuleName = nextModuleName; |
| prevModuleDefinition = nextModuleDefinition; |
| prevFileContent = nextFileContent; |
| if (prevModuleName != moduleName) { |
| moduleName = prevModuleName; |
| moduleDefinition = prevModuleDefinition; |
| fileContent = prevFileContent; |
| break; |
| } |
| } |
| } |
| |
| if (locations.size()) { |
| Error err1(ErrorDefinition::ELAB_MULTIPLY_DEFINED_MODULE, loc1, |
| &locations); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err1); |
| } |
| } |
| prevModuleName = moduleName; |
| prevModuleDefinition = moduleDefinition; |
| prevFileContent = fileContent; |
| if (done) break; |
| } |
| |
| if (m_topLevelModules.size() > 1) { |
| Location loc(0); |
| Error err(ErrorDefinition::ELAB_MULTIPLE_TOP_LEVEL_MODULES, loc); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err); |
| } |
| if (modulePresent && (!toplevelModuleFound)) { |
| Location loc(0); |
| Error err(ErrorDefinition::ELAB_NO_TOP_LEVEL_MODULE, loc); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err); |
| } |
| |
| return true; |
| } |
| |
| bool DesignElaboration::createBuiltinPrimitives_() { |
| m_moduleDefFactory = new ModuleDefinitionFactory(); |
| Design* design = m_compileDesign->getCompiler()->getDesign(); |
| |
| // Register built-in primitives |
| for (auto type : |
| {"cmos", "rcmos", "bufif0", "bufif1", "notif0", |
| "notif1", "nmos", "pmos", "rnmos", "rpmos", |
| "and", "or", "nand", "nor", "xor", |
| "xnor", "buf", "not", "tranif0", "tranif1", |
| "rtranif0", "rtranif1", "tran", "rtran", "UnsupportedPrimitive"}) { |
| std::string name = std::string("work@") + type; |
| design->addModuleDefinition(name, |
| m_moduleDefFactory->newModuleDefinition( |
| NULL, 0, std::string("work@") + type)); |
| } |
| |
| return true; |
| } |
| |
| bool DesignElaboration::elaborateAllModules_(bool onlyTopLevel) { |
| bool status = true; |
| for (auto topmodule : m_topLevelModules) { |
| if (!elaborateModule_(topmodule.first, topmodule.second, onlyTopLevel)) { |
| status = false; |
| } |
| } |
| return status; |
| } |
| |
| Config* DesignElaboration::getInstConfig(std::string name) { |
| Config* config = NULL; |
| auto itr = m_instConfig.find(name); |
| if (itr != m_instConfig.end()) { |
| config = &(*itr).second; |
| } |
| return config; |
| } |
| |
| Config* DesignElaboration::getCellConfig(std::string name) { |
| Config* config = NULL; |
| auto itr = m_cellConfig.find(name); |
| if (itr != m_cellConfig.end()) { |
| config = &(*itr).second; |
| } |
| return config; |
| } |
| |
| bool DesignElaboration::elaborateModule_(std::string moduleName, |
| FileContent* fC, bool onlyTopLevel) { |
| FileContent::NameIdMap& nameIds = fC->getObjectLookup(); |
| std::vector<VObjectType> types = {VObjectType::slUdp_instantiation, |
| VObjectType::slModule_instantiation, |
| VObjectType::slInterface_instantiation, |
| VObjectType::slProgram_instantiation}; |
| std::string libName = fC->getLibrary()->getName(); |
| Config* config = getInstConfig(moduleName); |
| if (config == NULL) config = getCellConfig(moduleName); |
| Design* design = m_compileDesign->getCompiler()->getDesign(); |
| if (!m_moduleInstFactory) m_moduleInstFactory = new ModuleInstanceFactory(); |
| for (auto nameId : nameIds) { |
| if ((fC->Type(nameId.second) == VObjectType::slModule_declaration) && |
| (moduleName == (libName + "@" + nameId.first))) { |
| DesignComponent* def = design->getComponentDefinition(moduleName); |
| if (onlyTopLevel) { |
| ModuleInstance* instance = m_moduleInstFactory->newModuleInstance( |
| def, fC, nameId.second, NULL, moduleName, moduleName); |
| design->addTopLevelModuleInstance(instance); |
| } else { |
| ModuleInstance* instance = design->findInstance(moduleName); |
| for (unsigned int i = 0; i < def->getFileContents().size(); i++) |
| elaborateInstance_(def->getFileContents()[i], def->getNodeIds()[i], 0, |
| m_moduleInstFactory, instance, config); |
| } |
| break; |
| } |
| } |
| return true; |
| } |
| |
| void DesignElaboration::recurseInstanceLoop_( |
| std::vector<int>& from, std::vector<int>& to, std::vector<int>& indexes, |
| unsigned int pos, DesignComponent* def, FileContent* fC, |
| NodeId subInstanceId, NodeId paramOverride, ModuleInstanceFactory* factory, |
| ModuleInstance* parent, Config* config, std::string instanceName, |
| std::string modName, std::vector<ModuleInstance*>& allSubInstances) { |
| if (pos == indexes.size()) { |
| // This is where the real logic goes. |
| // indexes[i] contain the value of the i-th index. |
| for (unsigned int i = 0; i < indexes.size(); i++) { |
| instanceName += std::to_string(indexes[i]); |
| } |
| ModuleInstance* child = factory->newModuleInstance( |
| def, fC, subInstanceId, parent, instanceName, modName); |
| VObjectType type = fC->Type(subInstanceId); |
| if (def && (type != VObjectType::slGate_instantiation)) |
| for (unsigned int i = 0; i < def->getFileContents().size(); i++) |
| elaborateInstance_(def->getFileContents()[i], def->getNodeIds()[i], |
| paramOverride, factory, child, config); |
| allSubInstances.push_back(child); |
| |
| } else { |
| for (indexes[pos] = from[pos]; indexes[pos] <= to[pos]; indexes[pos]++) { |
| // Recurse for the next level |
| recurseInstanceLoop_(from, to, indexes, pos + 1, def, fC, subInstanceId, |
| paramOverride, factory, parent, config, instanceName, |
| modName, allSubInstances); |
| } |
| } |
| } |
| |
| void DesignElaboration::elaborateInstance_(FileContent* fC, NodeId nodeId, |
| NodeId parentParamOverride, |
| ModuleInstanceFactory* factory, |
| ModuleInstance* parent, |
| Config* config) { |
| if (!parent) return; |
| std::vector<ModuleInstance*> allSubInstances; |
| std::string genBlkBaseName = "genblk"; |
| unsigned int genBlkIndex = 1; |
| bool reuseInstance = false; |
| std::string mname; |
| std::vector<VObjectType> types; |
| std::vector<std::string> params; |
| |
| // Scan for parameters, including DefParams |
| collectParams_(params, fC, nodeId, parent, parentParamOverride); |
| |
| // Apply DefParams |
| Design* design = m_compileDesign->getCompiler()->getDesign(); |
| for (auto name : params) { |
| DefParam* defparam = |
| design->getDefParam(parent->getFullPathName() + "." + name); |
| if (defparam) { |
| Value* value = defparam->getValue(); |
| if (value) { |
| parent->setValue(name, value, m_exprBuilder); |
| defparam->setUsed(); |
| } |
| } |
| } |
| |
| // Scan for regular instances and generate blocks |
| types = { |
| VObjectType::slUdp_instantiation, |
| VObjectType::slModule_instantiation, |
| VObjectType::slInterface_instantiation, |
| VObjectType::slProgram_instantiation, |
| VObjectType::slGate_instantiation, |
| VObjectType::slConditional_generate_construct, // Generate construct are |
| // a kind of instantiation |
| VObjectType::slGenerate_module_conditional_statement, |
| VObjectType::slLoop_generate_construct, |
| VObjectType::slGenerate_module_loop_statement, |
| VObjectType::slPar_block, |
| VObjectType::slSeq_block}; |
| |
| std::vector<VObjectType> stopPoints = { |
| VObjectType::slConditional_generate_construct, |
| VObjectType::slGenerate_module_conditional_statement, |
| VObjectType::slLoop_generate_construct, |
| VObjectType::slGenerate_module_loop_statement, |
| VObjectType::slPar_block, |
| VObjectType::slSeq_block, |
| VObjectType::slModule_declaration}; |
| |
| std::vector<NodeId> subInstances = |
| fC->sl_collect_all(nodeId, types, stopPoints); |
| |
| for (auto subInstanceId : subInstances) { |
| NodeId childId = 0; |
| std::string instName; |
| std::string modName; |
| DesignComponent* def = NULL; |
| NodeId paramOverride = 0; |
| Config* subConfig = config; |
| VObjectType type = fC->Type(subInstanceId); |
| |
| if (type == slSeq_block || type == slPar_block) { |
| NodeId identifierId = fC->Child(subInstanceId); |
| if (fC->Name(identifierId)) |
| instName = fC->SymName(identifierId); |
| else |
| instName = "UNNAMED"; |
| } else if (type == slConditional_generate_construct) { |
| NodeId constructId = fC->Child(subInstanceId); |
| NodeId condId = fC->Child(constructId); |
| NodeId blockId = fC->Sibling(condId); |
| NodeId nameId = fC->Child(blockId); |
| if (fC->Name(nameId)) |
| instName = fC->SymName(nameId); |
| else |
| instName = "UNNAMED"; |
| } else { |
| NodeId instId = fC->sl_collect(subInstanceId, slName_of_instance); |
| NodeId identifierId = 0; |
| if (instId != InvalidNodeId) { |
| identifierId = fC->Child(instId); |
| instName = fC->SymName(identifierId); |
| } |
| } |
| |
| // Special module binding for built-in primitives |
| if (type == VObjectType::slGate_instantiation) { |
| VObjectType gatetype = fC->Type(fC->Child(subInstanceId)); |
| switch (gatetype) { |
| case VObjectType::slNInpGate_And: |
| modName = "work@and"; |
| break; |
| case VObjectType::slNInpGate_Or: |
| modName = "work@or"; |
| break; |
| case VObjectType::slNInpGate_Nand: |
| modName = "work@nand"; |
| break; |
| case VObjectType::slNInpGate_Nor: |
| modName = "work@nor"; |
| break; |
| case VObjectType::slNInpGate_Xor: |
| modName = "work@xor"; |
| break; |
| case VObjectType::slNInpGate_Xnor: |
| modName = "work@xnor"; |
| break; |
| case VObjectType::slNOutGate_Buf: |
| modName = "work@buf"; |
| break; |
| case VObjectType::slNOutGate_Not: |
| modName = "work@not"; |
| break; |
| // TODO: Cater for the transistor level |
| default: |
| modName = "work@UnsupportedPrimitive"; |
| break; |
| } |
| |
| def = design->getComponentDefinition(modName); |
| childId = 0; // = def->getNodeId (); |
| ModuleInstance* child = factory->newModuleInstance( |
| def, fC, subInstanceId, parent, instName, modName); |
| allSubInstances.push_back(child); |
| |
| } |
| // Special module binding for generate statements |
| else if (type == VObjectType::slConditional_generate_construct || |
| type == VObjectType::slGenerate_module_conditional_statement || |
| type == VObjectType::slLoop_generate_construct || |
| type == VObjectType::slGenerate_module_loop_statement) { |
| modName = genBlkBaseName + std::to_string(genBlkIndex); |
| |
| std::vector<VObjectType> btypes = { |
| VObjectType::slGenerate_module_block, VObjectType::slGenerate_block, |
| VObjectType::slGenerate_module_named_block}; |
| |
| std::vector<NodeId> blockIds = |
| fC->sl_collect_all(subInstanceId, btypes, true); |
| bool namedBlock = false; |
| if (blockIds.size()) { |
| NodeId blockId = blockIds[0]; |
| NodeId blockNameId = fC->Child(blockId); |
| if (fC->Type(blockNameId) == VObjectType::slStringConst) { |
| namedBlock = true; |
| modName = fC->SymName(blockNameId); |
| } |
| } |
| if (!namedBlock) genBlkIndex++; |
| instName = modName; |
| std::string fullName; |
| std::string libName = fC->getLibrary()->getName(); |
| if (instName == parent->getInstanceName()) { |
| fullName += parent->getFullPathName(); |
| reuseInstance = true; |
| } else { |
| fullName += parent->getModuleName() + "." + instName; |
| } |
| def = design->getComponentDefinition(fullName); |
| if (def == NULL) { |
| def = m_moduleDefFactory->newModuleDefinition(fC, subInstanceId, |
| fullName); |
| design->addModuleDefinition(fullName, (ModuleDefinition*)def); |
| } |
| |
| NodeId conditionId = fC->Child(subInstanceId); |
| |
| if (fC->Type(conditionId) == VObjectType::slGenvar_initialization || |
| fC->Type(conditionId) == |
| VObjectType::slGenvar_decl_assignment) { // For loop stmt |
| |
| // Var init |
| NodeId varId = fC->Child(conditionId); |
| NodeId constExpr = fC->Sibling(varId); |
| Value* initValue = m_exprBuilder.evalExpr(fC, constExpr, parent); |
| std::string name = fC->SymName(varId); |
| parent->setValue(name, initValue, m_exprBuilder); |
| |
| // End-loop test |
| NodeId endLoopTest = fC->Sibling(conditionId); |
| |
| // Iteration |
| NodeId iteration = fC->Sibling(endLoopTest); |
| NodeId var = fC->Child(iteration); |
| NodeId assignOp = fC->Sibling(var); |
| NodeId expr = fC->Sibling(assignOp); |
| if (expr == 0) { // Unary operator like i++ |
| expr = var; |
| } |
| // Generate block |
| NodeId genBlock = fC->Sibling(iteration); |
| |
| bool cont = true; |
| Value* testCond = m_exprBuilder.evalExpr(fC, endLoopTest, parent); |
| cont = testCond->getValueUL(); |
| m_exprBuilder.deleteValue(testCond); |
| |
| while (cont) { |
| Value* currentIndexValue = parent->getValue(name); |
| long currVal = currentIndexValue->getValueUL(); |
| std::string indexedModName = |
| modName + "[" + std::to_string(currVal) + "]"; |
| instName = indexedModName; |
| ModuleInstance* child = factory->newModuleInstance( |
| def, fC, genBlock, parent, instName, indexedModName); |
| child->setValue(name, currentIndexValue, m_exprBuilder); |
| elaborateInstance_(def->getFileContents()[0], genBlock, 0, factory, |
| child, config); |
| allSubInstances.push_back(child); |
| |
| Value* newVal = m_exprBuilder.evalExpr(fC, expr, parent); |
| parent->setValue(name, newVal, m_exprBuilder); |
| Value* testCond = m_exprBuilder.evalExpr(fC, endLoopTest, parent); |
| cont = testCond->getValueUL(); |
| m_exprBuilder.deleteValue(testCond); |
| } |
| if (allSubInstances.size()) { |
| ModuleInstance** children = |
| new ModuleInstance*[allSubInstances.size()]; |
| for (unsigned int index = 0; index < allSubInstances.size(); |
| index++) { |
| children[index] = allSubInstances[index]; |
| } |
| parent->addSubInstances(children, allSubInstances.size()); |
| } |
| continue; |
| |
| } else { // If-Else or Case stmt |
| if (fC->Type(conditionId) != VObjectType::slConstant_expression) { |
| conditionId = fC->Child(conditionId); |
| } |
| Value* condValue = m_exprBuilder.evalExpr(fC, conditionId, parent); |
| long condVal = condValue->getValueUL(); |
| m_exprBuilder.deleteValue(condValue); |
| NodeId tmp = fC->Sibling(conditionId); |
| if (fC->Type(tmp) == VObjectType::slCase_generate_item) { // Case stmt |
| NodeId caseItem = tmp; |
| bool nomatch = true; |
| while (nomatch) { |
| NodeId exprItem = fC->Child(caseItem); |
| if (fC->Type(exprItem) == |
| VObjectType::slGenerate_block) // Default block |
| nomatch = false; |
| while (nomatch) { |
| // Find if one of the case expr matches the case expr |
| if (fC->Type(exprItem) == VObjectType::slConstant_expression) { |
| Value* caseValue = m_exprBuilder.evalExpr(fC, exprItem, parent); |
| long caseVal = caseValue->getValueUL(); |
| m_exprBuilder.deleteValue(caseValue); |
| if (condVal == caseVal) { |
| nomatch = false; |
| break; |
| } |
| } else |
| break; |
| exprItem = fC->Sibling(exprItem); |
| } |
| |
| if (nomatch) { |
| // Next case stmt |
| caseItem = fC->Sibling(caseItem); |
| if (!caseItem) break; |
| if (fC->Type(caseItem) != VObjectType::slCase_generate_item) |
| break; |
| } else { |
| // We found a match |
| while (fC->Type(exprItem) == VObjectType::slConstant_expression) |
| exprItem = fC->Sibling(exprItem); |
| childId = exprItem; |
| } |
| } |
| } else { // If-Else stmt |
| if (condVal) { // If branch |
| if (tmp) |
| childId = tmp; |
| else // There is no If stmt |
| continue; |
| } else { // Else branch |
| if (tmp) tmp = fC->Sibling(tmp); |
| if (tmp) |
| childId = tmp; |
| else // There is no Else stmt |
| continue; |
| } |
| } |
| } |
| |
| libName = fC->getLibrary()->getName(); |
| fullName = parent->getModuleName() + "." + instName; |
| def = design->getComponentDefinition(fullName); |
| if (def == NULL) { |
| def = m_moduleDefFactory->newModuleDefinition(fC, subInstanceId, |
| fullName); |
| design->addModuleDefinition(fullName, (ModuleDefinition*)def); |
| } |
| |
| ModuleInstance* child = factory->newModuleInstance( |
| def, fC, subInstanceId, parent, instName, modName); |
| elaborateInstance_(def->getFileContents()[0], childId, paramOverride, |
| factory, child, config); |
| allSubInstances.push_back(child); |
| |
| } |
| // Named blocks |
| else if (type == slSeq_block || type == slPar_block) { |
| std::string libName = fC->getLibrary()->getName(); |
| std::string fullName = parent->getModuleName() + "." + instName; |
| |
| def = design->getComponentDefinition(fullName); |
| if (def == NULL) { |
| def = m_moduleDefFactory->newModuleDefinition(fC, subInstanceId, |
| fullName); |
| design->addModuleDefinition(fullName, (ModuleDefinition*)def); |
| } |
| |
| ModuleInstance* child = factory->newModuleInstance( |
| def, fC, subInstanceId, parent, instName, modName); |
| elaborateInstance_(def->getFileContents()[0], subInstanceId, |
| paramOverride, factory, child, config); |
| allSubInstances.push_back(child); |
| |
| } |
| // Regular module binding |
| else { |
| NodeId moduleName = |
| fC->sl_collect(subInstanceId, VObjectType::slStringConst); |
| std::string libName = fC->getLibrary()->getName(); |
| mname = fC->SymName(moduleName); |
| |
| std::vector<std::string> libs; |
| if (config) { |
| for (auto lib : config->getDefaultLibs()) { |
| libs.push_back(lib); |
| } |
| libs.push_back(libName); |
| } else { |
| libs.push_back(libName); |
| } |
| |
| for (auto lib : libs) { |
| modName = lib + "@" + mname; |
| def = design->getComponentDefinition(modName); |
| if (def) { |
| break; |
| } else { |
| modName = parent->getDefinition()->getName() + "::" + mname; |
| def = design->getComponentDefinition(modName); |
| if (def) { |
| break; |
| } |
| } |
| } |
| |
| auto itr = m_cellUseClause.find(mname); |
| if (itr != m_cellUseClause.end()) { |
| UseClause& use = (*itr).second; |
| switch (use.getType()) { |
| case UseClause::UseModule: { |
| std::string name = use.getName(); |
| def = design->getComponentDefinition(name); |
| if (def) use.setUsed(); |
| break; |
| } |
| case UseClause::UseLib: { |
| for (auto lib : use.getLibs()) { |
| modName = lib + "@" + mname; |
| def = design->getComponentDefinition(modName); |
| if (def) { |
| use.setUsed(); |
| break; |
| } |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| |
| if (def) childId = def->getNodeIds()[0]; |
| |
| NodeId tmpId = fC->Sibling(moduleName); |
| if (fC->Type(tmpId) == VObjectType::slParameter_value_assignment) { |
| paramOverride = tmpId; |
| } |
| |
| bool loopDetected = false; |
| ModuleInstance* tmp = parent; |
| while (tmp) { |
| if (tmp->getDefinition() == def) { |
| loopDetected = true; |
| break; |
| } |
| tmp = tmp->getParent(); |
| } |
| if (loopDetected) { |
| SymbolTable* st = m_compileDesign->getCompiler() |
| ->getErrorContainer() |
| ->getSymbolTable(); |
| Location loc(st->registerSymbol(fC->getFileName(subInstanceId)), |
| fC->Line(subInstanceId), 0, st->registerSymbol(modName)); |
| Location loc2(st->registerSymbol( |
| tmp->getFileContent()->getFileName(tmp->getNodeId())), |
| tmp->getFileContent()->Line(tmp->getNodeId()), 0); |
| Error err(ErrorDefinition::ELAB_INSTANTIATION_LOOP, loc, loc2); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err); |
| } else { |
| std::vector<int> from; |
| std::vector<int> to; |
| std::vector<int> index; |
| |
| std::vector<VObjectType> insttypes = { |
| VObjectType::slHierarchical_instance, |
| VObjectType::slN_input_gate_instance, |
| VObjectType::slN_output_gate_instance, VObjectType::slUdp_instance}; |
| |
| std::vector<NodeId> hierInstIds = |
| fC->sl_collect_all(subInstanceId, insttypes, true); |
| |
| NodeId hierInstId = InvalidNodeId; |
| if (hierInstIds.size()) hierInstId = hierInstIds[0]; |
| |
| if (hierInstId == InvalidNodeId) continue; |
| |
| while (hierInstId) { |
| NodeId instId = fC->sl_collect(hierInstId, slName_of_instance); |
| NodeId identifierId = 0; |
| if (instId != InvalidNodeId) { |
| identifierId = fC->Child(instId); |
| instName = fC->SymName(identifierId); |
| } |
| |
| auto itr = |
| m_instUseClause.find(parent->getFullPathName() + "." + instName); |
| if (itr != m_instUseClause.end()) { |
| UseClause& use = (*itr).second; |
| switch (use.getType()) { |
| case UseClause::UseModule: { |
| std::string name = use.getName(); |
| def = design->getComponentDefinition(name); |
| if (def) use.setUsed(); |
| break; |
| } |
| case UseClause::UseLib: { |
| for (auto lib : use.getLibs()) { |
| modName = lib + "@" + mname; |
| def = design->getComponentDefinition(modName); |
| if (def) { |
| use.setUsed(); |
| break; |
| } |
| } |
| break; |
| } |
| case UseClause::UseConfig: { |
| std::string useConfig = use.getName(); |
| Config* config = design->getConfigSet()->getConfig(useConfig); |
| if (config) { |
| subConfig = config; |
| std::string lib = config->getDesignLib(); |
| std::string top = config->getDesignTop(); |
| modName = lib + "@" + top; |
| def = design->getComponentDefinition(modName); |
| if (def) use.setUsed(); |
| } |
| } |
| default: |
| break; |
| } |
| } |
| |
| if (def) |
| childId = def->getNodeIds()[0]; |
| else { |
| SymbolTable* st = m_compileDesign->getCompiler() |
| ->getErrorContainer() |
| ->getSymbolTable(); |
| Location loc(st->registerSymbol(fC->getFileName(subInstanceId)), |
| fC->Line(subInstanceId), 0, |
| st->registerSymbol(modName)); |
| Error err(ErrorDefinition::ELAB_NO_MODULE_DEFINITION, loc); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError( |
| err, false, false); |
| } |
| |
| NodeId unpackedDimId = 0; |
| |
| if (identifierId) unpackedDimId = fC->Sibling(identifierId); |
| |
| if (unpackedDimId) { |
| // Vector instances |
| while (unpackedDimId) { |
| if (fC->Type(unpackedDimId) == slUnpacked_dimension) { |
| NodeId constantRangeId = fC->Child(unpackedDimId); |
| NodeId leftNode = fC->Child(constantRangeId); |
| NodeId rightNode = fC->Sibling(leftNode); |
| Value* leftVal = m_exprBuilder.evalExpr(fC, leftNode, parent); |
| Value* rightVal = m_exprBuilder.evalExpr(fC, rightNode, parent); |
| unsigned long left = leftVal->getValueUL(); |
| unsigned long right = rightVal->getValueUL(); |
| m_exprBuilder.deleteValue(leftVal); |
| m_exprBuilder.deleteValue(rightVal); |
| if (left < right) { |
| from.push_back(left); |
| to.push_back(right); |
| index.push_back(left); |
| } else { |
| from.push_back(right); |
| to.push_back(left); |
| index.push_back(right); |
| } |
| } |
| unpackedDimId = fC->Sibling(unpackedDimId); |
| } |
| recurseInstanceLoop_(from, to, index, 0, def, fC, subInstanceId, |
| paramOverride, factory, parent, subConfig, |
| instName, modName, allSubInstances); |
| } else { |
| // Simple instance |
| ModuleInstance* child = NULL; |
| if (reuseInstance) { |
| child = parent; |
| child->setNodeId(subInstanceId); |
| } else { |
| child = factory->newModuleInstance(def, fC, subInstanceId, parent, |
| instName, modName); |
| } |
| if (def && (type != VObjectType::slGate_instantiation)) |
| elaborateInstance_(def->getFileContents()[0], childId, |
| paramOverride, factory, child, subConfig); |
| |
| if (!reuseInstance) allSubInstances.push_back(child); |
| } |
| |
| hierInstId = fC->Sibling(hierInstId); |
| } |
| |
| // std::cout << "INST: " << modName << " " << instName << " " << def << |
| // std::endl; |
| } |
| } |
| } |
| // Record sub-scopes and sub-instances |
| if (allSubInstances.size()) { |
| ModuleInstance** children = new ModuleInstance*[allSubInstances.size()]; |
| for (unsigned int index = 0; index < allSubInstances.size(); index++) { |
| children[index] = allSubInstances[index]; |
| } |
| parent->addSubInstances(children, allSubInstances.size()); |
| } |
| } |
| |
| void DesignElaboration::reportElaboration_() { |
| unsigned int nbTopLevelModules = 0; |
| unsigned int maxDepth = 0; |
| unsigned int numberOfInstances = 0; |
| unsigned int numberOfLeafInstances = 0; |
| unsigned int nbUndefinedModules = 0; |
| unsigned int nbUndefinedInstances = 0; |
| |
| m_compileDesign->getCompiler()->getDesign()->reportInstanceTreeStats( |
| nbTopLevelModules, maxDepth, numberOfInstances, numberOfLeafInstances, |
| nbUndefinedModules, nbUndefinedInstances); |
| |
| SymbolTable* symtable = m_compileDesign->getCompiler()->getSymbolTable(); |
| |
| Location loc1(symtable->registerSymbol(std::to_string(nbTopLevelModules))); |
| Error err1(ErrorDefinition::ELAB_NB_TOP_LEVEL_MODULES, loc1); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err1); |
| |
| Location loc2(symtable->registerSymbol(std::to_string(maxDepth))); |
| Error err2(ErrorDefinition::ELAB_MAX_INSTANCE_DEPTH, loc2); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err2); |
| |
| Location loc3(symtable->registerSymbol(std::to_string(numberOfInstances))); |
| Error err3(ErrorDefinition::ELAB_NB_INSTANCES, loc3); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err3); |
| |
| Location loc4( |
| symtable->registerSymbol(std::to_string(numberOfLeafInstances))); |
| Error err4(ErrorDefinition::ELAB_NB_LEAF_INSTANCES, loc4); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err4); |
| |
| if (nbUndefinedModules) { |
| Location loc5(symtable->registerSymbol(std::to_string(nbUndefinedModules))); |
| Error err5(ErrorDefinition::ELAB_NB_UNDEF_MODULES, loc5); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err5); |
| } |
| |
| if (nbUndefinedInstances) { |
| Location loc6( |
| symtable->registerSymbol(std::to_string(nbUndefinedInstances))); |
| Error err6(ErrorDefinition::ELAB_NB_UNDEF_INSTANCES, loc6); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err6); |
| } |
| CommandLineParser* cl = |
| m_compileDesign->getCompiler()->getCommandLineParser(); |
| if (cl->getDebugInstanceTree() && (!cl->muteStdout())) { |
| std::cout << "Instance tree:" << std::endl; |
| std::cout |
| << m_compileDesign->getCompiler()->getDesign()->reportInstanceTree(); |
| std::cout << std::endl; |
| } |
| } |
| |
| void DesignElaboration::collectParams_(std::vector<std::string>& params, |
| FileContent* fC, NodeId nodeId, |
| ModuleInstance* instance, |
| NodeId parentParamOverride) { |
| if (!nodeId) return; |
| if (!instance) return; |
| Design* design = m_compileDesign->getCompiler()->getDesign(); |
| SymbolTable* st = m_compileDesign->getCompiler()->getSymbolTable(); |
| ErrorContainer* errors = m_compileDesign->getCompiler()->getErrorContainer(); |
| DesignComponent* module = instance->getDefinition(); |
| |
| // Parameters imported by package imports |
| std::vector<FileCNodeId> pack_imports; |
| for (auto import : fC->getObjects(VObjectType::slPackage_import_item)) { |
| pack_imports.push_back(import); |
| } |
| for (auto import : module->getObjects(VObjectType::slPackage_import_item)) { |
| pack_imports.push_back(import); |
| } |
| |
| for (auto pack_import : pack_imports) { |
| NodeId pack_id = pack_import.fC->Child(pack_import.nodeId); |
| std::string pack_name = pack_import.fC->SymName(pack_id); |
| Package* def = design->getPackage(pack_name); |
| if (def) { |
| auto& paramSet = def->getObjects(VObjectType::slParam_assignment); |
| for (unsigned int i = 0; i < paramSet.size(); i++) { |
| FileContent* packageFile = paramSet[i].fC; |
| NodeId param = paramSet[i].nodeId; |
| |
| NodeId ident = packageFile->Child(param); |
| std::string name = packageFile->SymName(ident); |
| Value* value = m_exprBuilder.clone(def->getValues()[i]); |
| instance->setValue(name, value, m_exprBuilder); |
| params.push_back(name); |
| } |
| } else { |
| Location loc(st->registerSymbol(pack_import.fC->getFileName(pack_id)), |
| pack_import.fC->Line(pack_id), 0, |
| st->registerSymbol(pack_name)); |
| Error err(ErrorDefinition::ELAB_UNDEFINED_PACKAGE, loc); |
| errors->addError(err); |
| } |
| } |
| |
| for (FileCNodeId param : |
| module->getObjects(VObjectType::slParam_assignment)) { |
| NodeId ident = param.fC->Child(param.nodeId); |
| std::string name = param.fC->SymName(ident); |
| Value* value = |
| m_exprBuilder.evalExpr(param.fC, param.fC->Sibling(ident), instance); |
| instance->setValue(name, value, m_exprBuilder); |
| params.push_back(name); |
| } |
| |
| std::vector<VObjectType> types; |
| // Param overrides |
| if (parentParamOverride) { |
| FileContent* parentFile = |
| instance->getParent()->getDefinition()->getFileContents()[0]; |
| types = {VObjectType::slOrdered_parameter_assignment, |
| VObjectType::slNamed_parameter_assignment}; |
| std::vector<NodeId> overrideParams = |
| parentFile->sl_collect_all(parentParamOverride, types); |
| |
| unsigned int index = 0; |
| for (auto paramAssign : overrideParams) { |
| NodeId child = parentFile->Child(paramAssign); |
| if (parentFile->Type(child) == VObjectType::slStringConst) { |
| // Named param |
| std::string name = parentFile->SymName(child); |
| NodeId expr = parentFile->Sibling(child); |
| Value* value = |
| m_exprBuilder.evalExpr(parentFile, expr, instance->getParent()); |
| instance->setValue(name, value, m_exprBuilder); |
| } else { |
| // Index param |
| NodeId expr = child; |
| Value* value = |
| m_exprBuilder.evalExpr(parentFile, expr, instance->getParent()); |
| std::string name = "OUT_OF_RANGE_PARAM_INDEX"; |
| if (index < params.size()) { |
| name = params[index]; |
| } else { |
| Location loc(st->registerSymbol(parentFile->getFileName(paramAssign)), |
| parentFile->Line(paramAssign), 0, |
| st->registerSymbol(std::to_string(index))); |
| Error err(ErrorDefinition::ELAB_OUT_OF_RANGE_PARAM_INDEX, loc); |
| errors->addError(err); |
| } |
| instance->setValue(name, value, m_exprBuilder); |
| index++; |
| } |
| } |
| } |
| |
| // Defparams |
| types = {VObjectType::slDefparam_assignment}; |
| std::vector<VObjectType> stopPoints = { |
| VObjectType::slConditional_generate_construct, |
| VObjectType::slGenerate_module_conditional_statement, |
| VObjectType::slLoop_generate_construct, |
| VObjectType::slGenerate_module_loop_statement, |
| VObjectType::slPar_block, |
| VObjectType::slSeq_block, |
| VObjectType::slModule_declaration}; |
| |
| std::vector<NodeId> defParams = fC->sl_collect_all(nodeId, types, stopPoints); |
| for (auto defParam : defParams) { |
| NodeId hIdent = fC->Child(defParam); |
| NodeId var = fC->Child(hIdent); |
| NodeId value = fC->Sibling(hIdent); |
| std::string fullPath = fC->SymName(var); |
| std::string path; |
| for (unsigned int i = 0; i < fullPath.size(); i++) { |
| if (fullPath[i] == '.') break; |
| path += fullPath[i]; |
| } |
| std::string pathRoot; |
| pathRoot = fC->getLibrary()->getName() + "@"; |
| pathRoot += path; |
| path = fullPath; |
| |
| // path refers to a sub instance |
| std::string prefix; |
| if (design->findInstance(pathRoot)) { |
| std::string p = design->findInstance(pathRoot)->getFullPathName(); |
| if (strstr(p.c_str(), ".")) { |
| prefix = instance->getFullPathName() + "."; |
| } else { |
| prefix = fC->getLibrary()->getName() + "@"; |
| } |
| } else { |
| prefix = instance->getFullPathName() + "."; |
| } |
| path = prefix + path; |
| Value* val = m_exprBuilder.evalExpr(fC, value, instance); |
| design->addDefParam(path, fC, hIdent, val); |
| } |
| } |
| |
| void DesignElaboration::checkElaboration_() { |
| Design* design = m_compileDesign->getCompiler()->getDesign(); |
| design->checkDefParamUsage(); |
| checkConfigurations_(); |
| } |
| |
| void DesignElaboration::checkConfigurations_() { |
| SymbolTable* st = m_compileDesign->getCompiler()->getSymbolTable(); |
| for (auto& pathUseC : m_cellUseClause) { |
| UseClause& useC = pathUseC.second; |
| if (!useC.isUsed()) { |
| FileContent* fC = useC.getFileContent(); |
| Location loc(st->registerSymbol(fC->getFileName(useC.getNodeId())), |
| fC->Line(useC.getNodeId()), 0, |
| st->registerSymbol(pathUseC.first)); |
| Error err(ErrorDefinition::ELAB_USE_CLAUSE_IGNORED, loc); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err); |
| } |
| } |
| for (auto& pathUseC : m_instUseClause) { |
| UseClause& useC = pathUseC.second; |
| if (!useC.isUsed()) { |
| FileContent* fC = useC.getFileContent(); |
| Location loc(st->registerSymbol(fC->getFileName(useC.getNodeId())), |
| fC->Line(useC.getNodeId()), 0, |
| st->registerSymbol(pathUseC.first)); |
| Error err(ErrorDefinition::ELAB_USE_CLAUSE_IGNORED, loc); |
| m_compileDesign->getCompiler()->getErrorContainer()->addError(err); |
| } |
| } |
| } |
| |
| void DesignElaboration::reduceUnnamedBlocks_() { |
| Design* design = m_compileDesign->getCompiler()->getDesign(); |
| std::queue<ModuleInstance*> queue; |
| for (auto instance : design->getTopLevelModuleInstances()) { |
| queue.push(instance); |
| } |
| |
| while (queue.size()) { |
| ModuleInstance* current = queue.front(); |
| queue.pop(); |
| for (unsigned int i = 0; i < current->getNbChildren(); i++) { |
| queue.push(current->getChildren(i)); |
| } |
| FileContent* fC = current->getFileContent(); |
| NodeId id = current->getNodeId(); |
| VObjectType type = fC->Type(id); |
| |
| ModuleInstance* parent = current->getParent(); |
| if (parent) { |
| FileContent* fCP = parent->getFileContent(); |
| NodeId idP = parent->getNodeId(); |
| VObjectType typeP = fCP->Type(idP); |
| |
| if ((type == VObjectType::slConditional_generate_construct || |
| type == VObjectType::slGenerate_module_conditional_statement || |
| type == VObjectType::slLoop_generate_construct || |
| type == VObjectType::slGenerate_module_loop_statement) && |
| (typeP == VObjectType::slConditional_generate_construct || |
| typeP == VObjectType::slGenerate_module_conditional_statement || |
| typeP == VObjectType::slLoop_generate_construct || |
| typeP == VObjectType::slGenerate_module_loop_statement)) { |
| std::string fullModName = current->getModuleName(); |
| fullModName = StringUtils::leaf(fullModName); |
| std::string fullModNameP = parent->getModuleName(); |
| fullModNameP = StringUtils::leaf(fullModNameP); |
| if (strstr(fullModName.c_str(), "genblk")) { |
| if (fullModName == fullModNameP) |
| parent->getParent()->overrideParentChild(parent->getParent(), |
| parent, current); |
| } else { |
| if (strstr(fullModNameP.c_str(), "genblk")) |
| parent->getParent()->overrideParentChild(parent->getParent(), |
| parent, current); |
| } |
| } |
| } |
| } |
| } |
