1 //===--- CodeGenAction.cpp - LLVM Code Generation Frontend Action ---------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "clang/CodeGen/CodeGenAction.h"
11 #include "CodeGenModule.h"
12 #include "CoverageMappingGen.h"
13 #include "MacroPPCallbacks.h"
14 #include "clang/AST/ASTConsumer.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclGroup.h"
18 #include "clang/Basic/FileManager.h"
19 #include "clang/Basic/SourceManager.h"
20 #include "clang/Basic/TargetInfo.h"
21 #include "clang/CodeGen/BackendUtil.h"
22 #include "clang/CodeGen/ModuleBuilder.h"
23 #include "clang/Frontend/CompilerInstance.h"
24 #include "clang/Frontend/FrontendDiagnostic.h"
25 #include "clang/Lex/Preprocessor.h"
26 #include "llvm/Bitcode/BitcodeReader.h"
27 #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
28 #include "llvm/IR/DebugInfo.h"
29 #include "llvm/IR/DiagnosticInfo.h"
30 #include "llvm/IR/DiagnosticPrinter.h"
31 #include "llvm/IR/GlobalValue.h"
32 #include "llvm/IR/LLVMContext.h"
33 #include "llvm/IR/Module.h"
34 #include "llvm/IRReader/IRReader.h"
35 #include "llvm/Linker/Linker.h"
36 #include "llvm/Pass.h"
37 #include "llvm/Support/MemoryBuffer.h"
38 #include "llvm/Support/SourceMgr.h"
39 #include "llvm/Support/Timer.h"
40 #include "llvm/Support/ToolOutputFile.h"
41 #include "llvm/Support/YAMLTraits.h"
42 #include "llvm/Transforms/IPO/Internalize.h"
45 using namespace clang;
49 class BackendConsumer;
50 class ClangDiagnosticHandler final : public DiagnosticHandler {
52 ClangDiagnosticHandler(const CodeGenOptions &CGOpts, BackendConsumer *BCon)
53 : CodeGenOpts(CGOpts), BackendCon(BCon) {}
55 bool handleDiagnostics(const DiagnosticInfo &DI) override;
57 bool isAnalysisRemarkEnabled(StringRef PassName) const override {
58 return (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
59 CodeGenOpts.OptimizationRemarkAnalysisPattern->match(PassName));
61 bool isMissedOptRemarkEnabled(StringRef PassName) const override {
62 return (CodeGenOpts.OptimizationRemarkMissedPattern &&
63 CodeGenOpts.OptimizationRemarkMissedPattern->match(PassName));
65 bool isPassedOptRemarkEnabled(StringRef PassName) const override {
66 return (CodeGenOpts.OptimizationRemarkPattern &&
67 CodeGenOpts.OptimizationRemarkPattern->match(PassName));
70 bool isAnyRemarkEnabled() const override {
71 return (CodeGenOpts.OptimizationRemarkAnalysisPattern ||
72 CodeGenOpts.OptimizationRemarkMissedPattern ||
73 CodeGenOpts.OptimizationRemarkPattern);
77 const CodeGenOptions &CodeGenOpts;
78 BackendConsumer *BackendCon;
81 class BackendConsumer : public ASTConsumer {
82 using LinkModule = CodeGenAction::LinkModule;
84 virtual void anchor();
85 DiagnosticsEngine &Diags;
87 const HeaderSearchOptions &HeaderSearchOpts;
88 const CodeGenOptions &CodeGenOpts;
89 const TargetOptions &TargetOpts;
90 const LangOptions &LangOpts;
91 std::unique_ptr<raw_pwrite_stream> AsmOutStream;
94 Timer LLVMIRGeneration;
95 unsigned LLVMIRGenerationRefCount;
97 /// True if we've finished generating IR. This prevents us from generating
98 /// additional LLVM IR after emitting output in HandleTranslationUnit. This
99 /// can happen when Clang plugins trigger additional AST deserialization.
100 bool IRGenFinished = false;
102 std::unique_ptr<CodeGenerator> Gen;
104 SmallVector<LinkModule, 4> LinkModules;
106 // This is here so that the diagnostic printer knows the module a diagnostic
108 llvm::Module *CurLinkModule = nullptr;
111 BackendConsumer(BackendAction Action, DiagnosticsEngine &Diags,
112 const HeaderSearchOptions &HeaderSearchOpts,
113 const PreprocessorOptions &PPOpts,
114 const CodeGenOptions &CodeGenOpts,
115 const TargetOptions &TargetOpts,
116 const LangOptions &LangOpts, bool TimePasses,
117 const std::string &InFile,
118 SmallVector<LinkModule, 4> LinkModules,
119 std::unique_ptr<raw_pwrite_stream> OS, LLVMContext &C,
120 CoverageSourceInfo *CoverageInfo = nullptr)
121 : Diags(Diags), Action(Action), HeaderSearchOpts(HeaderSearchOpts),
122 CodeGenOpts(CodeGenOpts), TargetOpts(TargetOpts), LangOpts(LangOpts),
123 AsmOutStream(std::move(OS)), Context(nullptr),
124 LLVMIRGeneration("irgen", "LLVM IR Generation Time"),
125 LLVMIRGenerationRefCount(0),
126 Gen(CreateLLVMCodeGen(Diags, InFile, HeaderSearchOpts, PPOpts,
127 CodeGenOpts, C, CoverageInfo)),
128 LinkModules(std::move(LinkModules)) {
129 llvm::TimePassesIsEnabled = TimePasses;
131 llvm::Module *getModule() const { return Gen->GetModule(); }
132 std::unique_ptr<llvm::Module> takeModule() {
133 return std::unique_ptr<llvm::Module>(Gen->ReleaseModule());
136 CodeGenerator *getCodeGenerator() { return Gen.get(); }
138 void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override {
139 Gen->HandleCXXStaticMemberVarInstantiation(VD);
142 void Initialize(ASTContext &Ctx) override {
143 assert(!Context && "initialized multiple times");
147 if (llvm::TimePassesIsEnabled)
148 LLVMIRGeneration.startTimer();
150 Gen->Initialize(Ctx);
152 if (llvm::TimePassesIsEnabled)
153 LLVMIRGeneration.stopTimer();
156 bool HandleTopLevelDecl(DeclGroupRef D) override {
157 PrettyStackTraceDecl CrashInfo(*D.begin(), SourceLocation(),
158 Context->getSourceManager(),
159 "LLVM IR generation of declaration");
162 if (llvm::TimePassesIsEnabled) {
163 LLVMIRGenerationRefCount += 1;
164 if (LLVMIRGenerationRefCount == 1)
165 LLVMIRGeneration.startTimer();
168 Gen->HandleTopLevelDecl(D);
170 if (llvm::TimePassesIsEnabled) {
171 LLVMIRGenerationRefCount -= 1;
172 if (LLVMIRGenerationRefCount == 0)
173 LLVMIRGeneration.stopTimer();
179 void HandleInlineFunctionDefinition(FunctionDecl *D) override {
180 PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
181 Context->getSourceManager(),
182 "LLVM IR generation of inline function");
183 if (llvm::TimePassesIsEnabled)
184 LLVMIRGeneration.startTimer();
186 Gen->HandleInlineFunctionDefinition(D);
188 if (llvm::TimePassesIsEnabled)
189 LLVMIRGeneration.stopTimer();
192 void HandleInterestingDecl(DeclGroupRef D) override {
193 // Ignore interesting decls from the AST reader after IRGen is finished.
195 HandleTopLevelDecl(D);
198 // Links each entry in LinkModules into our module. Returns true on error.
199 bool LinkInModules() {
200 for (auto &LM : LinkModules) {
201 if (LM.PropagateAttrs)
202 for (Function &F : *LM.Module)
203 Gen->CGM().AddDefaultFnAttrs(F);
205 CurLinkModule = LM.Module.get();
208 if (LM.Internalize) {
209 Err = Linker::linkModules(
210 *getModule(), std::move(LM.Module), LM.LinkFlags,
211 [](llvm::Module &M, const llvm::StringSet<> &GVS) {
212 internalizeModule(M, [&GVS](const llvm::GlobalValue &GV) {
213 return !GV.hasName() || (GVS.count(GV.getName()) == 0);
217 Err = Linker::linkModules(*getModule(), std::move(LM.Module),
224 return false; // success
227 void HandleTranslationUnit(ASTContext &C) override {
229 PrettyStackTraceString CrashInfo("Per-file LLVM IR generation");
230 if (llvm::TimePassesIsEnabled) {
231 LLVMIRGenerationRefCount += 1;
232 if (LLVMIRGenerationRefCount == 1)
233 LLVMIRGeneration.startTimer();
236 Gen->HandleTranslationUnit(C);
238 if (llvm::TimePassesIsEnabled) {
239 LLVMIRGenerationRefCount -= 1;
240 if (LLVMIRGenerationRefCount == 0)
241 LLVMIRGeneration.stopTimer();
244 IRGenFinished = true;
247 // Silently ignore if we weren't initialized for some reason.
251 // Install an inline asm handler so that diagnostics get printed through
252 // our diagnostics hooks.
253 LLVMContext &Ctx = getModule()->getContext();
254 LLVMContext::InlineAsmDiagHandlerTy OldHandler =
255 Ctx.getInlineAsmDiagnosticHandler();
256 void *OldContext = Ctx.getInlineAsmDiagnosticContext();
257 Ctx.setInlineAsmDiagnosticHandler(InlineAsmDiagHandler, this);
259 std::unique_ptr<DiagnosticHandler> OldDiagnosticHandler =
260 Ctx.getDiagnosticHandler();
261 Ctx.setDiagnosticHandler(llvm::make_unique<ClangDiagnosticHandler>(
263 Ctx.setDiagnosticsHotnessRequested(CodeGenOpts.DiagnosticsWithHotness);
264 if (CodeGenOpts.DiagnosticsHotnessThreshold != 0)
265 Ctx.setDiagnosticsHotnessThreshold(
266 CodeGenOpts.DiagnosticsHotnessThreshold);
268 std::unique_ptr<llvm::ToolOutputFile> OptRecordFile;
269 if (!CodeGenOpts.OptRecordFile.empty()) {
271 OptRecordFile = llvm::make_unique<llvm::ToolOutputFile>(
272 CodeGenOpts.OptRecordFile, EC, sys::fs::F_None);
274 Diags.Report(diag::err_cannot_open_file) <<
275 CodeGenOpts.OptRecordFile << EC.message();
279 Ctx.setDiagnosticsOutputFile(
280 llvm::make_unique<yaml::Output>(OptRecordFile->os()));
282 if (CodeGenOpts.getProfileUse() != CodeGenOptions::ProfileNone)
283 Ctx.setDiagnosticsHotnessRequested(true);
286 // Link each LinkModule into our module.
290 EmbedBitcode(getModule(), CodeGenOpts, llvm::MemoryBufferRef());
292 EmitBackendOutput(Diags, HeaderSearchOpts, CodeGenOpts, TargetOpts,
293 LangOpts, C.getTargetInfo().getDataLayout(),
294 getModule(), Action, std::move(AsmOutStream));
296 Ctx.setInlineAsmDiagnosticHandler(OldHandler, OldContext);
298 Ctx.setDiagnosticHandler(std::move(OldDiagnosticHandler));
301 OptRecordFile->keep();
304 void HandleTagDeclDefinition(TagDecl *D) override {
305 PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
306 Context->getSourceManager(),
307 "LLVM IR generation of declaration");
308 Gen->HandleTagDeclDefinition(D);
311 void HandleTagDeclRequiredDefinition(const TagDecl *D) override {
312 Gen->HandleTagDeclRequiredDefinition(D);
315 void CompleteTentativeDefinition(VarDecl *D) override {
316 Gen->CompleteTentativeDefinition(D);
319 void AssignInheritanceModel(CXXRecordDecl *RD) override {
320 Gen->AssignInheritanceModel(RD);
323 void HandleVTable(CXXRecordDecl *RD) override {
324 Gen->HandleVTable(RD);
327 static void InlineAsmDiagHandler(const llvm::SMDiagnostic &SM,void *Context,
328 unsigned LocCookie) {
329 SourceLocation Loc = SourceLocation::getFromRawEncoding(LocCookie);
330 ((BackendConsumer*)Context)->InlineAsmDiagHandler2(SM, Loc);
333 /// Get the best possible source location to represent a diagnostic that
334 /// may have associated debug info.
336 getBestLocationFromDebugLoc(const llvm::DiagnosticInfoWithLocationBase &D,
337 bool &BadDebugInfo, StringRef &Filename,
338 unsigned &Line, unsigned &Column) const;
340 void InlineAsmDiagHandler2(const llvm::SMDiagnostic &,
341 SourceLocation LocCookie);
343 void DiagnosticHandlerImpl(const llvm::DiagnosticInfo &DI);
344 /// \brief Specialized handler for InlineAsm diagnostic.
345 /// \return True if the diagnostic has been successfully reported, false
347 bool InlineAsmDiagHandler(const llvm::DiagnosticInfoInlineAsm &D);
348 /// \brief Specialized handler for StackSize diagnostic.
349 /// \return True if the diagnostic has been successfully reported, false
351 bool StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D);
352 /// \brief Specialized handler for unsupported backend feature diagnostic.
353 void UnsupportedDiagHandler(const llvm::DiagnosticInfoUnsupported &D);
354 /// \brief Specialized handlers for optimization remarks.
355 /// Note that these handlers only accept remarks and they always handle
357 void EmitOptimizationMessage(const llvm::DiagnosticInfoOptimizationBase &D,
360 OptimizationRemarkHandler(const llvm::DiagnosticInfoOptimizationBase &D);
361 void OptimizationRemarkHandler(
362 const llvm::OptimizationRemarkAnalysisFPCommute &D);
363 void OptimizationRemarkHandler(
364 const llvm::OptimizationRemarkAnalysisAliasing &D);
365 void OptimizationFailureHandler(
366 const llvm::DiagnosticInfoOptimizationFailure &D);
369 void BackendConsumer::anchor() {}
372 bool ClangDiagnosticHandler::handleDiagnostics(const DiagnosticInfo &DI) {
373 BackendCon->DiagnosticHandlerImpl(DI);
377 /// ConvertBackendLocation - Convert a location in a temporary llvm::SourceMgr
378 /// buffer to be a valid FullSourceLoc.
379 static FullSourceLoc ConvertBackendLocation(const llvm::SMDiagnostic &D,
380 SourceManager &CSM) {
381 // Get both the clang and llvm source managers. The location is relative to
382 // a memory buffer that the LLVM Source Manager is handling, we need to add
383 // a copy to the Clang source manager.
384 const llvm::SourceMgr &LSM = *D.getSourceMgr();
386 // We need to copy the underlying LLVM memory buffer because llvm::SourceMgr
387 // already owns its one and clang::SourceManager wants to own its one.
388 const MemoryBuffer *LBuf =
389 LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(D.getLoc()));
391 // Create the copy and transfer ownership to clang::SourceManager.
392 // TODO: Avoid copying files into memory.
393 std::unique_ptr<llvm::MemoryBuffer> CBuf =
394 llvm::MemoryBuffer::getMemBufferCopy(LBuf->getBuffer(),
395 LBuf->getBufferIdentifier());
396 // FIXME: Keep a file ID map instead of creating new IDs for each location.
397 FileID FID = CSM.createFileID(std::move(CBuf));
399 // Translate the offset into the file.
400 unsigned Offset = D.getLoc().getPointer() - LBuf->getBufferStart();
401 SourceLocation NewLoc =
402 CSM.getLocForStartOfFile(FID).getLocWithOffset(Offset);
403 return FullSourceLoc(NewLoc, CSM);
407 /// InlineAsmDiagHandler2 - This function is invoked when the backend hits an
408 /// error parsing inline asm. The SMDiagnostic indicates the error relative to
409 /// the temporary memory buffer that the inline asm parser has set up.
410 void BackendConsumer::InlineAsmDiagHandler2(const llvm::SMDiagnostic &D,
411 SourceLocation LocCookie) {
412 // There are a couple of different kinds of errors we could get here. First,
413 // we re-format the SMDiagnostic in terms of a clang diagnostic.
415 // Strip "error: " off the start of the message string.
416 StringRef Message = D.getMessage();
417 if (Message.startswith("error: "))
418 Message = Message.substr(7);
420 // If the SMDiagnostic has an inline asm source location, translate it.
422 if (D.getLoc() != SMLoc())
423 Loc = ConvertBackendLocation(D, Context->getSourceManager());
426 switch (D.getKind()) {
427 case llvm::SourceMgr::DK_Error:
428 DiagID = diag::err_fe_inline_asm;
430 case llvm::SourceMgr::DK_Warning:
431 DiagID = diag::warn_fe_inline_asm;
433 case llvm::SourceMgr::DK_Note:
434 DiagID = diag::note_fe_inline_asm;
436 case llvm::SourceMgr::DK_Remark:
437 llvm_unreachable("remarks unexpected");
439 // If this problem has clang-level source location information, report the
440 // issue in the source with a note showing the instantiated
442 if (LocCookie.isValid()) {
443 Diags.Report(LocCookie, DiagID).AddString(Message);
445 if (D.getLoc().isValid()) {
446 DiagnosticBuilder B = Diags.Report(Loc, diag::note_fe_inline_asm_here);
447 // Convert the SMDiagnostic ranges into SourceRange and attach them
448 // to the diagnostic.
449 for (const std::pair<unsigned, unsigned> &Range : D.getRanges()) {
450 unsigned Column = D.getColumnNo();
451 B << SourceRange(Loc.getLocWithOffset(Range.first - Column),
452 Loc.getLocWithOffset(Range.second - Column));
458 // Otherwise, report the backend issue as occurring in the generated .s file.
459 // If Loc is invalid, we still need to report the issue, it just gets no
461 Diags.Report(Loc, DiagID).AddString(Message);
464 #define ComputeDiagID(Severity, GroupName, DiagID) \
466 switch (Severity) { \
467 case llvm::DS_Error: \
468 DiagID = diag::err_fe_##GroupName; \
470 case llvm::DS_Warning: \
471 DiagID = diag::warn_fe_##GroupName; \
473 case llvm::DS_Remark: \
474 llvm_unreachable("'remark' severity not expected"); \
476 case llvm::DS_Note: \
477 DiagID = diag::note_fe_##GroupName; \
482 #define ComputeDiagRemarkID(Severity, GroupName, DiagID) \
484 switch (Severity) { \
485 case llvm::DS_Error: \
486 DiagID = diag::err_fe_##GroupName; \
488 case llvm::DS_Warning: \
489 DiagID = diag::warn_fe_##GroupName; \
491 case llvm::DS_Remark: \
492 DiagID = diag::remark_fe_##GroupName; \
494 case llvm::DS_Note: \
495 DiagID = diag::note_fe_##GroupName; \
501 BackendConsumer::InlineAsmDiagHandler(const llvm::DiagnosticInfoInlineAsm &D) {
503 ComputeDiagID(D.getSeverity(), inline_asm, DiagID);
504 std::string Message = D.getMsgStr().str();
506 // If this problem has clang-level source location information, report the
507 // issue as being a problem in the source with a note showing the instantiated
509 SourceLocation LocCookie =
510 SourceLocation::getFromRawEncoding(D.getLocCookie());
511 if (LocCookie.isValid())
512 Diags.Report(LocCookie, DiagID).AddString(Message);
514 // Otherwise, report the backend diagnostic as occurring in the generated
516 // If Loc is invalid, we still need to report the diagnostic, it just gets
519 Diags.Report(Loc, DiagID).AddString(Message);
521 // We handled all the possible severities.
526 BackendConsumer::StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D) {
527 if (D.getSeverity() != llvm::DS_Warning)
528 // For now, the only support we have for StackSize diagnostic is warning.
529 // We do not know how to format other severities.
532 if (const Decl *ND = Gen->GetDeclForMangledName(D.getFunction().getName())) {
533 // FIXME: Shouldn't need to truncate to uint32_t
534 Diags.Report(ND->getASTContext().getFullLoc(ND->getLocation()),
535 diag::warn_fe_frame_larger_than)
536 << static_cast<uint32_t>(D.getStackSize()) << Decl::castToDeclContext(ND);
543 const FullSourceLoc BackendConsumer::getBestLocationFromDebugLoc(
544 const llvm::DiagnosticInfoWithLocationBase &D, bool &BadDebugInfo,
545 StringRef &Filename, unsigned &Line, unsigned &Column) const {
546 SourceManager &SourceMgr = Context->getSourceManager();
547 FileManager &FileMgr = SourceMgr.getFileManager();
548 SourceLocation DILoc;
550 if (D.isLocationAvailable()) {
551 D.getLocation(&Filename, &Line, &Column);
552 const FileEntry *FE = FileMgr.getFile(Filename);
553 if (FE && Line > 0) {
554 // If -gcolumn-info was not used, Column will be 0. This upsets the
555 // source manager, so pass 1 if Column is not set.
556 DILoc = SourceMgr.translateFileLineCol(FE, Line, Column ? Column : 1);
558 BadDebugInfo = DILoc.isInvalid();
561 // If a location isn't available, try to approximate it using the associated
562 // function definition. We use the definition's right brace to differentiate
563 // from diagnostics that genuinely relate to the function itself.
564 FullSourceLoc Loc(DILoc, SourceMgr);
566 if (const Decl *FD = Gen->GetDeclForMangledName(D.getFunction().getName()))
567 Loc = FD->getASTContext().getFullLoc(FD->getLocation());
569 if (DILoc.isInvalid() && D.isLocationAvailable())
570 // If we were not able to translate the file:line:col information
571 // back to a SourceLocation, at least emit a note stating that
572 // we could not translate this location. This can happen in the
573 // case of #line directives.
574 Diags.Report(Loc, diag::note_fe_backend_invalid_loc)
575 << Filename << Line << Column;
580 void BackendConsumer::UnsupportedDiagHandler(
581 const llvm::DiagnosticInfoUnsupported &D) {
582 // We only support errors.
583 assert(D.getSeverity() == llvm::DS_Error);
586 unsigned Line, Column;
587 bool BadDebugInfo = false;
589 getBestLocationFromDebugLoc(D, BadDebugInfo, Filename, Line, Column);
591 Diags.Report(Loc, diag::err_fe_backend_unsupported) << D.getMessage().str();
594 // If we were not able to translate the file:line:col information
595 // back to a SourceLocation, at least emit a note stating that
596 // we could not translate this location. This can happen in the
597 // case of #line directives.
598 Diags.Report(Loc, diag::note_fe_backend_invalid_loc)
599 << Filename << Line << Column;
602 void BackendConsumer::EmitOptimizationMessage(
603 const llvm::DiagnosticInfoOptimizationBase &D, unsigned DiagID) {
604 // We only support warnings and remarks.
605 assert(D.getSeverity() == llvm::DS_Remark ||
606 D.getSeverity() == llvm::DS_Warning);
609 unsigned Line, Column;
610 bool BadDebugInfo = false;
612 getBestLocationFromDebugLoc(D, BadDebugInfo, Filename, Line, Column);
615 raw_string_ostream MsgStream(Msg);
616 MsgStream << D.getMsg();
619 MsgStream << " (hotness: " << *D.getHotness() << ")";
621 Diags.Report(Loc, DiagID)
622 << AddFlagValue(D.getPassName())
626 // If we were not able to translate the file:line:col information
627 // back to a SourceLocation, at least emit a note stating that
628 // we could not translate this location. This can happen in the
629 // case of #line directives.
630 Diags.Report(Loc, diag::note_fe_backend_invalid_loc)
631 << Filename << Line << Column;
634 void BackendConsumer::OptimizationRemarkHandler(
635 const llvm::DiagnosticInfoOptimizationBase &D) {
636 // Without hotness information, don't show noisy remarks.
637 if (D.isVerbose() && !D.getHotness())
641 // Optimization remarks are active only if the -Rpass flag has a regular
642 // expression that matches the name of the pass name in \p D.
643 if (CodeGenOpts.OptimizationRemarkPattern &&
644 CodeGenOpts.OptimizationRemarkPattern->match(D.getPassName()))
645 EmitOptimizationMessage(D, diag::remark_fe_backend_optimization_remark);
646 } else if (D.isMissed()) {
647 // Missed optimization remarks are active only if the -Rpass-missed
648 // flag has a regular expression that matches the name of the pass
650 if (CodeGenOpts.OptimizationRemarkMissedPattern &&
651 CodeGenOpts.OptimizationRemarkMissedPattern->match(D.getPassName()))
652 EmitOptimizationMessage(
653 D, diag::remark_fe_backend_optimization_remark_missed);
655 assert(D.isAnalysis() && "Unknown remark type");
657 bool ShouldAlwaysPrint = false;
658 if (auto *ORA = dyn_cast<llvm::OptimizationRemarkAnalysis>(&D))
659 ShouldAlwaysPrint = ORA->shouldAlwaysPrint();
661 if (ShouldAlwaysPrint ||
662 (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
663 CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())))
664 EmitOptimizationMessage(
665 D, diag::remark_fe_backend_optimization_remark_analysis);
669 void BackendConsumer::OptimizationRemarkHandler(
670 const llvm::OptimizationRemarkAnalysisFPCommute &D) {
671 // Optimization analysis remarks are active if the pass name is set to
672 // llvm::DiagnosticInfo::AlwasyPrint or if the -Rpass-analysis flag has a
673 // regular expression that matches the name of the pass name in \p D.
675 if (D.shouldAlwaysPrint() ||
676 (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
677 CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())))
678 EmitOptimizationMessage(
679 D, diag::remark_fe_backend_optimization_remark_analysis_fpcommute);
682 void BackendConsumer::OptimizationRemarkHandler(
683 const llvm::OptimizationRemarkAnalysisAliasing &D) {
684 // Optimization analysis remarks are active if the pass name is set to
685 // llvm::DiagnosticInfo::AlwasyPrint or if the -Rpass-analysis flag has a
686 // regular expression that matches the name of the pass name in \p D.
688 if (D.shouldAlwaysPrint() ||
689 (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
690 CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())))
691 EmitOptimizationMessage(
692 D, diag::remark_fe_backend_optimization_remark_analysis_aliasing);
695 void BackendConsumer::OptimizationFailureHandler(
696 const llvm::DiagnosticInfoOptimizationFailure &D) {
697 EmitOptimizationMessage(D, diag::warn_fe_backend_optimization_failure);
700 /// \brief This function is invoked when the backend needs
701 /// to report something to the user.
702 void BackendConsumer::DiagnosticHandlerImpl(const DiagnosticInfo &DI) {
703 unsigned DiagID = diag::err_fe_inline_asm;
704 llvm::DiagnosticSeverity Severity = DI.getSeverity();
705 // Get the diagnostic ID based.
706 switch (DI.getKind()) {
707 case llvm::DK_InlineAsm:
708 if (InlineAsmDiagHandler(cast<DiagnosticInfoInlineAsm>(DI)))
710 ComputeDiagID(Severity, inline_asm, DiagID);
712 case llvm::DK_StackSize:
713 if (StackSizeDiagHandler(cast<DiagnosticInfoStackSize>(DI)))
715 ComputeDiagID(Severity, backend_frame_larger_than, DiagID);
718 assert(CurLinkModule);
719 // FIXME: stop eating the warnings and notes.
720 if (Severity != DS_Error)
722 DiagID = diag::err_fe_cannot_link_module;
724 case llvm::DK_OptimizationRemark:
725 // Optimization remarks are always handled completely by this
726 // handler. There is no generic way of emitting them.
727 OptimizationRemarkHandler(cast<OptimizationRemark>(DI));
729 case llvm::DK_OptimizationRemarkMissed:
730 // Optimization remarks are always handled completely by this
731 // handler. There is no generic way of emitting them.
732 OptimizationRemarkHandler(cast<OptimizationRemarkMissed>(DI));
734 case llvm::DK_OptimizationRemarkAnalysis:
735 // Optimization remarks are always handled completely by this
736 // handler. There is no generic way of emitting them.
737 OptimizationRemarkHandler(cast<OptimizationRemarkAnalysis>(DI));
739 case llvm::DK_OptimizationRemarkAnalysisFPCommute:
740 // Optimization remarks are always handled completely by this
741 // handler. There is no generic way of emitting them.
742 OptimizationRemarkHandler(cast<OptimizationRemarkAnalysisFPCommute>(DI));
744 case llvm::DK_OptimizationRemarkAnalysisAliasing:
745 // Optimization remarks are always handled completely by this
746 // handler. There is no generic way of emitting them.
747 OptimizationRemarkHandler(cast<OptimizationRemarkAnalysisAliasing>(DI));
749 case llvm::DK_MachineOptimizationRemark:
750 // Optimization remarks are always handled completely by this
751 // handler. There is no generic way of emitting them.
752 OptimizationRemarkHandler(cast<MachineOptimizationRemark>(DI));
754 case llvm::DK_MachineOptimizationRemarkMissed:
755 // Optimization remarks are always handled completely by this
756 // handler. There is no generic way of emitting them.
757 OptimizationRemarkHandler(cast<MachineOptimizationRemarkMissed>(DI));
759 case llvm::DK_MachineOptimizationRemarkAnalysis:
760 // Optimization remarks are always handled completely by this
761 // handler. There is no generic way of emitting them.
762 OptimizationRemarkHandler(cast<MachineOptimizationRemarkAnalysis>(DI));
764 case llvm::DK_OptimizationFailure:
765 // Optimization failures are always handled completely by this
767 OptimizationFailureHandler(cast<DiagnosticInfoOptimizationFailure>(DI));
769 case llvm::DK_Unsupported:
770 UnsupportedDiagHandler(cast<DiagnosticInfoUnsupported>(DI));
773 // Plugin IDs are not bound to any value as they are set dynamically.
774 ComputeDiagRemarkID(Severity, backend_plugin, DiagID);
777 std::string MsgStorage;
779 raw_string_ostream Stream(MsgStorage);
780 DiagnosticPrinterRawOStream DP(Stream);
784 if (DiagID == diag::err_fe_cannot_link_module) {
785 Diags.Report(diag::err_fe_cannot_link_module)
786 << CurLinkModule->getModuleIdentifier() << MsgStorage;
790 // Report the backend message using the usual diagnostic mechanism.
792 Diags.Report(Loc, DiagID).AddString(MsgStorage);
796 CodeGenAction::CodeGenAction(unsigned _Act, LLVMContext *_VMContext)
797 : Act(_Act), VMContext(_VMContext ? _VMContext : new LLVMContext),
798 OwnsVMContext(!_VMContext) {}
800 CodeGenAction::~CodeGenAction() {
806 bool CodeGenAction::hasIRSupport() const { return true; }
808 void CodeGenAction::EndSourceFileAction() {
809 // If the consumer creation failed, do nothing.
810 if (!getCompilerInstance().hasASTConsumer())
813 // Steal the module from the consumer.
814 TheModule = BEConsumer->takeModule();
817 std::unique_ptr<llvm::Module> CodeGenAction::takeModule() {
818 return std::move(TheModule);
821 llvm::LLVMContext *CodeGenAction::takeLLVMContext() {
822 OwnsVMContext = false;
826 static std::unique_ptr<raw_pwrite_stream>
827 GetOutputStream(CompilerInstance &CI, StringRef InFile, BackendAction Action) {
829 case Backend_EmitAssembly:
830 return CI.createDefaultOutputFile(false, InFile, "s");
832 return CI.createDefaultOutputFile(false, InFile, "ll");
834 return CI.createDefaultOutputFile(true, InFile, "bc");
835 case Backend_EmitNothing:
837 case Backend_EmitMCNull:
838 return CI.createNullOutputFile();
839 case Backend_EmitObj:
840 return CI.createDefaultOutputFile(true, InFile, "o");
843 llvm_unreachable("Invalid action!");
846 std::unique_ptr<ASTConsumer>
847 CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
848 BackendAction BA = static_cast<BackendAction>(Act);
849 std::unique_ptr<raw_pwrite_stream> OS = GetOutputStream(CI, InFile, BA);
850 if (BA != Backend_EmitNothing && !OS)
853 // Load bitcode modules to link with, if we need to.
854 if (LinkModules.empty())
855 for (const CodeGenOptions::BitcodeFileToLink &F :
856 CI.getCodeGenOpts().LinkBitcodeFiles) {
857 auto BCBuf = CI.getFileManager().getBufferForFile(F.Filename);
859 CI.getDiagnostics().Report(diag::err_cannot_open_file)
860 << F.Filename << BCBuf.getError().message();
865 Expected<std::unique_ptr<llvm::Module>> ModuleOrErr =
866 getOwningLazyBitcodeModule(std::move(*BCBuf), *VMContext);
868 handleAllErrors(ModuleOrErr.takeError(), [&](ErrorInfoBase &EIB) {
869 CI.getDiagnostics().Report(diag::err_cannot_open_file)
870 << F.Filename << EIB.message();
875 LinkModules.push_back({std::move(ModuleOrErr.get()), F.PropagateAttrs,
876 F.Internalize, F.LinkFlags});
879 CoverageSourceInfo *CoverageInfo = nullptr;
880 // Add the preprocessor callback only when the coverage mapping is generated.
881 if (CI.getCodeGenOpts().CoverageMapping) {
882 CoverageInfo = new CoverageSourceInfo;
883 CI.getPreprocessor().addPPCallbacks(
884 std::unique_ptr<PPCallbacks>(CoverageInfo));
887 std::unique_ptr<BackendConsumer> Result(new BackendConsumer(
888 BA, CI.getDiagnostics(), CI.getHeaderSearchOpts(),
889 CI.getPreprocessorOpts(), CI.getCodeGenOpts(), CI.getTargetOpts(),
890 CI.getLangOpts(), CI.getFrontendOpts().ShowTimers, InFile,
891 std::move(LinkModules), std::move(OS), *VMContext, CoverageInfo));
892 BEConsumer = Result.get();
894 // Enable generating macro debug info only when debug info is not disabled and
895 // also macro debug info is enabled.
896 if (CI.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo &&
897 CI.getCodeGenOpts().MacroDebugInfo) {
898 std::unique_ptr<PPCallbacks> Callbacks =
899 llvm::make_unique<MacroPPCallbacks>(BEConsumer->getCodeGenerator(),
900 CI.getPreprocessor());
901 CI.getPreprocessor().addPPCallbacks(std::move(Callbacks));
904 return std::move(Result);
907 static void BitcodeInlineAsmDiagHandler(const llvm::SMDiagnostic &SM,
909 unsigned LocCookie) {
910 SM.print(nullptr, llvm::errs());
912 auto Diags = static_cast<DiagnosticsEngine *>(Context);
914 switch (SM.getKind()) {
915 case llvm::SourceMgr::DK_Error:
916 DiagID = diag::err_fe_inline_asm;
918 case llvm::SourceMgr::DK_Warning:
919 DiagID = diag::warn_fe_inline_asm;
921 case llvm::SourceMgr::DK_Note:
922 DiagID = diag::note_fe_inline_asm;
924 case llvm::SourceMgr::DK_Remark:
925 llvm_unreachable("remarks unexpected");
928 Diags->Report(DiagID).AddString("cannot compile inline asm");
931 std::unique_ptr<llvm::Module> CodeGenAction::loadModule(MemoryBufferRef MBRef) {
932 CompilerInstance &CI = getCompilerInstance();
933 SourceManager &SM = CI.getSourceManager();
935 // For ThinLTO backend invocations, ensure that the context
936 // merges types based on ODR identifiers. We also need to read
937 // the correct module out of a multi-module bitcode file.
938 if (!CI.getCodeGenOpts().ThinLTOIndexFile.empty()) {
939 VMContext->enableDebugTypeODRUniquing();
941 auto DiagErrors = [&](Error E) -> std::unique_ptr<llvm::Module> {
943 CI.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, "%0");
944 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
945 CI.getDiagnostics().Report(DiagID) << EIB.message();
950 Expected<llvm::BitcodeModule> BMOrErr = FindThinLTOModule(MBRef);
952 return DiagErrors(BMOrErr.takeError());
954 Expected<std::unique_ptr<llvm::Module>> MOrErr =
955 BMOrErr->parseModule(*VMContext);
957 return DiagErrors(MOrErr.takeError());
958 return std::move(*MOrErr);
961 llvm::SMDiagnostic Err;
962 if (std::unique_ptr<llvm::Module> M = parseIR(MBRef, Err, *VMContext))
965 // Translate from the diagnostic info to the SourceManager location if
967 // TODO: Unify this with ConvertBackendLocation()
969 if (Err.getLineNo() > 0) {
970 assert(Err.getColumnNo() >= 0);
971 Loc = SM.translateFileLineCol(SM.getFileEntryForID(SM.getMainFileID()),
972 Err.getLineNo(), Err.getColumnNo() + 1);
975 // Strip off a leading diagnostic code if there is one.
976 StringRef Msg = Err.getMessage();
977 if (Msg.startswith("error: "))
981 CI.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, "%0");
983 CI.getDiagnostics().Report(Loc, DiagID) << Msg;
987 void CodeGenAction::ExecuteAction() {
988 // If this is an IR file, we have to treat it specially.
989 if (getCurrentFileKind().getLanguage() == InputKind::LLVM_IR) {
990 BackendAction BA = static_cast<BackendAction>(Act);
991 CompilerInstance &CI = getCompilerInstance();
992 std::unique_ptr<raw_pwrite_stream> OS =
993 GetOutputStream(CI, getCurrentFile(), BA);
994 if (BA != Backend_EmitNothing && !OS)
998 SourceManager &SM = CI.getSourceManager();
999 FileID FID = SM.getMainFileID();
1000 llvm::MemoryBuffer *MainFile = SM.getBuffer(FID, &Invalid);
1004 TheModule = loadModule(*MainFile);
1008 const TargetOptions &TargetOpts = CI.getTargetOpts();
1009 if (TheModule->getTargetTriple() != TargetOpts.Triple) {
1010 CI.getDiagnostics().Report(SourceLocation(),
1011 diag::warn_fe_override_module)
1012 << TargetOpts.Triple;
1013 TheModule->setTargetTriple(TargetOpts.Triple);
1016 EmbedBitcode(TheModule.get(), CI.getCodeGenOpts(),
1017 MainFile->getMemBufferRef());
1019 LLVMContext &Ctx = TheModule->getContext();
1020 Ctx.setInlineAsmDiagnosticHandler(BitcodeInlineAsmDiagHandler,
1021 &CI.getDiagnostics());
1023 EmitBackendOutput(CI.getDiagnostics(), CI.getHeaderSearchOpts(),
1024 CI.getCodeGenOpts(), TargetOpts, CI.getLangOpts(),
1025 CI.getTarget().getDataLayout(), TheModule.get(), BA,
1030 // Otherwise follow the normal AST path.
1031 this->ASTFrontendAction::ExecuteAction();
1036 void EmitAssemblyAction::anchor() { }
1037 EmitAssemblyAction::EmitAssemblyAction(llvm::LLVMContext *_VMContext)
1038 : CodeGenAction(Backend_EmitAssembly, _VMContext) {}
1040 void EmitBCAction::anchor() { }
1041 EmitBCAction::EmitBCAction(llvm::LLVMContext *_VMContext)
1042 : CodeGenAction(Backend_EmitBC, _VMContext) {}
1044 void EmitLLVMAction::anchor() { }
1045 EmitLLVMAction::EmitLLVMAction(llvm::LLVMContext *_VMContext)
1046 : CodeGenAction(Backend_EmitLL, _VMContext) {}
1048 void EmitLLVMOnlyAction::anchor() { }
1049 EmitLLVMOnlyAction::EmitLLVMOnlyAction(llvm::LLVMContext *_VMContext)
1050 : CodeGenAction(Backend_EmitNothing, _VMContext) {}
1052 void EmitCodeGenOnlyAction::anchor() { }
1053 EmitCodeGenOnlyAction::EmitCodeGenOnlyAction(llvm::LLVMContext *_VMContext)
1054 : CodeGenAction(Backend_EmitMCNull, _VMContext) {}
1056 void EmitObjAction::anchor() { }
1057 EmitObjAction::EmitObjAction(llvm::LLVMContext *_VMContext)
1058 : CodeGenAction(Backend_EmitObj, _VMContext) {}