Backend::Backend(clang::DiagnosticsEngine *DiagEngine,
const clang::CodeGenOptions &CodeGenOpts,
const clang::TargetOptions &TargetOpts,
PragmaList *Pragmas,
llvm::raw_ostream *OS,
Slang::OutputType OT)
: ASTConsumer(),
mTargetOpts(TargetOpts),
mpModule(NULL),
mpOS(OS),
mOT(OT),
mGen(NULL),
mPerFunctionPasses(NULL),
mPerModulePasses(NULL),
mCodeGenPasses(NULL),
mLLVMContext(llvm::getGlobalContext()),
mDiagEngine(*DiagEngine),
mCodeGenOpts(CodeGenOpts),
mPragmas(Pragmas) {
FormattedOutStream.setStream(*mpOS,
llvm::formatted_raw_ostream::PRESERVE_STREAM);
mGen = CreateLLVMCodeGen(mDiagEngine, "", mCodeGenOpts,
mTargetOpts, mLLVMContext);
return;
}
std::unique_ptr<CodeGenerator> BuildCodeGen(CompilerInstance &CI,
llvm::LLVMContext &LLVMCtx) {
StringRef ModuleName("$__module");
return std::unique_ptr<CodeGenerator>(CreateLLVMCodeGen(
CI.getDiagnostics(), ModuleName, CI.getHeaderSearchOpts(),
CI.getPreprocessorOpts(), CI.getCodeGenOpts(), LLVMCtx));
}
IncrementalParser::IncrementalParser(Interpreter* interp, const char* llvmdir)
: m_Interpreter(interp),
m_CI(CIFactory::createCI("", interp->getOptions(), llvmdir,
m_Consumer = new cling::DeclCollector())),
m_ModuleNo(0) {
if (!m_CI) {
cling::errs() << "Compiler instance could not be created.\n";
return;
}
// Is the CompilerInstance being used to generate output only?
if (m_Interpreter->getOptions().CompilerOpts.HasOutput)
return;
if (!m_Consumer) {
cling::errs() << "No AST consumer available.\n";
return;
}
DiagnosticsEngine& Diag = m_CI->getDiagnostics();
if (m_CI->getFrontendOpts().ProgramAction != frontend::ParseSyntaxOnly) {
m_CodeGen.reset(CreateLLVMCodeGen(
Diag, makeModuleName(), m_CI->getHeaderSearchOpts(),
m_CI->getPreprocessorOpts(), m_CI->getCodeGenOpts(),
*m_Interpreter->getLLVMContext()));
}
// Initialize the DeclCollector and add callbacks keeping track of macros.
m_Consumer->Setup(this, m_CodeGen.get(), m_CI->getPreprocessor());
m_DiagConsumer.reset(new FilteringDiagConsumer(Diag, false));
initializeVirtualFile();
}
IncrementalParser::IncrementalParser(Interpreter* interp,
int argc, const char* const *argv,
const char* llvmdir):
m_Interpreter(interp),
m_DynamicLookupEnabled(false),
m_Consumer(0),
m_FirstTopLevelDecl(0),
m_LastTopLevelDecl(0),
m_SyntaxOnly(false)
{
CompilerInstance* CI
= CIFactory::createCI(llvm::MemoryBuffer::getMemBuffer("", "CLING"),
argc, argv, llvmdir);
assert(CI && "CompilerInstance is (null)!");
m_CI.reset(CI);
m_SyntaxOnly
= CI->getFrontendOpts().ProgramAction == clang::frontend::ParseSyntaxOnly;
CreateSLocOffsetGenerator();
m_Consumer = dyn_cast<ChainedConsumer>(&CI->getASTConsumer());
assert(m_Consumer && "Expected ChainedConsumer!");
// Add consumers to the ChainedConsumer, which owns them
EvaluateTSynthesizer* ES = new EvaluateTSynthesizer(interp);
ES->Attach(m_Consumer);
m_Consumer->Add(ChainedConsumer::kEvaluateTSynthesizer, ES);
DeclExtractor* DE = new DeclExtractor();
DE->Attach(m_Consumer);
m_Consumer->Add(ChainedConsumer::kDeclExtractor, DE);
ValuePrinterSynthesizer* VPS = new ValuePrinterSynthesizer(interp);
VPS->Attach(m_Consumer);
m_Consumer->Add(ChainedConsumer::kValuePrinterSynthesizer, VPS);
m_Consumer->Add(ChainedConsumer::kASTDumper, new ASTDumper());
if (!m_SyntaxOnly) {
CodeGenerator* CG = CreateLLVMCodeGen(CI->getDiagnostics(),
"cling input",
CI->getCodeGenOpts(),
/*Owned by codegen*/ * new llvm::LLVMContext()
);
assert(CG && "No CodeGen?!");
m_Consumer->Add(ChainedConsumer::kCodeGenerator, CG);
}
m_Parser.reset(new Parser(CI->getPreprocessor(), CI->getSema(),
false /*skipFuncBodies*/));
CI->getPreprocessor().EnterMainSourceFile();
// Initialize the parser after we have entered the main source file.
m_Parser->Initialize();
// Perform initialization that occurs after the parser has been initialized
// but before it parses anything. Initializes the consumers too.
CI->getSema().Initialize();
}
BackendConsumer(BackendAction action, DiagnosticsEngine &_Diags,
const CodeGenOptions &compopts,
const TargetOptions &targetopts,
const LangOptions &langopts, bool TimePasses,
const std::string &infile, llvm::Module *LinkModule,
raw_ostream *OS, LLVMContext &C)
: Diags(_Diags), Action(action), CodeGenOpts(compopts),
TargetOpts(targetopts), LangOpts(langopts), AsmOutStream(OS),
Context(), LLVMIRGeneration("LLVM IR Generation Time"),
Gen(CreateLLVMCodeGen(Diags, infile, compopts, targetopts, C)),
LinkModule(LinkModule) {
llvm::TimePassesIsEnabled = TimePasses;
}
BackendConsumer(BackendAction Action, DiagnosticsEngine &Diags,
const CodeGenOptions &CodeGenOpts,
const TargetOptions &TargetOpts,
const LangOptions &LangOpts, bool TimePasses,
const std::string &InFile, llvm::Module *LinkModule,
raw_pwrite_stream *OS, LLVMContext &C,
CoverageSourceInfo *CoverageInfo = nullptr)
: Diags(Diags), Action(Action), CodeGenOpts(CodeGenOpts),
TargetOpts(TargetOpts), LangOpts(LangOpts), AsmOutStream(OS),
Context(nullptr), LLVMIRGeneration("LLVM IR Generation Time"),
Gen(CreateLLVMCodeGen(Diags, InFile, CodeGenOpts, C, CoverageInfo)),
LinkModule(LinkModule) {
llvm::TimePassesIsEnabled = TimePasses;
}
BackendConsumer(BackendAction action, DiagnosticsEngine &_Diags,
const HeaderSearchOptions &headersearchopts,
const PreprocessorOptions &ppopts,
const CodeGenOptions &compopts,
const TargetOptions &targetopts,
const LangOptions &langopts, bool TimePasses,
const std::string &infile, llvm::Module *LinkModule,
raw_ostream *OS, LLVMContext &C,
CoverageSourceInfo *CoverageInfo = nullptr)
: Diags(_Diags), Action(action), CodeGenOpts(compopts),
TargetOpts(targetopts), LangOpts(langopts), AsmOutStream(OS),
Context(nullptr), LLVMIRGeneration("LLVM IR Generation Time"),
Gen(CreateLLVMCodeGen(Diags, infile, headersearchopts, ppopts,
compopts, C, CoverageInfo)),
LinkModule(LinkModule) {
llvm::TimePassesIsEnabled = TimePasses;
}
BackendConsumer(
BackendAction Action, DiagnosticsEngine &Diags,
const HeaderSearchOptions &HeaderSearchOpts,
const PreprocessorOptions &PPOpts, const CodeGenOptions &CodeGenOpts,
const TargetOptions &TargetOpts, const LangOptions &LangOpts,
bool TimePasses, const std::string &InFile,
const SmallVectorImpl<std::pair<unsigned, llvm::Module *>> &LinkModules,
raw_pwrite_stream *OS, LLVMContext &C,
CoverageSourceInfo *CoverageInfo = nullptr)
: Diags(Diags), Action(Action), CodeGenOpts(CodeGenOpts),
TargetOpts(TargetOpts), LangOpts(LangOpts), AsmOutStream(OS),
Context(nullptr), LLVMIRGeneration("LLVM IR Generation Time"),
Gen(CreateLLVMCodeGen(Diags, InFile, HeaderSearchOpts, PPOpts,
CodeGenOpts, C, CoverageInfo)) {
llvm::TimePassesIsEnabled = TimePasses;
for (auto &I : LinkModules)
this->LinkModules.push_back(
std::make_pair(I.first, std::unique_ptr<llvm::Module>(I.second)));
}
BackendConsumer(BackendAction Action, DiagnosticsEngine &Diags,
const HeaderSearchOptions &HeaderSearchOpts,
const PreprocessorOptions &PPOpts,
const CodeGenOptions &CodeGenOpts,
const TargetOptions &TargetOpts,
const LangOptions &LangOpts, bool TimePasses,
const std::string &InFile,
SmallVector<LinkModule, 4> LinkModules,
std::unique_ptr<raw_pwrite_stream> OS, LLVMContext &C,
CoverageSourceInfo *CoverageInfo = nullptr)
: Diags(Diags), Action(Action), HeaderSearchOpts(HeaderSearchOpts),
CodeGenOpts(CodeGenOpts), TargetOpts(TargetOpts), LangOpts(LangOpts),
AsmOutStream(std::move(OS)), Context(nullptr),
LLVMIRGeneration("irgen", "LLVM IR Generation Time"),
LLVMIRGenerationRefCount(0),
Gen(CreateLLVMCodeGen(Diags, InFile, HeaderSearchOpts, PPOpts,
CodeGenOpts, C, CoverageInfo)),
LinkModules(std::move(LinkModules)) {
llvm::TimePassesIsEnabled = TimePasses;
}
IncrementalParser::IncrementalParser(Interpreter* interp,
int argc, const char* const *argv,
const char* llvmdir):
m_Interpreter(interp), m_Consumer(0) {
CompilerInstance* CI
= CIFactory::createCI(0, argc, argv, llvmdir);
assert(CI && "CompilerInstance is (null)!");
m_Consumer = dyn_cast<DeclCollector>(&CI->getASTConsumer());
assert(m_Consumer && "Expected ChainedConsumer!");
m_Consumer->setInterpreter(interp);
m_CI.reset(CI);
if (CI->getFrontendOpts().ProgramAction != clang::frontend::ParseSyntaxOnly){
m_CodeGen.reset(CreateLLVMCodeGen(CI->getDiagnostics(), "cling input",
CI->getCodeGenOpts(),
CI->getTargetOpts(),
*m_Interpreter->getLLVMContext()
));
m_Consumer->setCodeGen(m_CodeGen.get());
}
CreateSLocOffsetGenerator();
// Add transformers to the IncrementalParser, which owns them
Sema* TheSema = &CI->getSema();
// Register the AST Transformers
m_ASTTransformers.push_back(new EvaluateTSynthesizer(TheSema));
m_ASTTransformers.push_back(new AutoSynthesizer(TheSema));
m_ASTTransformers.push_back(new ValuePrinterSynthesizer(TheSema, 0));
m_ASTTransformers.push_back(new ASTDumper());
m_ASTTransformers.push_back(new DeclExtractor(TheSema));
m_ASTTransformers.push_back(new ReturnSynthesizer(TheSema));
// Register the IR Transformers
m_IRTransformers.push_back(new IRDumper());
m_IRTransformers.push_back(new NullDerefProtectionTransformer());
}
