| /* |
| 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.hpp" |
| #include "../SourceCompile/CompilationUnit.h" |
| #include "../SourceCompile/PreprocessFile.h" |
| #include "../SourceCompile/CompileSourceFile.h" |
| #include "../SourceCompile/ParseFile.h" |
| #include "../SourceCompile/Compiler.h" |
| #include "CompileDesign.h" |
| #include "../Testbench/Property.h" |
| #include "../Design/Function.h" |
| #include "../Testbench/ClassDefinition.h" |
| #include "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); |
| } |
| } |
| } |
| } |
| } |
