| //===--- CodeGenAction.cpp - LLVM Code Generation Frontend Action ---------===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "clang/CodeGen/CodeGenAction.h" | |
| #include "BackendConsumer.h" | |
| #include "CGCall.h" | |
| #include "CodeGenModule.h" | |
| #include "CoverageMappingGen.h" | |
| #include "MacroPPCallbacks.h" | |
| #include "clang/AST/ASTConsumer.h" | |
| #include "clang/AST/ASTContext.h" | |
| #include "clang/AST/DeclCXX.h" | |
| #include "clang/AST/DeclGroup.h" | |
| #include "clang/Basic/DiagnosticFrontend.h" | |
| #include "clang/Basic/FileManager.h" | |
| #include "clang/Basic/LangStandard.h" | |
| #include "clang/Basic/SourceManager.h" | |
| #include "clang/Basic/TargetInfo.h" | |
| #include "clang/CodeGen/BackendUtil.h" | |
| #include "clang/CodeGen/ModuleBuilder.h" | |
| #include "clang/Driver/DriverDiagnostic.h" | |
| #include "clang/Frontend/CompilerInstance.h" | |
| #include "clang/Frontend/MultiplexConsumer.h" | |
| #include "clang/Lex/Preprocessor.h" | |
| #include "clang/Serialization/ASTWriter.h" | |
| #include "llvm/ADT/ScopeExit.h" | |
| #include "llvm/Bitcode/BitcodeReader.h" | |
| #include "llvm/IR/DebugInfo.h" | |
| #include "llvm/IR/DiagnosticInfo.h" | |
| #include "llvm/IR/GlobalValue.h" | |
| #include "llvm/IR/LLVMContext.h" | |
| #include "llvm/IR/LLVMRemarkStreamer.h" | |
| #include "llvm/IR/Module.h" | |
| #include "llvm/IR/PassTimingInfo.h" | |
| #include "llvm/IR/Verifier.h" | |
| #include "llvm/IRReader/IRReader.h" | |
| #include "llvm/LTO/LTOBackend.h" | |
| #include "llvm/Pass.h" | |
| #include "llvm/Support/LibraryOptionsContext.h" | |
| #include "llvm/Support/ManagedStatic.h" | |
| #include "llvm/Support/MemoryBuffer.h" | |
| #include "llvm/Support/Mutex.h" | |
| #include "llvm/Support/SourceMgr.h" | |
| #include "llvm/Support/TimeProfiler.h" | |
| #include "llvm/Support/Timer.h" | |
| #include "llvm/Support/ToolOutputFile.h" | |
| #include "llvm/Transforms/Utils/Cloning.h" | |
| #include <optional> | |
| using namespace clang; | |
| using namespace llvm; | |
| #define DEBUG_TYPE "codegenaction" | |
| namespace { | |
| llvm::ManagedStatic<llvm::sys::SmartMutex<true>> TimePassesMutex; | |
| } | |
| namespace clang { | |
| static void reportOptRecordError(Error E, DiagnosticsEngine &Diags, | |
| const CodeGenOptions &CodeGenOpts) { | |
| handleAllErrors( | |
| std::move(E), | |
| [&](const LLVMRemarkSetupFileError &E) { | |
| Diags.Report(diag::err_cannot_open_file) | |
| << CodeGenOpts.OptRecordFile << E.message(); | |
| }, | |
| [&](const LLVMRemarkSetupPatternError &E) { | |
| Diags.Report(diag::err_drv_optimization_remark_pattern) | |
| << E.message() << CodeGenOpts.OptRecordPasses; | |
| }, | |
| [&](const LLVMRemarkSetupFormatError &E) { | |
| Diags.Report(diag::err_drv_optimization_remark_format) | |
| << CodeGenOpts.OptRecordFormat; | |
| }); | |
| } | |
| BackendConsumer::BackendConsumer(CompilerInstance &CI, BackendAction Action, | |
| IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS, | |
| LLVMContext &C, | |
| SmallVector<LinkModule, 4> LinkModules, | |
| StringRef InFile, | |
| std::unique_ptr<raw_pwrite_stream> OS, | |
| CoverageSourceInfo *CoverageInfo, | |
| llvm::Module *CurLinkModule) | |
| : CI(CI), Diags(CI.getDiagnostics()), CodeGenOpts(CI.getCodeGenOpts()), | |
| TargetOpts(CI.getTargetOpts()), LangOpts(CI.getLangOpts()), | |
| AsmOutStream(std::move(OS)), FS(VFS), Action(Action), | |
| Gen(CreateLLVMCodeGen(CI, InFile, C, CoverageInfo)), | |
| LinkModules(std::move(LinkModules)), DiagConsumer(Diags, CodeGenOpts) { | |
| DiagConsumer.setCurLinkModule(CurLinkModule); | |
| TimerIsEnabled = CodeGenOpts.TimePasses; | |
| { | |
| llvm::sys::SmartScopedLock<true> Lock(*TimePassesMutex); | |
| llvm::TimePassesIsEnabled = CodeGenOpts.TimePasses; | |
| llvm::TimePassesPerRun = CodeGenOpts.TimePassesPerRun; | |
| } | |
| if (CodeGenOpts.TimePasses) | |
| LLVMIRGeneration.init("irgen", "LLVM IR generation", CI.getTimerGroup()); | |
| } | |
| llvm::Module* BackendConsumer::getModule() const { | |
| return Gen->GetModule(); | |
| } | |
| std::unique_ptr<llvm::Module> BackendConsumer::takeModule() { | |
| return std::unique_ptr<llvm::Module>(Gen->ReleaseModule()); | |
| } | |
| CodeGenerator* BackendConsumer::getCodeGenerator() { | |
| return Gen.get(); | |
| } | |
| void BackendConsumer::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { | |
| Gen->HandleCXXStaticMemberVarInstantiation(VD); | |
| } | |
| void BackendConsumer::Initialize(ASTContext &Ctx) { | |
| assert(!Context && "initialized multiple times"); | |
| Context = &Ctx; | |
| DiagConsumer.setSourceManager(&Ctx.getSourceManager()); | |
| if (TimerIsEnabled) | |
| LLVMIRGeneration.startTimer(); | |
| Gen->Initialize(Ctx); | |
| if (TimerIsEnabled) | |
| LLVMIRGeneration.stopTimer(); | |
| } | |
| bool BackendConsumer::HandleTopLevelDecl(DeclGroupRef D) { | |
| PrettyStackTraceDecl CrashInfo(*D.begin(), SourceLocation(), | |
| Context->getSourceManager(), | |
| "LLVM IR generation of declaration"); | |
| // Recurse. | |
| if (TimerIsEnabled && !LLVMIRGenerationRefCount++) | |
| CI.getFrontendTimer().yieldTo(LLVMIRGeneration); | |
| Gen->HandleTopLevelDecl(D); | |
| if (TimerIsEnabled && !--LLVMIRGenerationRefCount) | |
| LLVMIRGeneration.yieldTo(CI.getFrontendTimer()); | |
| return true; | |
| } | |
| void BackendConsumer::HandleInlineFunctionDefinition(FunctionDecl *D) { | |
| PrettyStackTraceDecl CrashInfo(D, SourceLocation(), | |
| Context->getSourceManager(), | |
| "LLVM IR generation of inline function"); | |
| if (TimerIsEnabled) | |
| CI.getFrontendTimer().yieldTo(LLVMIRGeneration); | |
| Gen->HandleInlineFunctionDefinition(D); | |
| if (TimerIsEnabled) | |
| LLVMIRGeneration.yieldTo(CI.getFrontendTimer()); | |
| } | |
| void BackendConsumer::HandleInterestingDecl(DeclGroupRef D) { | |
| HandleTopLevelDecl(D); | |
| } | |
| // Links each entry in LinkModules into our module. Returns true on error. | |
| bool BackendConsumer::LinkInModules(llvm::Module *M) { | |
| // Builtin bitcode is internalized into the module that links it, so each | |
| // PTU of an incremental session needs its own copy. Plain bitcode files are | |
| // still linked once. | |
| if (LangOpts.IncrementalExtensions && LinkModules.empty() && | |
| loadLinkModules(CI, M->getContext(), LinkModules, | |
| /*OnlyInternalized=*/true)) | |
| return true; | |
| return linkInModules(*M, LinkModules, CodeGenOpts, LangOpts, TargetOpts, | |
| DiagConsumer); | |
| } | |
| void BackendConsumer::HandleTranslationUnit(ASTContext &C) { | |
| { | |
| llvm::TimeTraceScope TimeScope("Frontend"); | |
| PrettyStackTraceString CrashInfo("Per-file LLVM IR generation"); | |
| if (TimerIsEnabled && !LLVMIRGenerationRefCount++) | |
| CI.getFrontendTimer().yieldTo(LLVMIRGeneration); | |
| Gen->HandleTranslationUnit(C); | |
| if (TimerIsEnabled && !--LLVMIRGenerationRefCount) | |
| LLVMIRGeneration.yieldTo(CI.getFrontendTimer()); | |
| } | |
| // Silently ignore if we weren't initialized for some reason. | |
| if (!getModule()) | |
| return; | |
| LLVMContext &Ctx = getModule()->getContext(); | |
| std::unique_ptr<DiagnosticHandler> OldDiagnosticHandler = | |
| Ctx.getDiagnosticHandler(); | |
| llvm::scope_exit RestoreDiagnosticHandler( | |
| [&]() { Ctx.setDiagnosticHandler(std::move(OldDiagnosticHandler)); }); | |
| Ctx.setDiagnosticHandler(createDiagnosticHandler()); | |
| Ctx.setDefaultTargetCPU(TargetOpts.CPU); | |
| Ctx.setDefaultTargetFeatures(llvm::join(TargetOpts.Features, ",")); | |
| Ctx.setVirtualFileSystem(CI.getVirtualFileSystemPtr()); | |
| Expected<LLVMRemarkFileHandle> OptRecordFileOrErr = | |
| setupLLVMOptimizationRemarks( | |
| Ctx, CodeGenOpts.OptRecordFile, CodeGenOpts.OptRecordPasses, | |
| CodeGenOpts.OptRecordFormat, CodeGenOpts.DiagnosticsWithHotness, | |
| CodeGenOpts.DiagnosticsHotnessThreshold); | |
| if (Error E = OptRecordFileOrErr.takeError()) { | |
| reportOptRecordError(std::move(E), Diags, CodeGenOpts); | |
| return; | |
| } | |
| LLVMRemarkFileHandle OptRecordFile = std::move(*OptRecordFileOrErr); | |
| if (OptRecordFile && CodeGenOpts.getProfileUse() != | |
| llvm::driver::ProfileInstrKind::ProfileNone) | |
| Ctx.setDiagnosticsHotnessRequested(true); | |
| if (CodeGenOpts.MisExpect) { | |
| Ctx.setMisExpectWarningRequested(true); | |
| } | |
| if (CodeGenOpts.DiagnosticsMisExpectTolerance) { | |
| Ctx.setDiagnosticsMisExpectTolerance( | |
| CodeGenOpts.DiagnosticsMisExpectTolerance); | |
| } | |
| // Link each LinkModule into our module. | |
| if (!CodeGenOpts.LinkBitcodePostopt && LinkInModules(getModule())) | |
| return; | |
| for (auto &F : getModule()->functions()) { | |
| if (const Decl *FD = Gen->GetDeclForMangledName(F.getName())) { | |
| auto Loc = FD->getASTContext().getFullLoc(FD->getLocation()); | |
| DiagConsumer.addFunctionSourceLocation(F.getName(), Loc); | |
| } | |
| } | |
| if (CodeGenOpts.ClearASTBeforeBackend) { | |
| LLVM_DEBUG(llvm::dbgs() << "Clearing AST...\n"); | |
| // Access to the AST is no longer available after this. | |
| // Other things that the ASTContext manages are still available, e.g. | |
| // the SourceManager. It'd be nice if we could separate out all the | |
| // things in ASTContext used after this point and null out the | |
| // ASTContext, but too many various parts of the ASTContext are still | |
| // used in various parts. | |
| C.cleanup(); | |
| C.getAllocator().Reset(); | |
| } | |
| EmbedBitcode(getModule(), CodeGenOpts, llvm::MemoryBufferRef()); | |
| emitBackendOutput(CI, CI.getCodeGenOpts(), getModule(), Action, FS, | |
| std::move(AsmOutStream), this); | |
| if (OptRecordFile) | |
| OptRecordFile->keep(); | |
| } | |
| void BackendConsumer::HandleTagDeclDefinition(TagDecl *D) { | |
| PrettyStackTraceDecl CrashInfo(D, SourceLocation(), | |
| Context->getSourceManager(), | |
| "LLVM IR generation of declaration"); | |
| Gen->HandleTagDeclDefinition(D); | |
| } | |
| void BackendConsumer::HandleTagDeclRequiredDefinition(const TagDecl *D) { | |
| Gen->HandleTagDeclRequiredDefinition(D); | |
| } | |
| void BackendConsumer::CompleteTentativeDefinition(VarDecl *D) { | |
| Gen->CompleteTentativeDefinition(D); | |
| } | |
| void BackendConsumer::CompleteExternalDeclaration(DeclaratorDecl *D) { | |
| Gen->CompleteExternalDeclaration(D); | |
| } | |
| void BackendConsumer::AssignInheritanceModel(CXXRecordDecl *RD) { | |
| Gen->AssignInheritanceModel(RD); | |
| } | |
| void BackendConsumer::HandleVTable(CXXRecordDecl *RD) { | |
| Gen->HandleVTable(RD); | |
| } | |
| void BackendConsumer::anchor() { } | |
| } // namespace clang | |
| std::unique_ptr<llvm::DiagnosticHandler> | |
| BackendConsumer::createDiagnosticHandler() { | |
| return DiagConsumer.createDiagnosticHandler(); | |
| } | |
| CodeGenAction::CodeGenAction(unsigned _Act, LLVMContext *_VMContext) | |
| : Act(_Act), VMContext(_VMContext ? _VMContext : new LLVMContext), | |
| OwnsVMContext(!_VMContext) {} | |
| CodeGenAction::~CodeGenAction() { | |
| TheModule.reset(); | |
| if (OwnsVMContext) | |
| delete VMContext; | |
| } | |
| bool CodeGenAction::hasIRSupport() const { return true; } | |
| void CodeGenAction::EndSourceFileAction() { | |
| ASTFrontendAction::EndSourceFileAction(); | |
| // If the consumer creation failed, do nothing. | |
| if (!getCompilerInstance().hasASTConsumer()) | |
| return; | |
| // Steal the module from the consumer. | |
| TheModule = BEConsumer->takeModule(); | |
| } | |
| std::unique_ptr<llvm::Module> CodeGenAction::takeModule() { | |
| return std::move(TheModule); | |
| } | |
| llvm::LLVMContext *CodeGenAction::takeLLVMContext() { | |
| OwnsVMContext = false; | |
| return VMContext; | |
| } | |
| CodeGenerator *CodeGenAction::getCodeGenerator() const { | |
| return BEConsumer->getCodeGenerator(); | |
| } | |
| bool CodeGenAction::BeginSourceFileAction(CompilerInstance &CI) { | |
| VMContext->getLibraryOptions().assign(CI.getLibraryOptions()); | |
| if (CI.getFrontendOpts().GenReducedBMI) | |
| CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface); | |
| return ASTFrontendAction::BeginSourceFileAction(CI); | |
| } | |
| static std::unique_ptr<raw_pwrite_stream> | |
| GetOutputStream(CompilerInstance &CI, StringRef InFile, BackendAction Action) { | |
| switch (Action) { | |
| case Backend_EmitAssembly: | |
| return CI.createDefaultOutputFile(false, InFile, "s"); | |
| case Backend_EmitLL: | |
| return CI.createDefaultOutputFile(false, InFile, "ll"); | |
| case Backend_EmitBC: | |
| return CI.createDefaultOutputFile(true, InFile, "bc"); | |
| case Backend_EmitNothing: | |
| return nullptr; | |
| case Backend_EmitMCNull: | |
| return CI.createNullOutputFile(); | |
| case Backend_EmitObj: | |
| return CI.createDefaultOutputFile(true, InFile, "o"); | |
| } | |
| llvm_unreachable("Invalid action!"); | |
| } | |
| std::unique_ptr<ASTConsumer> | |
| CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) { | |
| BackendAction BA = static_cast<BackendAction>(Act); | |
| std::unique_ptr<raw_pwrite_stream> OS = CI.takeOutputStream(); | |
| if (!OS) | |
| OS = GetOutputStream(CI, InFile, BA); | |
| if (BA != Backend_EmitNothing && !OS) | |
| return nullptr; | |
| // Load bitcode modules to link with, if we need to. | |
| if (clang::loadLinkModules(CI, *VMContext, LinkModules, | |
| /*OnlyInternalized=*/false)) | |
| return nullptr; | |
| CoverageSourceInfo *CoverageInfo = nullptr; | |
| // Add the preprocessor callback only when the coverage mapping is generated. | |
| if (CI.getCodeGenOpts().CoverageMapping) | |
| CoverageInfo = CodeGen::CoverageMappingModuleGen::setUpCoverageCallbacks( | |
| CI.getPreprocessor()); | |
| std::unique_ptr<BackendConsumer> Result(new BackendConsumer( | |
| CI, BA, CI.getVirtualFileSystemPtr(), *VMContext, std::move(LinkModules), | |
| InFile, std::move(OS), CoverageInfo)); | |
| BEConsumer = Result.get(); | |
| // Enable generating macro debug info only when debug info is not disabled and | |
| // also macro debug info is enabled. | |
| if (CI.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo && | |
| CI.getCodeGenOpts().MacroDebugInfo) { | |
| std::unique_ptr<PPCallbacks> Callbacks = | |
| std::make_unique<MacroPPCallbacks>(BEConsumer->getCodeGenerator(), | |
| CI.getPreprocessor()); | |
| CI.getPreprocessor().addPPCallbacks(std::move(Callbacks)); | |
| } | |
| if (CI.getFrontendOpts().GenReducedBMI && | |
| !CI.getFrontendOpts().ModuleOutputPath.empty()) { | |
| std::vector<std::unique_ptr<ASTConsumer>> Consumers(2); | |
| Consumers[0] = std::make_unique<ReducedBMIGenerator>( | |
| CI.getPreprocessor(), CI.getModuleCache(), | |
| CI.getFrontendOpts().ModuleOutputPath, CI.getCodeGenOpts()); | |
| Consumers[1] = std::move(Result); | |
| return std::make_unique<MultiplexConsumer>(std::move(Consumers)); | |
| } | |
| return std::move(Result); | |
| } | |
| std::unique_ptr<llvm::Module> | |
| CodeGenAction::loadModule(MemoryBufferRef MBRef) { | |
| CompilerInstance &CI = getCompilerInstance(); | |
| SourceManager &SM = CI.getSourceManager(); | |
| auto DiagErrors = [&](Error E) -> std::unique_ptr<llvm::Module> { | |
| unsigned DiagID = | |
| CI.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, "%0"); | |
| handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) { | |
| CI.getDiagnostics().Report(DiagID) << EIB.message(); | |
| }); | |
| return {}; | |
| }; | |
| // For ThinLTO backend invocations, ensure that the context | |
| // merges types based on ODR identifiers. We also need to read | |
| // the correct module out of a multi-module bitcode file. | |
| if (!CI.getCodeGenOpts().ThinLTOIndexFile.empty()) { | |
| VMContext->enableDebugTypeODRUniquing(); | |
| Expected<std::vector<BitcodeModule>> BMsOrErr = getBitcodeModuleList(MBRef); | |
| if (!BMsOrErr) | |
| return DiagErrors(BMsOrErr.takeError()); | |
| BitcodeModule *Bm = llvm::lto::findThinLTOModule(*BMsOrErr); | |
| // We have nothing to do if the file contains no ThinLTO module. This is | |
| // possible if ThinLTO compilation was not able to split module. Content of | |
| // the file was already processed by indexing and will be passed to the | |
| // linker using merged object file. | |
| if (!Bm) { | |
| auto M = std::make_unique<llvm::Module>("empty", *VMContext); | |
| M->setTargetTriple(Triple(CI.getTargetOpts().Triple)); | |
| return M; | |
| } | |
| Expected<std::unique_ptr<llvm::Module>> MOrErr = | |
| Bm->parseModule(*VMContext); | |
| if (!MOrErr) | |
| return DiagErrors(MOrErr.takeError()); | |
| return std::move(*MOrErr); | |
| } | |
| // Load bitcode modules to link with, if we need to. | |
| if (clang::loadLinkModules(CI, *VMContext, LinkModules, | |
| /*OnlyInternalized=*/false)) | |
| return nullptr; | |
| // Handle textual IR and bitcode file with one single module. | |
| llvm::SMDiagnostic Err; | |
| if (std::unique_ptr<llvm::Module> M = parseIR(MBRef, Err, *VMContext)) { | |
| // For LLVM IR files, always verify the input and report the error in a way | |
| // that does not ask people to report an issue for it. | |
| std::string VerifierErr; | |
| raw_string_ostream VerifierErrStream(VerifierErr); | |
| if (llvm::verifyModule(*M, &VerifierErrStream)) { | |
| CI.getDiagnostics().Report(diag::err_invalid_llvm_ir) << VerifierErr; | |
| return {}; | |
| } | |
| return M; | |
| } | |
| // If MBRef is a bitcode with multiple modules (e.g., -fsplit-lto-unit | |
| // output), place the extra modules (actually only one, a regular LTO module) | |
| // into LinkModules as if we are using -mlink-bitcode-file. | |
| Expected<std::vector<BitcodeModule>> BMsOrErr = getBitcodeModuleList(MBRef); | |
| if (BMsOrErr && BMsOrErr->size()) { | |
| std::unique_ptr<llvm::Module> FirstM; | |
| for (auto &BM : *BMsOrErr) { | |
| Expected<std::unique_ptr<llvm::Module>> MOrErr = | |
| BM.parseModule(*VMContext); | |
| if (!MOrErr) | |
| return DiagErrors(MOrErr.takeError()); | |
| if (FirstM) | |
| LinkModules.push_back({std::move(*MOrErr), /*PropagateAttrs=*/false, | |
| /*Internalize=*/false, /*LinkFlags=*/{}}); | |
| else | |
| FirstM = std::move(*MOrErr); | |
| } | |
| if (FirstM) | |
| return FirstM; | |
| } | |
| // If BMsOrErr fails, consume the error and use the error message from | |
| // parseIR. | |
| consumeError(BMsOrErr.takeError()); | |
| // Translate from the diagnostic info to the SourceManager location if | |
| // available. | |
| // TODO: Unify this with ConvertBackendLocation() | |
| SourceLocation Loc; | |
| if (Err.getLineNo() > 0) { | |
| assert(Err.getColumnNo() >= 0); | |
| Loc = SM.translateFileLineCol(SM.getFileEntryForID(SM.getMainFileID()), | |
| Err.getLineNo(), Err.getColumnNo() + 1); | |
| } | |
| // Strip off a leading diagnostic code if there is one. | |
| StringRef Msg = Err.getMessage(); | |
| Msg.consume_front("error: "); | |
| unsigned DiagID = | |
| CI.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, "%0"); | |
| CI.getDiagnostics().Report(Loc, DiagID) << Msg; | |
| return {}; | |
| } | |
| void CodeGenAction::ExecuteAction() { | |
| if (getCurrentFileKind().getLanguage() != Language::LLVM_IR) { | |
| this->ASTFrontendAction::ExecuteAction(); | |
| return; | |
| } | |
| // If this is an IR file, we have to treat it specially. | |
| BackendAction BA = static_cast<BackendAction>(Act); | |
| CompilerInstance &CI = getCompilerInstance(); | |
| auto &CodeGenOpts = CI.getCodeGenOpts(); | |
| auto &Diagnostics = CI.getDiagnostics(); | |
| std::unique_ptr<raw_pwrite_stream> OS = | |
| GetOutputStream(CI, getCurrentFileOrBufferName(), BA); | |
| if (BA != Backend_EmitNothing && !OS) | |
| return; | |
| SourceManager &SM = CI.getSourceManager(); | |
| FileID FID = SM.getMainFileID(); | |
| std::optional<MemoryBufferRef> MainFile = SM.getBufferOrNone(FID); | |
| if (!MainFile) | |
| return; | |
| TheModule = loadModule(*MainFile); | |
| if (!TheModule) | |
| return; | |
| const TargetOptions &TargetOpts = CI.getTargetOpts(); | |
| if (TheModule->getTargetTriple().str() != TargetOpts.Triple) { | |
| Diagnostics.Report(SourceLocation(), diag::warn_fe_override_module) | |
| << TargetOpts.Triple; | |
| TheModule->setTargetTriple(Triple(TargetOpts.Triple)); | |
| } | |
| llvm::ExceptionHandling ExceptionModel = | |
| CodeGenOptions::toExceptionHandling(CodeGenOpts.getExceptionHandling()); | |
| if (ExceptionModel != llvm::ExceptionHandling::Default) { | |
| StringRef ModelName = llvm::getExceptionModelName(ExceptionModel); | |
| if (auto *Existing = cast_or_null<llvm::MDString>( | |
| TheModule->getModuleFlag("exception-model"))) { | |
| if (Existing->getString() != ModelName) { | |
| Diagnostics.Report(diag::err_fe_exception_model_mismatch) | |
| << ModelName << Existing->getString(); | |
| return; | |
| } | |
| } else { | |
| TheModule->addModuleFlag( | |
| llvm::Module::Error, "exception-model", | |
| llvm::MDString::get(TheModule->getContext(), ModelName)); | |
| } | |
| } | |
| EmbedObject(TheModule.get(), CodeGenOpts, CI.getVirtualFileSystem(), | |
| Diagnostics); | |
| EmbedBitcode(TheModule.get(), CodeGenOpts, *MainFile); | |
| LLVMContext &Ctx = TheModule->getContext(); | |
| // Restore any diagnostic handler previously set before returning from this | |
| // function. | |
| struct RAII { | |
| LLVMContext &Ctx; | |
| std::unique_ptr<DiagnosticHandler> PrevHandler = Ctx.getDiagnosticHandler(); | |
| ~RAII() { Ctx.setDiagnosticHandler(std::move(PrevHandler)); } | |
| } _{Ctx}; | |
| // Set clang diagnostic handler. To do this we need to create a fake | |
| // BackendConsumer. | |
| BackendConsumer Result(CI, BA, CI.getVirtualFileSystemPtr(), *VMContext, | |
| std::move(LinkModules), "", nullptr, nullptr, | |
| TheModule.get()); | |
| // Link in each pending link module. | |
| if (!CodeGenOpts.LinkBitcodePostopt && Result.LinkInModules(&*TheModule)) | |
| return; | |
| // Textual IR needs value names while parsing; discard new names afterwards. | |
| Ctx.setDiscardValueNames(CodeGenOpts.DiscardValueNames); | |
| Ctx.setDiagnosticHandler(Result.createDiagnosticHandler()); | |
| Ctx.setDefaultTargetCPU(TargetOpts.CPU); | |
| Ctx.setDefaultTargetFeatures(llvm::join(TargetOpts.Features, ",")); | |
| Ctx.setVirtualFileSystem(CI.getVirtualFileSystemPtr()); | |
| Expected<LLVMRemarkFileHandle> OptRecordFileOrErr = | |
| setupLLVMOptimizationRemarks( | |
| Ctx, CodeGenOpts.OptRecordFile, CodeGenOpts.OptRecordPasses, | |
| CodeGenOpts.OptRecordFormat, CodeGenOpts.DiagnosticsWithHotness, | |
| CodeGenOpts.DiagnosticsHotnessThreshold); | |
| if (Error E = OptRecordFileOrErr.takeError()) { | |
| reportOptRecordError(std::move(E), Diagnostics, CodeGenOpts); | |
| return; | |
| } | |
| LLVMRemarkFileHandle OptRecordFile = std::move(*OptRecordFileOrErr); | |
| emitBackendOutput(CI, CI.getCodeGenOpts(), TheModule.get(), BA, | |
| CI.getFileManager().getVirtualFileSystemPtr(), | |
| std::move(OS)); | |
| if (OptRecordFile) | |
| OptRecordFile->keep(); | |
| } | |
| // | |
| void EmitAssemblyAction::anchor() { } | |
| EmitAssemblyAction::EmitAssemblyAction(llvm::LLVMContext *_VMContext) | |
| : CodeGenAction(Backend_EmitAssembly, _VMContext) {} | |
| void EmitBCAction::anchor() { } | |
| EmitBCAction::EmitBCAction(llvm::LLVMContext *_VMContext) | |
| : CodeGenAction(Backend_EmitBC, _VMContext) {} | |
| void EmitLLVMAction::anchor() { } | |
| EmitLLVMAction::EmitLLVMAction(llvm::LLVMContext *_VMContext) | |
| : CodeGenAction(Backend_EmitLL, _VMContext) {} | |
| void EmitLLVMOnlyAction::anchor() { } | |
| EmitLLVMOnlyAction::EmitLLVMOnlyAction(llvm::LLVMContext *_VMContext) | |
| : CodeGenAction(Backend_EmitNothing, _VMContext) {} | |
| void EmitCodeGenOnlyAction::anchor() { } | |
| EmitCodeGenOnlyAction::EmitCodeGenOnlyAction(llvm::LLVMContext *_VMContext) | |
| : CodeGenAction(Backend_EmitMCNull, _VMContext) {} | |
| void EmitObjAction::anchor() { } | |
| EmitObjAction::EmitObjAction(llvm::LLVMContext *_VMContext) | |
| : CodeGenAction(Backend_EmitObj, _VMContext) {} |