1//===--- CodeGenAction.cpp - LLVM Code Generation Frontend Action ---------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "clang/CodeGen/CodeGenAction.h"
11#include "clang/AST/ASTConsumer.h"
12#include "clang/AST/ASTContext.h"
13#include "clang/AST/DeclGroup.h"
14#include "clang/AST/DeclCXX.h"
15#include "clang/Basic/FileManager.h"
16#include "clang/Basic/SourceManager.h"
17#include "clang/Basic/TargetInfo.h"
18#include "clang/CodeGen/BackendUtil.h"
19#include "clang/CodeGen/ModuleBuilder.h"
20#include "clang/Frontend/CompilerInstance.h"
21#include "clang/Frontend/FrontendDiagnostic.h"
22#include "llvm/ADT/SmallString.h"
23#include "llvm/Bitcode/ReaderWriter.h"
24#include "llvm/IR/DebugInfo.h"
25#include "llvm/IR/DiagnosticInfo.h"
26#include "llvm/IR/DiagnosticPrinter.h"
27#include "llvm/IR/LLVMContext.h"
28#include "llvm/IR/Module.h"
29#include "llvm/IRReader/IRReader.h"
30#include "llvm/Linker/Linker.h"
31#include "llvm/Pass.h"
32#include "llvm/Support/MemoryBuffer.h"
33#include "llvm/Support/SourceMgr.h"
34#include "llvm/Support/Timer.h"
35#include <memory>
36using namespace clang;
37using namespace llvm;
38
39namespace clang {
40  class BackendConsumer : public ASTConsumer {
41    virtual void anchor();
42    DiagnosticsEngine &Diags;
43    BackendAction Action;
44    const CodeGenOptions &CodeGenOpts;
45    const TargetOptions &TargetOpts;
46    const LangOptions &LangOpts;
47    raw_ostream *AsmOutStream;
48    ASTContext *Context;
49
50    Timer LLVMIRGeneration;
51
52    std::unique_ptr<CodeGenerator> Gen;
53
54    std::unique_ptr<llvm::Module> TheModule, LinkModule;
55
56  public:
57    BackendConsumer(BackendAction action, DiagnosticsEngine &_Diags,
58                    const CodeGenOptions &compopts,
59                    const TargetOptions &targetopts,
60                    const LangOptions &langopts, bool TimePasses,
61                    const std::string &infile, llvm::Module *LinkModule,
62                    raw_ostream *OS, LLVMContext &C)
63        : Diags(_Diags), Action(action), CodeGenOpts(compopts),
64          TargetOpts(targetopts), LangOpts(langopts), AsmOutStream(OS),
65          Context(), LLVMIRGeneration("LLVM IR Generation Time"),
66          Gen(CreateLLVMCodeGen(Diags, infile, compopts, targetopts, C)),
67          LinkModule(LinkModule) {
68      llvm::TimePassesIsEnabled = TimePasses;
69    }
70
71    llvm::Module *takeModule() { return TheModule.release(); }
72    llvm::Module *takeLinkModule() { return LinkModule.release(); }
73
74    void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override {
75      Gen->HandleCXXStaticMemberVarInstantiation(VD);
76    }
77
78    void Initialize(ASTContext &Ctx) override {
79      Context = &Ctx;
80
81      if (llvm::TimePassesIsEnabled)
82        LLVMIRGeneration.startTimer();
83
84      Gen->Initialize(Ctx);
85
86      TheModule.reset(Gen->GetModule());
87
88      if (llvm::TimePassesIsEnabled)
89        LLVMIRGeneration.stopTimer();
90    }
91
92    bool HandleTopLevelDecl(DeclGroupRef D) override {
93      PrettyStackTraceDecl CrashInfo(*D.begin(), SourceLocation(),
94                                     Context->getSourceManager(),
95                                     "LLVM IR generation of declaration");
96
97      if (llvm::TimePassesIsEnabled)
98        LLVMIRGeneration.startTimer();
99
100      Gen->HandleTopLevelDecl(D);
101
102      if (llvm::TimePassesIsEnabled)
103        LLVMIRGeneration.stopTimer();
104
105      return true;
106    }
107
108    void HandleInlineMethodDefinition(CXXMethodDecl *D) override {
109      PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
110                                     Context->getSourceManager(),
111                                     "LLVM IR generation of inline method");
112      if (llvm::TimePassesIsEnabled)
113        LLVMIRGeneration.startTimer();
114
115      Gen->HandleInlineMethodDefinition(D);
116
117      if (llvm::TimePassesIsEnabled)
118        LLVMIRGeneration.stopTimer();
119    }
120
121    void HandleTranslationUnit(ASTContext &C) override {
122      {
123        PrettyStackTraceString CrashInfo("Per-file LLVM IR generation");
124        if (llvm::TimePassesIsEnabled)
125          LLVMIRGeneration.startTimer();
126
127        Gen->HandleTranslationUnit(C);
128
129        if (llvm::TimePassesIsEnabled)
130          LLVMIRGeneration.stopTimer();
131      }
132
133      // Silently ignore if we weren't initialized for some reason.
134      if (!TheModule)
135        return;
136
137      // Make sure IR generation is happy with the module. This is released by
138      // the module provider.
139      llvm::Module *M = Gen->ReleaseModule();
140      if (!M) {
141        // The module has been released by IR gen on failures, do not double
142        // free.
143        TheModule.release();
144        return;
145      }
146
147      assert(TheModule.get() == M &&
148             "Unexpected module change during IR generation");
149
150      // Link LinkModule into this module if present, preserving its validity.
151      if (LinkModule) {
152        std::string ErrorMsg;
153        if (Linker::LinkModules(M, LinkModule.get(), Linker::PreserveSource,
154                                &ErrorMsg)) {
155          Diags.Report(diag::err_fe_cannot_link_module)
156            << LinkModule->getModuleIdentifier() << ErrorMsg;
157          return;
158        }
159      }
160
161      // Install an inline asm handler so that diagnostics get printed through
162      // our diagnostics hooks.
163      LLVMContext &Ctx = TheModule->getContext();
164      LLVMContext::InlineAsmDiagHandlerTy OldHandler =
165        Ctx.getInlineAsmDiagnosticHandler();
166      void *OldContext = Ctx.getInlineAsmDiagnosticContext();
167      Ctx.setInlineAsmDiagnosticHandler(InlineAsmDiagHandler, this);
168
169      LLVMContext::DiagnosticHandlerTy OldDiagnosticHandler =
170          Ctx.getDiagnosticHandler();
171      void *OldDiagnosticContext = Ctx.getDiagnosticContext();
172      Ctx.setDiagnosticHandler(DiagnosticHandler, this);
173
174      EmitBackendOutput(Diags, CodeGenOpts, TargetOpts, LangOpts,
175                        C.getTargetInfo().getTargetDescription(),
176                        TheModule.get(), Action, AsmOutStream);
177
178      Ctx.setInlineAsmDiagnosticHandler(OldHandler, OldContext);
179
180      Ctx.setDiagnosticHandler(OldDiagnosticHandler, OldDiagnosticContext);
181    }
182
183    void HandleTagDeclDefinition(TagDecl *D) override {
184      PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
185                                     Context->getSourceManager(),
186                                     "LLVM IR generation of declaration");
187      Gen->HandleTagDeclDefinition(D);
188    }
189
190    void HandleTagDeclRequiredDefinition(const TagDecl *D) override {
191      Gen->HandleTagDeclRequiredDefinition(D);
192    }
193
194    void CompleteTentativeDefinition(VarDecl *D) override {
195      Gen->CompleteTentativeDefinition(D);
196    }
197
198    void HandleVTable(CXXRecordDecl *RD, bool DefinitionRequired) override {
199      Gen->HandleVTable(RD, DefinitionRequired);
200    }
201
202    void HandleLinkerOptionPragma(llvm::StringRef Opts) override {
203      Gen->HandleLinkerOptionPragma(Opts);
204    }
205
206    void HandleDetectMismatch(llvm::StringRef Name,
207                                      llvm::StringRef Value) override {
208      Gen->HandleDetectMismatch(Name, Value);
209    }
210
211    void HandleDependentLibrary(llvm::StringRef Opts) override {
212      Gen->HandleDependentLibrary(Opts);
213    }
214
215    static void InlineAsmDiagHandler(const llvm::SMDiagnostic &SM,void *Context,
216                                     unsigned LocCookie) {
217      SourceLocation Loc = SourceLocation::getFromRawEncoding(LocCookie);
218      ((BackendConsumer*)Context)->InlineAsmDiagHandler2(SM, Loc);
219    }
220
221    static void DiagnosticHandler(const llvm::DiagnosticInfo &DI,
222                                  void *Context) {
223      ((BackendConsumer *)Context)->DiagnosticHandlerImpl(DI);
224    }
225
226    void InlineAsmDiagHandler2(const llvm::SMDiagnostic &,
227                               SourceLocation LocCookie);
228
229    void DiagnosticHandlerImpl(const llvm::DiagnosticInfo &DI);
230    /// \brief Specialized handler for InlineAsm diagnostic.
231    /// \return True if the diagnostic has been successfully reported, false
232    /// otherwise.
233    bool InlineAsmDiagHandler(const llvm::DiagnosticInfoInlineAsm &D);
234    /// \brief Specialized handler for StackSize diagnostic.
235    /// \return True if the diagnostic has been successfully reported, false
236    /// otherwise.
237    bool StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D);
238    /// \brief Specialized handlers for optimization remarks.
239    /// Note that these handlers only accept remarks and they always handle
240    /// them.
241    void
242    EmitOptimizationRemark(const llvm::DiagnosticInfoOptimizationRemarkBase &D,
243                           unsigned DiagID);
244    void
245    OptimizationRemarkHandler(const llvm::DiagnosticInfoOptimizationRemark &D);
246    void OptimizationRemarkHandler(
247        const llvm::DiagnosticInfoOptimizationRemarkMissed &D);
248    void OptimizationRemarkHandler(
249        const llvm::DiagnosticInfoOptimizationRemarkAnalysis &D);
250  };
251
252  void BackendConsumer::anchor() {}
253}
254
255/// ConvertBackendLocation - Convert a location in a temporary llvm::SourceMgr
256/// buffer to be a valid FullSourceLoc.
257static FullSourceLoc ConvertBackendLocation(const llvm::SMDiagnostic &D,
258                                            SourceManager &CSM) {
259  // Get both the clang and llvm source managers.  The location is relative to
260  // a memory buffer that the LLVM Source Manager is handling, we need to add
261  // a copy to the Clang source manager.
262  const llvm::SourceMgr &LSM = *D.getSourceMgr();
263
264  // We need to copy the underlying LLVM memory buffer because llvm::SourceMgr
265  // already owns its one and clang::SourceManager wants to own its one.
266  const MemoryBuffer *LBuf =
267  LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(D.getLoc()));
268
269  // Create the copy and transfer ownership to clang::SourceManager.
270  // TODO: Avoid copying files into memory.
271  llvm::MemoryBuffer *CBuf =
272  llvm::MemoryBuffer::getMemBufferCopy(LBuf->getBuffer(),
273                                       LBuf->getBufferIdentifier());
274  // FIXME: Keep a file ID map instead of creating new IDs for each location.
275  FileID FID = CSM.createFileID(CBuf);
276
277  // Translate the offset into the file.
278  unsigned Offset = D.getLoc().getPointer() - LBuf->getBufferStart();
279  SourceLocation NewLoc =
280  CSM.getLocForStartOfFile(FID).getLocWithOffset(Offset);
281  return FullSourceLoc(NewLoc, CSM);
282}
283
284
285/// InlineAsmDiagHandler2 - This function is invoked when the backend hits an
286/// error parsing inline asm.  The SMDiagnostic indicates the error relative to
287/// the temporary memory buffer that the inline asm parser has set up.
288void BackendConsumer::InlineAsmDiagHandler2(const llvm::SMDiagnostic &D,
289                                            SourceLocation LocCookie) {
290  // There are a couple of different kinds of errors we could get here.  First,
291  // we re-format the SMDiagnostic in terms of a clang diagnostic.
292
293  // Strip "error: " off the start of the message string.
294  StringRef Message = D.getMessage();
295  if (Message.startswith("error: "))
296    Message = Message.substr(7);
297
298  // If the SMDiagnostic has an inline asm source location, translate it.
299  FullSourceLoc Loc;
300  if (D.getLoc() != SMLoc())
301    Loc = ConvertBackendLocation(D, Context->getSourceManager());
302
303  unsigned DiagID;
304  switch (D.getKind()) {
305  case llvm::SourceMgr::DK_Error:
306    DiagID = diag::err_fe_inline_asm;
307    break;
308  case llvm::SourceMgr::DK_Warning:
309    DiagID = diag::warn_fe_inline_asm;
310    break;
311  case llvm::SourceMgr::DK_Note:
312    DiagID = diag::note_fe_inline_asm;
313    break;
314  }
315  // If this problem has clang-level source location information, report the
316  // issue in the source with a note showing the instantiated
317  // code.
318  if (LocCookie.isValid()) {
319    Diags.Report(LocCookie, DiagID).AddString(Message);
320
321    if (D.getLoc().isValid()) {
322      DiagnosticBuilder B = Diags.Report(Loc, diag::note_fe_inline_asm_here);
323      // Convert the SMDiagnostic ranges into SourceRange and attach them
324      // to the diagnostic.
325      for (unsigned i = 0, e = D.getRanges().size(); i != e; ++i) {
326        std::pair<unsigned, unsigned> Range = D.getRanges()[i];
327        unsigned Column = D.getColumnNo();
328        B << SourceRange(Loc.getLocWithOffset(Range.first - Column),
329                         Loc.getLocWithOffset(Range.second - Column));
330      }
331    }
332    return;
333  }
334
335  // Otherwise, report the backend issue as occurring in the generated .s file.
336  // If Loc is invalid, we still need to report the issue, it just gets no
337  // location info.
338  Diags.Report(Loc, DiagID).AddString(Message);
339}
340
341#define ComputeDiagID(Severity, GroupName, DiagID)                             \
342  do {                                                                         \
343    switch (Severity) {                                                        \
344    case llvm::DS_Error:                                                       \
345      DiagID = diag::err_fe_##GroupName;                                       \
346      break;                                                                   \
347    case llvm::DS_Warning:                                                     \
348      DiagID = diag::warn_fe_##GroupName;                                      \
349      break;                                                                   \
350    case llvm::DS_Remark:                                                      \
351      llvm_unreachable("'remark' severity not expected");                      \
352      break;                                                                   \
353    case llvm::DS_Note:                                                        \
354      DiagID = diag::note_fe_##GroupName;                                      \
355      break;                                                                   \
356    }                                                                          \
357  } while (false)
358
359#define ComputeDiagRemarkID(Severity, GroupName, DiagID)                       \
360  do {                                                                         \
361    switch (Severity) {                                                        \
362    case llvm::DS_Error:                                                       \
363      DiagID = diag::err_fe_##GroupName;                                       \
364      break;                                                                   \
365    case llvm::DS_Warning:                                                     \
366      DiagID = diag::warn_fe_##GroupName;                                      \
367      break;                                                                   \
368    case llvm::DS_Remark:                                                      \
369      DiagID = diag::remark_fe_##GroupName;                                    \
370      break;                                                                   \
371    case llvm::DS_Note:                                                        \
372      DiagID = diag::note_fe_##GroupName;                                      \
373      break;                                                                   \
374    }                                                                          \
375  } while (false)
376
377bool
378BackendConsumer::InlineAsmDiagHandler(const llvm::DiagnosticInfoInlineAsm &D) {
379  unsigned DiagID;
380  ComputeDiagID(D.getSeverity(), inline_asm, DiagID);
381  std::string Message = D.getMsgStr().str();
382
383  // If this problem has clang-level source location information, report the
384  // issue as being a problem in the source with a note showing the instantiated
385  // code.
386  SourceLocation LocCookie =
387      SourceLocation::getFromRawEncoding(D.getLocCookie());
388  if (LocCookie.isValid())
389    Diags.Report(LocCookie, DiagID).AddString(Message);
390  else {
391    // Otherwise, report the backend diagnostic as occurring in the generated
392    // .s file.
393    // If Loc is invalid, we still need to report the diagnostic, it just gets
394    // no location info.
395    FullSourceLoc Loc;
396    Diags.Report(Loc, DiagID).AddString(Message);
397  }
398  // We handled all the possible severities.
399  return true;
400}
401
402bool
403BackendConsumer::StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D) {
404  if (D.getSeverity() != llvm::DS_Warning)
405    // For now, the only support we have for StackSize diagnostic is warning.
406    // We do not know how to format other severities.
407    return false;
408
409  if (const Decl *ND = Gen->GetDeclForMangledName(D.getFunction().getName())) {
410    Diags.Report(ND->getASTContext().getFullLoc(ND->getLocation()),
411                 diag::warn_fe_frame_larger_than)
412        << D.getStackSize() << Decl::castToDeclContext(ND);
413    return true;
414  }
415
416  return false;
417}
418
419void BackendConsumer::EmitOptimizationRemark(
420    const llvm::DiagnosticInfoOptimizationRemarkBase &D, unsigned DiagID) {
421  // We only support remarks.
422  assert(D.getSeverity() == llvm::DS_Remark);
423
424  SourceManager &SourceMgr = Context->getSourceManager();
425  FileManager &FileMgr = SourceMgr.getFileManager();
426  StringRef Filename;
427  unsigned Line, Column;
428  D.getLocation(&Filename, &Line, &Column);
429  SourceLocation DILoc;
430  const FileEntry *FE = FileMgr.getFile(Filename);
431  if (FE && Line > 0) {
432    // If -gcolumn-info was not used, Column will be 0. This upsets the
433    // source manager, so pass 1 if Column is not set.
434    DILoc = SourceMgr.translateFileLineCol(FE, Line, Column ? Column : 1);
435  }
436
437  // If a location isn't available, try to approximate it using the associated
438  // function definition. We use the definition's right brace to differentiate
439  // from diagnostics that genuinely relate to the function itself.
440  FullSourceLoc Loc(DILoc, SourceMgr);
441  if (Loc.isInvalid())
442    if (const Decl *FD = Gen->GetDeclForMangledName(D.getFunction().getName()))
443      Loc = FD->getASTContext().getFullLoc(FD->getBodyRBrace());
444
445  Diags.Report(Loc, DiagID) << AddFlagValue(D.getPassName())
446                            << D.getMsg().str();
447
448  if (DILoc.isInvalid())
449    // If we were not able to translate the file:line:col information
450    // back to a SourceLocation, at least emit a note stating that
451    // we could not translate this location. This can happen in the
452    // case of #line directives.
453    Diags.Report(Loc, diag::note_fe_backend_optimization_remark_invalid_loc)
454        << Filename << Line << Column;
455}
456
457void BackendConsumer::OptimizationRemarkHandler(
458    const llvm::DiagnosticInfoOptimizationRemark &D) {
459  // Optimization remarks are active only if the -Rpass flag has a regular
460  // expression that matches the name of the pass name in \p D.
461  if (CodeGenOpts.OptimizationRemarkPattern &&
462      CodeGenOpts.OptimizationRemarkPattern->match(D.getPassName()))
463    EmitOptimizationRemark(D, diag::remark_fe_backend_optimization_remark);
464}
465
466void BackendConsumer::OptimizationRemarkHandler(
467    const llvm::DiagnosticInfoOptimizationRemarkMissed &D) {
468  // Missed optimization remarks are active only if the -Rpass-missed
469  // flag has a regular expression that matches the name of the pass
470  // name in \p D.
471  if (CodeGenOpts.OptimizationRemarkMissedPattern &&
472      CodeGenOpts.OptimizationRemarkMissedPattern->match(D.getPassName()))
473    EmitOptimizationRemark(D,
474                           diag::remark_fe_backend_optimization_remark_missed);
475}
476
477void BackendConsumer::OptimizationRemarkHandler(
478    const llvm::DiagnosticInfoOptimizationRemarkAnalysis &D) {
479  // Optimization analysis remarks are active only if the -Rpass-analysis
480  // flag has a regular expression that matches the name of the pass
481  // name in \p D.
482  if (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
483      CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName()))
484    EmitOptimizationRemark(
485        D, diag::remark_fe_backend_optimization_remark_analysis);
486}
487
488/// \brief This function is invoked when the backend needs
489/// to report something to the user.
490void BackendConsumer::DiagnosticHandlerImpl(const DiagnosticInfo &DI) {
491  unsigned DiagID = diag::err_fe_inline_asm;
492  llvm::DiagnosticSeverity Severity = DI.getSeverity();
493  // Get the diagnostic ID based.
494  switch (DI.getKind()) {
495  case llvm::DK_InlineAsm:
496    if (InlineAsmDiagHandler(cast<DiagnosticInfoInlineAsm>(DI)))
497      return;
498    ComputeDiagID(Severity, inline_asm, DiagID);
499    break;
500  case llvm::DK_StackSize:
501    if (StackSizeDiagHandler(cast<DiagnosticInfoStackSize>(DI)))
502      return;
503    ComputeDiagID(Severity, backend_frame_larger_than, DiagID);
504    break;
505  case llvm::DK_OptimizationRemark:
506    // Optimization remarks are always handled completely by this
507    // handler. There is no generic way of emitting them.
508    OptimizationRemarkHandler(cast<DiagnosticInfoOptimizationRemark>(DI));
509    return;
510  case llvm::DK_OptimizationRemarkMissed:
511    // Optimization remarks are always handled completely by this
512    // handler. There is no generic way of emitting them.
513    OptimizationRemarkHandler(cast<DiagnosticInfoOptimizationRemarkMissed>(DI));
514    return;
515  case llvm::DK_OptimizationRemarkAnalysis:
516    // Optimization remarks are always handled completely by this
517    // handler. There is no generic way of emitting them.
518    OptimizationRemarkHandler(
519        cast<DiagnosticInfoOptimizationRemarkAnalysis>(DI));
520    return;
521  default:
522    // Plugin IDs are not bound to any value as they are set dynamically.
523    ComputeDiagRemarkID(Severity, backend_plugin, DiagID);
524    break;
525  }
526  std::string MsgStorage;
527  {
528    raw_string_ostream Stream(MsgStorage);
529    DiagnosticPrinterRawOStream DP(Stream);
530    DI.print(DP);
531  }
532
533  // Report the backend message using the usual diagnostic mechanism.
534  FullSourceLoc Loc;
535  Diags.Report(Loc, DiagID).AddString(MsgStorage);
536}
537#undef ComputeDiagID
538
539CodeGenAction::CodeGenAction(unsigned _Act, LLVMContext *_VMContext)
540  : Act(_Act), LinkModule(nullptr),
541    VMContext(_VMContext ? _VMContext : new LLVMContext),
542    OwnsVMContext(!_VMContext) {}
543
544CodeGenAction::~CodeGenAction() {
545  TheModule.reset();
546  if (OwnsVMContext)
547    delete VMContext;
548}
549
550bool CodeGenAction::hasIRSupport() const { return true; }
551
552void CodeGenAction::EndSourceFileAction() {
553  // If the consumer creation failed, do nothing.
554  if (!getCompilerInstance().hasASTConsumer())
555    return;
556
557  // If we were given a link module, release consumer's ownership of it.
558  if (LinkModule)
559    BEConsumer->takeLinkModule();
560
561  // Steal the module from the consumer.
562  TheModule.reset(BEConsumer->takeModule());
563}
564
565llvm::Module *CodeGenAction::takeModule() { return TheModule.release(); }
566
567llvm::LLVMContext *CodeGenAction::takeLLVMContext() {
568  OwnsVMContext = false;
569  return VMContext;
570}
571
572static raw_ostream *GetOutputStream(CompilerInstance &CI,
573                                    StringRef InFile,
574                                    BackendAction Action) {
575  switch (Action) {
576  case Backend_EmitAssembly:
577    return CI.createDefaultOutputFile(false, InFile, "s");
578  case Backend_EmitLL:
579    return CI.createDefaultOutputFile(false, InFile, "ll");
580  case Backend_EmitBC:
581    return CI.createDefaultOutputFile(true, InFile, "bc");
582  case Backend_EmitNothing:
583    return nullptr;
584  case Backend_EmitMCNull:
585    return CI.createNullOutputFile();
586  case Backend_EmitObj:
587    return CI.createDefaultOutputFile(true, InFile, "o");
588  }
589
590  llvm_unreachable("Invalid action!");
591}
592
593ASTConsumer *CodeGenAction::CreateASTConsumer(CompilerInstance &CI,
594                                              StringRef InFile) {
595  BackendAction BA = static_cast<BackendAction>(Act);
596  std::unique_ptr<raw_ostream> OS(GetOutputStream(CI, InFile, BA));
597  if (BA != Backend_EmitNothing && !OS)
598    return nullptr;
599
600  llvm::Module *LinkModuleToUse = LinkModule;
601
602  // If we were not given a link module, and the user requested that one be
603  // loaded from bitcode, do so now.
604  const std::string &LinkBCFile = CI.getCodeGenOpts().LinkBitcodeFile;
605  if (!LinkModuleToUse && !LinkBCFile.empty()) {
606    std::string ErrorStr;
607
608    llvm::MemoryBuffer *BCBuf =
609      CI.getFileManager().getBufferForFile(LinkBCFile, &ErrorStr);
610    if (!BCBuf) {
611      CI.getDiagnostics().Report(diag::err_cannot_open_file)
612        << LinkBCFile << ErrorStr;
613      return nullptr;
614    }
615
616    ErrorOr<llvm::Module *> ModuleOrErr =
617        getLazyBitcodeModule(BCBuf, *VMContext);
618    if (std::error_code EC = ModuleOrErr.getError()) {
619      CI.getDiagnostics().Report(diag::err_cannot_open_file)
620        << LinkBCFile << EC.message();
621      return nullptr;
622    }
623    LinkModuleToUse = ModuleOrErr.get();
624  }
625
626  BEConsumer = new BackendConsumer(BA, CI.getDiagnostics(), CI.getCodeGenOpts(),
627                                   CI.getTargetOpts(), CI.getLangOpts(),
628                                   CI.getFrontendOpts().ShowTimers, InFile,
629                                   LinkModuleToUse, OS.release(), *VMContext);
630  return BEConsumer;
631}
632
633void CodeGenAction::ExecuteAction() {
634  // If this is an IR file, we have to treat it specially.
635  if (getCurrentFileKind() == IK_LLVM_IR) {
636    BackendAction BA = static_cast<BackendAction>(Act);
637    CompilerInstance &CI = getCompilerInstance();
638    raw_ostream *OS = GetOutputStream(CI, getCurrentFile(), BA);
639    if (BA != Backend_EmitNothing && !OS)
640      return;
641
642    bool Invalid;
643    SourceManager &SM = CI.getSourceManager();
644    FileID FID = SM.getMainFileID();
645    llvm::MemoryBuffer *MainFile = SM.getBuffer(FID, &Invalid);
646    if (Invalid)
647      return;
648
649    llvm::SMDiagnostic Err;
650    TheModule.reset(ParseIR(MainFile, Err, *VMContext));
651    if (!TheModule) {
652      // Translate from the diagnostic info to the SourceManager location if
653      // available.
654      // TODO: Unify this with ConvertBackendLocation()
655      SourceLocation Loc;
656      if (Err.getLineNo() > 0) {
657        assert(Err.getColumnNo() >= 0);
658        Loc = SM.translateFileLineCol(SM.getFileEntryForID(FID),
659                                      Err.getLineNo(), Err.getColumnNo() + 1);
660      }
661
662      // Strip off a leading diagnostic code if there is one.
663      StringRef Msg = Err.getMessage();
664      if (Msg.startswith("error: "))
665        Msg = Msg.substr(7);
666
667      unsigned DiagID =
668          CI.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, "%0");
669
670      CI.getDiagnostics().Report(Loc, DiagID) << Msg;
671      return;
672    }
673    const TargetOptions &TargetOpts = CI.getTargetOpts();
674    if (TheModule->getTargetTriple() != TargetOpts.Triple) {
675      unsigned DiagID = CI.getDiagnostics().getCustomDiagID(
676          DiagnosticsEngine::Warning,
677          "overriding the module target triple with %0");
678
679      CI.getDiagnostics().Report(SourceLocation(), DiagID) << TargetOpts.Triple;
680      TheModule->setTargetTriple(TargetOpts.Triple);
681    }
682
683    EmitBackendOutput(CI.getDiagnostics(), CI.getCodeGenOpts(), TargetOpts,
684                      CI.getLangOpts(), CI.getTarget().getTargetDescription(),
685                      TheModule.get(), BA, OS);
686    return;
687  }
688
689  // Otherwise follow the normal AST path.
690  this->ASTFrontendAction::ExecuteAction();
691}
692
693//
694
695void EmitAssemblyAction::anchor() { }
696EmitAssemblyAction::EmitAssemblyAction(llvm::LLVMContext *_VMContext)
697  : CodeGenAction(Backend_EmitAssembly, _VMContext) {}
698
699void EmitBCAction::anchor() { }
700EmitBCAction::EmitBCAction(llvm::LLVMContext *_VMContext)
701  : CodeGenAction(Backend_EmitBC, _VMContext) {}
702
703void EmitLLVMAction::anchor() { }
704EmitLLVMAction::EmitLLVMAction(llvm::LLVMContext *_VMContext)
705  : CodeGenAction(Backend_EmitLL, _VMContext) {}
706
707void EmitLLVMOnlyAction::anchor() { }
708EmitLLVMOnlyAction::EmitLLVMOnlyAction(llvm::LLVMContext *_VMContext)
709  : CodeGenAction(Backend_EmitNothing, _VMContext) {}
710
711void EmitCodeGenOnlyAction::anchor() { }
712EmitCodeGenOnlyAction::EmitCodeGenOnlyAction(llvm::LLVMContext *_VMContext)
713  : CodeGenAction(Backend_EmitMCNull, _VMContext) {}
714
715void EmitObjAction::anchor() { }
716EmitObjAction::EmitObjAction(llvm::LLVMContext *_VMContext)
717  : CodeGenAction(Backend_EmitObj, _VMContext) {}
718