| /* |
| 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: Compiler.cpp |
| * Author: alain |
| * |
| * Created on March 4, 2017, 5:16 PM |
| */ |
| #include "../CommandLine/CommandLineParser.hpp" |
| #include "../ErrorReporting/ErrorContainer.h" |
| #include "SymbolTable.h" |
| #include "CompilationUnit.h" |
| #include "PreprocessFile.h" |
| #include "CompilationUnit.h" |
| #include "CompileSourceFile.h" |
| #include "Compiler.h" |
| #include "CheckCompile.h" |
| #include "antlr4-runtime.h" |
| #include "../DesignCompile/CompileDesign.h" |
| #include "AnalyzeFile.h" |
| #include "../Library/ParseLibraryDef.h" |
| #include "../Utils/FileUtils.h" |
| #include "../Package/Precompiled.h" |
| #include "../Utils/StringUtils.h" |
| #include "../Utils/Timer.h" |
| #include "math.h" |
| using namespace antlr4; |
| |
| #include "../API/PythonAPI.h" |
| #include "CheckCompile.h" |
| #include <mutex> |
| #include <thread> |
| #include <vector> |
| using namespace SURELOG; |
| |
| Compiler::Compiler (CommandLineParser* commandLineParser, ErrorContainer* errors, SymbolTable* symbolTable) : |
| m_commandLineParser (commandLineParser), m_errors (errors), m_symbolTable (symbolTable), m_commonCompilationUnit (NULL) |
| { |
| m_design = NULL; |
| #ifdef USETBB |
| if (getCommandLineParser ()->useTbb () && (getCommandLineParser ()->getNbMaxTreads () > 0)) |
| tbb::task_scheduler_init init (getCommandLineParser ()->getNbMaxTreads ()); |
| #endif |
| } |
| |
| Compiler::Compiler (const Compiler& orig) { } |
| |
| Compiler::~Compiler () |
| { |
| std::map<SymbolId, PreprocessFile::AntlrParserHandler*>::iterator itr; |
| for (itr = m_antlrPpMap.begin (); itr != m_antlrPpMap.end (); itr++) |
| { |
| delete (*itr).second; |
| } |
| if (m_commonCompilationUnit) |
| { |
| delete m_commonCompilationUnit; |
| } |
| cleanup_ (); |
| } |
| |
| struct FunctorCompileOneFile |
| { |
| |
| FunctorCompileOneFile (CompileSourceFile* compileSource, CompileSourceFile::Action action) : |
| m_compileSourceFile (compileSource), m_action (action) { } |
| |
| int operator() () const |
| { |
| if (m_compileSourceFile->getCommandLineParser ()->pythonListener () |
| || m_compileSourceFile->getCommandLineParser ()->pythonEvalScriptPerFile ()) |
| { |
| PyThreadState* interpState = PythonAPI::initNewInterp (); |
| m_compileSourceFile->setPythonInterp (interpState); |
| } |
| return m_compileSourceFile->compile (m_action); |
| } |
| |
| private: |
| CompileSourceFile* m_compileSourceFile; |
| CompileSourceFile::Action m_action; |
| }; |
| |
| bool |
| Compiler::compileOneFile_ (CompileSourceFile* compiler, CompileSourceFile::Action action) |
| { |
| bool status = compiler->compile (action); |
| return status; |
| } |
| |
| bool Compiler::isLibraryFile (SymbolId id) { |
| if (m_libraryFiles.find(id) == m_libraryFiles.end()) |
| { |
| return false; |
| } |
| else |
| { |
| return true; |
| } |
| } |
| |
| bool |
| Compiler::ppinit_ () |
| { |
| if (!m_commandLineParser->fileunit ()) |
| { |
| m_commonCompilationUnit = new CompilationUnit (false); |
| } |
| |
| CompilationUnit* comp_unit = m_commonCompilationUnit; |
| |
| // Source files (.v, .sv on the command line) |
| std::set<SymbolId> sourceFiles; |
| unsigned int size = m_commandLineParser->getSourceFiles ().size (); |
| for (unsigned int i = 0; i < size; i++) |
| { |
| SymbolTable* symbols = m_symbolTable; |
| if (m_commandLineParser->fileunit ()) |
| { |
| comp_unit = new CompilationUnit (true); |
| m_compilationUnits.push_back (comp_unit); |
| symbols = new SymbolTable (*m_commandLineParser->getSymbolTable ()); |
| m_symbolTables.push_back (symbols); |
| } |
| ErrorContainer* errors = new ErrorContainer (symbols); |
| m_errorContainers.push_back (errors); |
| errors->regiterCmdLine (m_commandLineParser); |
| |
| SymbolId id = m_commandLineParser->getSourceFiles ()[i]; |
| |
| std::string fileName = m_commandLineParser->getSymbolTable ()->getSymbol (id); |
| std::string fullPath = FileUtils::getFullPath (fileName); |
| SymbolId fullPathId = m_commandLineParser->getSymbolTable ()->registerSymbol(fullPath); |
| Library* library = m_librarySet->getLibrary (fullPathId); |
| sourceFiles.insert(fullPathId); |
| |
| CompileSourceFile* compiler = new CompileSourceFile (m_commandLineParser->getSourceFiles ()[i], |
| m_commandLineParser, errors, this, symbols, comp_unit, library); |
| m_compilers.push_back (compiler); |
| } |
| |
| // Library files |
| std::set<SymbolId> libFiles; |
| // (-v <file>) |
| size = m_commandLineParser->getLibraryFiles ().size (); |
| for (unsigned int i = 0; i < size; i++) |
| { |
| SymbolId id = m_commandLineParser->getLibraryFiles ()[i]; |
| libFiles.insert(id); |
| } |
| // (-y <path> +libext+<ext>) |
| for (auto path : m_commandLineParser->getLibraryPaths ()) |
| { |
| for (auto ext : m_commandLineParser->getLibraryExtensions ()) |
| { |
| auto files = FileUtils::collectFiles (path, ext, m_commandLineParser->getSymbolTable ()); |
| for (auto file : files) |
| { |
| libFiles.insert(file); |
| } |
| } |
| } |
| for (auto id : libFiles) |
| { |
| SymbolTable* symbols = m_symbolTable; |
| if (m_commandLineParser->fileunit ()) |
| { |
| comp_unit = new CompilationUnit (true); |
| m_compilationUnits.push_back (comp_unit); |
| symbols = new SymbolTable (*m_commandLineParser->getSymbolTable ()); |
| m_symbolTables.push_back (symbols); |
| } |
| ErrorContainer* errors = new ErrorContainer (symbols); |
| m_errorContainers.push_back (errors); |
| errors->regiterCmdLine (m_commandLineParser); |
| |
| std::string fullPath = FileUtils::getFullPath (m_commandLineParser->getSymbolTable ()->getSymbol (id)); |
| |
| // This line registers the file in the "work" library: |
| SymbolId fullPathId = m_commandLineParser->getSymbolTable ()->registerSymbol(fullPath); |
| /*Library* library = */ m_librarySet->getLibrary (fullPathId); |
| m_libraryFiles.insert(id); |
| m_libraryFiles.insert(fullPathId); |
| // No need to register a compiler |
| //CompileSourceFile* compiler = new CompileSourceFile (m_commandLineParser->getLibraryFiles ()[i], |
| // m_commandLineParser, errors, this, symbols, comp_unit, library); |
| //m_compilers.push_back (compiler); |
| } |
| |
| |
| // Libraries (.map) |
| for (auto& lib : m_librarySet->getLibraries ()) |
| { |
| for (auto id: lib.getFiles ()) |
| { |
| std::string fileName = lib.getSymbols()->getSymbol (id); |
| if (sourceFiles.find(id) != sourceFiles.end()) |
| { |
| // These files are already included in the command line |
| continue; |
| } |
| |
| if (strstr(fileName.c_str(), ".map")) |
| { |
| // .map files are not parsed with the regular parser |
| continue; |
| } |
| SymbolTable* symbols = m_symbolTable; |
| if (m_commandLineParser->fileunit ()) |
| { |
| comp_unit = new CompilationUnit (true); |
| m_compilationUnits.push_back (comp_unit); |
| symbols = new SymbolTable (*m_commandLineParser->getSymbolTable ()); |
| m_symbolTables.push_back (symbols); |
| } |
| ErrorContainer* errors = new ErrorContainer (symbols); |
| m_errorContainers.push_back (errors); |
| errors->regiterCmdLine (m_commandLineParser); |
| |
| CompileSourceFile* compiler = new CompileSourceFile (id, |
| m_commandLineParser, errors, this, symbols, comp_unit, &lib); |
| m_compilers.push_back (compiler); |
| } |
| } |
| |
| |
| return true; |
| } |
| |
| bool |
| Compiler::parseinit_ () |
| { |
| Precompiled* prec = Precompiled::getSingleton (); |
| // Single out the large files. |
| // Small files are going to be scheduled in multiple threads based on size. |
| // Large files are going to be compiled in a different batch in multithread |
| |
| if (!m_commandLineParser->fileunit ()) |
| { |
| unsigned int size = m_symbolTables.size (); |
| for (unsigned int i = 0; i < size; i++) |
| { |
| delete m_symbolTables[i]; |
| } |
| size = m_errorContainers.size (); |
| for (unsigned int i = 0; i < size; i++) |
| { |
| delete m_errorContainers[i]; |
| } |
| m_symbolTables.clear (); |
| m_errorContainers.clear (); |
| } |
| |
| std::vector<CompileSourceFile*> tmp_compilers; |
| unsigned int size = m_compilers.size (); |
| for (unsigned int i = 0; i < size; i++) |
| { |
| std::string fileName = m_compilers[i]->getSymbolTable ()->getSymbol(m_compilers[i]->getPpOutputFileId ()); |
| std::string origFile = m_compilers[i]->getSymbolTable ()->getSymbol(m_compilers[i]->getFileId ()); |
| unsigned int nbThreads = m_commandLineParser->getNbMaxTreads (); |
| std::string root = fileName; |
| root = StringUtils::getRootFileName (root); |
| if (prec->isFilePrecompiled (root)) |
| { |
| nbThreads = 0; |
| } |
| int effectiveNbThreads = 0; |
| if (nbThreads > 4) |
| effectiveNbThreads = (int) (log (((float) nbThreads + 1.0) / 4.0) * 10.0); |
| else |
| effectiveNbThreads = nbThreads; |
| |
| AnalyzeFile* fileAnalyzer = new AnalyzeFile(m_commandLineParser, m_design, fileName, origFile, effectiveNbThreads); |
| fileAnalyzer->analyze(); |
| m_compilers[i]->setFileAnalyzer (fileAnalyzer); |
| if (fileAnalyzer->getSplitFiles ().size() > 1) |
| { |
| // Schedule parent |
| m_compilersParentFiles.push_back (m_compilers[i]); |
| m_compilers[i]->initParser (); |
| |
| if (!m_commandLineParser->fileunit ()) |
| { |
| SymbolTable* symbols = new SymbolTable (*m_commandLineParser->getSymbolTable ()); |
| m_symbolTables.push_back (symbols); |
| m_compilers[i]->setSymbolTable (symbols); |
| // fileContent->setSymbolTable(symbols); |
| ErrorContainer* errors = new ErrorContainer (symbols); |
| m_errorContainers.push_back (errors); |
| errors->regiterCmdLine (m_commandLineParser); |
| m_compilers[i]->setErrorContainer (errors); |
| } |
| |
| FileContent* fileContent = new FileContent(m_compilers[i]->getParser()->getFileId(0), |
| m_compilers[i]->getParser()->getLibrary (), |
| m_compilers[i]->getSymbolTable(), |
| m_compilers[i]->getErrorContainer (), |
| NULL, 0); |
| m_compilers[i]->getParser()->setFileContent(fileContent); |
| |
| int j = 0; |
| for (auto chunk : fileAnalyzer->getSplitFiles ()) |
| { |
| SymbolTable* symbols = new SymbolTable (*m_commandLineParser->getSymbolTable ()); |
| m_symbolTables.push_back (symbols); |
| SymbolId ppId = symbols->registerSymbol(chunk); |
| symbols->registerSymbol(m_compilers[i]->getParser()->getFileName (LINE1)); |
| CompileSourceFile* chunkCompiler = new CompileSourceFile(m_compilers[i], ppId, |
| fileAnalyzer->getLineOffsets ()[j]); |
| // Schedule chunk |
| tmp_compilers.push_back(chunkCompiler); |
| |
| |
| chunkCompiler->setSymbolTable (symbols); |
| ErrorContainer* errors = new ErrorContainer (symbols); |
| m_errorContainers.push_back (errors); |
| errors->regiterCmdLine (m_commandLineParser); |
| chunkCompiler->setErrorContainer (errors); |
| //chunkCompiler->getParser ()->setFileContent (fileContent); |
| |
| FileContent* fileContent = new FileContent(m_compilers[i]->getParser()->getFileId(0), |
| m_compilers[i]->getParser()->getLibrary(), |
| symbols, errors, NULL, ppId); |
| chunkCompiler->getParser()->setFileContent(fileContent); |
| getDesign()->addFileContent(m_compilers[i]->getParser()->getFileId(0), fileContent); |
| |
| j++; |
| } |
| } |
| else |
| { |
| |
| if (!m_commandLineParser->fileunit ()) |
| { |
| SymbolTable* symbols = new SymbolTable (*m_commandLineParser->getSymbolTable ()); |
| m_symbolTables.push_back (symbols); |
| m_compilers[i]->setSymbolTable (symbols); |
| ErrorContainer* errors = new ErrorContainer (symbols); |
| m_errorContainers.push_back (errors); |
| errors->regiterCmdLine (m_commandLineParser); |
| m_compilers[i]->setErrorContainer (errors); |
| } |
| |
| tmp_compilers.push_back (m_compilers[i]); |
| } |
| } |
| m_compilers = tmp_compilers; |
| |
| return true; |
| } |
| |
| bool |
| Compiler::pythoninit_ () |
| { |
| return parseinit_(); |
| } |
| |
| ErrorContainer::Stats |
| Compiler::getErrorStats () |
| { |
| ErrorContainer::Stats stats; |
| unsigned int size = m_errorContainers.size (); |
| for (unsigned int i = 0; i < size; i++) |
| { |
| ErrorContainer::Stats tmp; |
| tmp = m_errorContainers[i]->getErrorStats (); |
| stats += tmp; |
| } |
| |
| return stats; |
| } |
| |
| bool |
| Compiler::cleanup_ () |
| { |
| unsigned int size = m_compilers.size (); |
| for (unsigned int i = 0; i < size; i++) |
| { |
| delete m_compilers[i]; |
| } |
| size = m_compilationUnits.size (); |
| for (unsigned int i = 0; i < size; i++) |
| { |
| delete m_compilationUnits[i]; |
| } |
| size = m_symbolTables.size (); |
| for (unsigned int i = 0; i < size; i++) |
| { |
| delete m_symbolTables[i]; |
| } |
| size = m_errorContainers.size (); |
| for (unsigned int i = 0; i < size; i++) |
| { |
| delete m_errorContainers[i]; |
| } |
| return true; |
| } |
| |
| bool |
| Compiler::compileFileSet_ (CompileSourceFile::Action action, bool allowMultithread, std::vector<CompileSourceFile*>& container) |
| { |
| unsigned short maxThreadCount = m_commandLineParser->getNbMaxTreads (); |
| if (allowMultithread == false) |
| { |
| maxThreadCount = 0; |
| } |
| |
| if (maxThreadCount == 0) |
| { |
| // Single thread |
| unsigned int size = container.size (); |
| for (unsigned int i = 0; i < size; i++) |
| { |
| container[i]->setPythonInterp (PythonAPI::getMainInterp ()); |
| bool status = compileOneFile_ (container[i], action); |
| m_errors->appendErrors (*container[i]->getErrorContainer ()); |
| m_errors->printMessages (m_commandLineParser->muteStdout ()); |
| if ((!status) || container[i]->getErrorContainer ()->hasFatalErrors ()) |
| return false; |
| } |
| } |
| else if (getCommandLineParser ()->useTbb () && (action != CompileSourceFile::Action::Parse)) |
| { |
| #ifdef USETBB |
| // TBB Thread management |
| int maxThreadCount = m_commandLineParser->getNbMaxTreads (); |
| if (allowMultithread == false) |
| { |
| maxThreadCount = 0; |
| } |
| unsigned int size = container.size (); |
| if (maxThreadCount) |
| { |
| for (unsigned int i = 0; i < size; i++) |
| { |
| m_taskGroup.run (FunctorCompileOneFile (container[i], action)); |
| } |
| m_taskGroup.wait (); |
| bool fatalErrors = false; |
| for (unsigned int i = 0; i < size; i++) |
| { |
| // Promote report to master error container |
| m_errors->appendErrors (*container[i]->getErrorContainer ()); |
| if (container[i]->getErrorContainer ()->hasFatalErrors ()) |
| { |
| fatalErrors = true; |
| } |
| if (getCommandLineParser ()->pythonListener ()) |
| { |
| container[i]->shutdownPythonInterp (); |
| } |
| m_errors->printMessages (m_commandLineParser->muteStdout ()); |
| } |
| if (fatalErrors) |
| return false; |
| } |
| else |
| { |
| for (unsigned int i = 0; i < size; i++) |
| { |
| container[i]->setPythonInterp (PythonAPI::getMainInterp ()); |
| bool status = compileOneFile_ (container[i], action); |
| m_errors->appendErrors (*container[i]->getErrorContainer ()); |
| m_errors->printMessages (m_commandLineParser->muteStdout ()); |
| if ((!status) || container[i]->getErrorContainer ()->hasFatalErrors ()) |
| return false; |
| |
| } |
| } |
| #endif |
| } |
| else |
| { |
| // Custom Thread management |
| |
| // Optimize the load balance, try to even out the work in each thread by the size of the files |
| std::vector<std::vector < CompileSourceFile*>> jobArray (maxThreadCount); |
| |
| std::vector<unsigned long> jobSize(maxThreadCount); |
| |
| for (unsigned short i = 0; i < maxThreadCount; i++) |
| jobSize[i] = 0; |
| |
| for (unsigned int i = 0; i < container.size (); i++) |
| { |
| unsigned int size = container[i]->getJobSize(action); |
| unsigned int newJobIndex = 0; |
| unsigned long minJobQueue = ULLONG_MAX; |
| for (unsigned short ii = 0; ii < maxThreadCount; ii++) |
| { |
| if (jobSize[ii] < minJobQueue) |
| { |
| newJobIndex = ii; |
| minJobQueue = jobSize[ii]; |
| } |
| } |
| |
| jobSize[newJobIndex] += size; |
| jobArray[newJobIndex].push_back (container[i]); |
| |
| } |
| |
| if (getCommandLineParser ()->profile()) |
| { |
| if(action == CompileSourceFile::Preprocess) |
| std::cout << "Preprocessing task\n"; |
| else if(action == CompileSourceFile::Parse) |
| std::cout << "Parsing task\n"; |
| else |
| std::cout << "Misc Task\n"; |
| for (unsigned short i = 0; i < maxThreadCount; i++) |
| { |
| |
| std::cout << "Thread " << i << " : \n"; |
| int sum = 0; |
| for (unsigned int j = 0; j < jobArray[i].size (); j++) |
| { |
| std::string fileName; |
| if (jobArray[i][j]->getPreprocessor ()) |
| fileName = jobArray[i][j]->getPreprocessor ()->getFileName (0); |
| if (jobArray[i][j]->getParser ()) |
| fileName = jobArray[i][j]->getParser ()->getFileName (0); |
| sum += jobArray[i][j]->getJobSize (action); |
| std::cout << jobArray[i][j]->getJobSize (action) << " " << fileName << "\n"; |
| } |
| std::cout << ", Total: " << sum << std::endl << std::flush; |
| } |
| } |
| |
| // Create the threads with their respective workloads |
| std::vector<std::thread*> threads; |
| for (unsigned short i = 0; i < maxThreadCount; i++) |
| { |
| std::thread* th = new std::thread ([ = ]{ |
| |
| for (unsigned int j = 0; j < jobArray[i].size(); j++) |
| { |
| if (getCommandLineParser ()->pythonListener () |
| || getCommandLineParser ()->pythonEvalScriptPerFile ()) |
| { |
| PyThreadState* interpState = PythonAPI::initNewInterp (); |
| jobArray[i][j]->setPythonInterp (interpState); |
| } |
| |
| jobArray[i][j]->compile(action); |
| |
| if (getCommandLineParser ()->pythonListener () |
| || getCommandLineParser ()->pythonEvalScriptPerFile ()) |
| { |
| jobArray[i][j]->shutdownPythonInterp (); |
| } |
| } |
| }); |
| threads.push_back(th); |
| } |
| |
| // Sync the threads |
| for (unsigned int th = 0; th < threads.size (); th++) |
| { |
| threads[th]->join (); |
| } |
| |
| // Delete the threads |
| for (unsigned int th = 0; th < threads.size (); th++) |
| { |
| delete threads[th]; |
| } |
| |
| // Promote report to master error container |
| bool fatalErrors = false; |
| for (unsigned int j = 0; j < container.size (); j++) |
| { |
| m_errors->appendErrors (*container[j]->getErrorContainer ()); |
| if (container[j]->getErrorContainer ()->hasFatalErrors ()) |
| fatalErrors = true; |
| } |
| m_errors->printMessages (m_commandLineParser->muteStdout ()); |
| |
| if (fatalErrors) |
| return false; |
| } |
| return true; |
| } |
| |
| bool |
| Compiler::compile () |
| { |
| |
| std::string profile; |
| Timer tmr; |
| Timer tmrTotal; |
| // Scan the libraries definition |
| if (!parseLibrariesDef_()) return false; |
| |
| if (m_commandLineParser->profile()) |
| { |
| std::string msg = "Scan libraries took " + StringUtils::to_string(tmr.elapsed_rounded ()) + "s\n"; |
| std::cout << msg << std::endl; |
| profile += msg; |
| tmr.reset(); |
| } |
| |
| // Preprocess |
| ppinit_ (); |
| if (!compileFileSet_ (CompileSourceFile::Preprocess, m_commandLineParser->fileunit (), m_compilers)) return false; |
| |
| // Single thread post Preprocess |
| if (!compileFileSet_ (CompileSourceFile::PostPreprocess, false, m_compilers)) return false; |
| |
| if (m_commandLineParser->profile()) |
| { |
| std::string msg = "Preprocessing took " + StringUtils::to_string(tmr.elapsed_rounded ()) + "s\n"; |
| std::cout << msg << std::endl; |
| profile += msg; |
| tmr.reset(); |
| } |
| |
| // Parse |
| bool parserInitialized = false; |
| if (m_commandLineParser->parse () |
| || m_commandLineParser->pythonListener () |
| || m_commandLineParser->pythonEvalScriptPerFile () |
| || m_commandLineParser->pythonEvalScript()) |
| { |
| parseinit_ (); |
| parserInitialized = true; |
| if (!compileFileSet_ (CompileSourceFile::Parse, true, m_compilers)) return false; // Small files and large file chunks |
| if (!compileFileSet_ (CompileSourceFile::Parse, true, m_compilersParentFiles)) return false; // Recombine chunks |
| } |
| |
| if (m_commandLineParser->profile()) |
| { |
| std::string msg = "Parsing took " + StringUtils::to_string(tmr.elapsed_rounded()) + "s\n"; |
| for (unsigned int i = 0; i < m_compilersParentFiles.size(); i++) |
| { |
| msg += m_compilersParentFiles[i]->getParser ()->getProfileInfo (); |
| } |
| for (unsigned int i = 0; i < m_compilers.size(); i++) |
| { |
| msg += m_compilers[i]->getParser ()->getProfileInfo (); |
| } |
| |
| std::cout << msg << std::endl; |
| profile += msg; |
| tmr.reset(); |
| } |
| |
| // Check Parsing |
| CheckCompile* checkComp = new CheckCompile (this); |
| checkComp->check (); |
| delete checkComp; |
| m_errors->printMessages (m_commandLineParser->muteStdout ()); |
| |
| // Python Listener |
| if (m_commandLineParser->pythonListener () |
| || m_commandLineParser->pythonEvalScriptPerFile ()) |
| { |
| |
| if (!parserInitialized) |
| pythoninit_ (); |
| if (!compileFileSet_ (CompileSourceFile::PythonAPI, true, m_compilers)) return false; |
| if (!compileFileSet_ (CompileSourceFile::PythonAPI, true, m_compilersParentFiles)) return false; |
| |
| if (m_commandLineParser->profile ()) |
| { |
| std::string msg = "Python file processing took " + StringUtils::to_string(tmr.elapsed_rounded ()) + "s\n"; |
| std::cout << msg << std::endl; |
| profile += msg; |
| tmr.reset(); |
| } |
| |
| } |
| |
| if (m_commandLineParser->compile()) |
| { |
| // Compile Design, has its own thread management |
| CompileDesign* compileDesign = new CompileDesign (this); |
| compileDesign->compile (); |
| m_errors->printMessages (m_commandLineParser->muteStdout ()); |
| |
| if (m_commandLineParser->profile ()) |
| { |
| std::string msg = "Compilation took " + StringUtils::to_string (tmr.elapsed_rounded ()) + "s\n"; |
| std::cout << msg << std::endl; |
| profile += msg; |
| tmr.reset (); |
| } |
| |
| if (m_commandLineParser->elaborate ()) |
| { |
| compileDesign->elaborate (); |
| m_errors->printMessages (m_commandLineParser->muteStdout ()); |
| |
| if (m_commandLineParser->profile ()) |
| { |
| std::string msg = "Elaboration took " + StringUtils::to_string (tmr.elapsed_rounded ()) + "s\n"; |
| std::cout << msg << std::endl; |
| profile += msg; |
| tmr.reset (); |
| } |
| |
| if (m_commandLineParser->pythonEvalScript ()) |
| { |
| PythonAPI::evalScript (m_commandLineParser->getSymbolTable ()->getSymbol (m_commandLineParser->pythonEvalScriptId ()), |
| m_design); |
| if (m_commandLineParser->profile ()) |
| { |
| std::string msg = "Python design processing took " + StringUtils::to_string (tmr.elapsed_rounded ()) + "s\n"; |
| profile += msg; |
| std::cout << msg << std::endl; |
| tmr.reset (); |
| } |
| } |
| m_errors->printMessages (m_commandLineParser->muteStdout ()); |
| } |
| |
| |
| delete compileDesign; |
| } |
| if (m_commandLineParser->profile ()) |
| { |
| std::string msg = "Total time " + StringUtils::to_string (tmrTotal.elapsed_rounded ()) + "s\n"; |
| profile += msg; |
| profile = std::string ("==============\n") + "PROFILE\n" + std::string ("==============\n") + profile + "==============\n"; |
| std::cout << profile << std::endl; |
| m_errors->printToLogFile (profile); |
| } |
| return true; |
| } |
| |
| void |
| Compiler::registerAntlrPpHandlerForId (SymbolId id, PreprocessFile::AntlrParserHandler* pp) |
| { |
| std::map<SymbolId, PreprocessFile::AntlrParserHandler*>::iterator itr = m_antlrPpMap.find (id); |
| if (itr != m_antlrPpMap.end ()) |
| { |
| delete (*itr).second; |
| m_antlrPpMap.erase (itr); |
| m_antlrPpMap.insert (std::make_pair (id, pp)); |
| return; |
| } |
| m_antlrPpMap.insert (std::make_pair (id, pp)); |
| } |
| |
| PreprocessFile::AntlrParserHandler* |
| Compiler::getAntlrPpHandlerForId (SymbolId id) |
| { |
| std::map<SymbolId, PreprocessFile::AntlrParserHandler*>::iterator itr = m_antlrPpMap.find (id); |
| if (itr != m_antlrPpMap.end ()) |
| { |
| PreprocessFile::AntlrParserHandler* ptr = (*itr).second; |
| return ptr; |
| } |
| return NULL; |
| } |
| |
| bool Compiler::parseLibrariesDef_() { |
| m_librarySet = new LibrarySet(); |
| m_configSet = new ConfigSet(); |
| m_design = new Design (this, m_librarySet, m_configSet); |
| ParseLibraryDef* libParser = new ParseLibraryDef(m_commandLineParser,m_errors,m_symbolTable,m_librarySet, m_configSet); |
| return libParser->parseLibrariesDefinition (); |
| } |
| |
| |
