contrib/llvm/tools/clang/include/clang/CodeGen/CodeGenAction.h

   1 //===--- CodeGenAction.h - LLVM Code Generation Frontend Action -*- C++ -*-===//
   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 #ifndef LLVM_CLANG_CODEGEN_CODEGENACTION_H
  11 #define LLVM_CLANG_CODEGEN_CODEGENACTION_H
  12
  13 #include "clang/Frontend/FrontendAction.h"
  14 #include <memory>
  15
  16 namespace llvm {
  17   class LLVMContext;
  18   class Module;
  19 }
  20
  21 namespace clang {
  22 class BackendConsumer;
  23
  24 class CodeGenAction : public ASTFrontendAction {
  25 private:
  26   // Let BackendConsumer access LinkModule.
  27   friend class BackendConsumer;
  28
  29   /// Info about module to link into a module we're generating.
  30   struct LinkModule {
  31     /// The module to link in.
  32     std::unique_ptr<llvm::Module> Module;
  33
  34     /// If true, we set attributes on Module's functions according to our
  35     /// CodeGenOptions and LangOptions, as though we were generating the
  36     /// function ourselves.
  37     bool PropagateAttrs;
  38
  39     /// If true, we use LLVM module internalizer.
  40     bool Internalize;
  41
  42     /// Bitwise combination of llvm::LinkerFlags used when we link the module.
  43     unsigned LinkFlags;
  44   };
  45
  46   unsigned Act;
  47   std::unique_ptr<llvm::Module> TheModule;
  48
  49   /// Bitcode modules to link in to our module.
  50   SmallVector<LinkModule, 4> LinkModules;
  51   llvm::LLVMContext *VMContext;
  52   bool OwnsVMContext;
  53
  54   std::unique_ptr<llvm::Module> loadModule(llvm::MemoryBufferRef MBRef);
  55
  56 protected:
  57   /// Create a new code generation action.  If the optional \p _VMContext
  58   /// parameter is supplied, the action uses it without taking ownership,
  59   /// otherwise it creates a fresh LLVM context and takes ownership.
  60   CodeGenAction(unsigned _Act, llvm::LLVMContext *_VMContext = nullptr);
  61
  62   bool hasIRSupport() const override;
  63
  64   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  65                                                  StringRef InFile) override;
  66
  67   void ExecuteAction() override;
  68
  69   void EndSourceFileAction() override;
  70
  71 public:
  72   ~CodeGenAction() override;
  73
  74   /// Take the generated LLVM module, for use after the action has been run.
  75   /// The result may be null on failure.
  76   std::unique_ptr<llvm::Module> takeModule();
  77
  78   /// Take the LLVM context used by this action.
  79   llvm::LLVMContext *takeLLVMContext();
  80
  81   BackendConsumer *BEConsumer;
  82 };
  83
  84 class EmitAssemblyAction : public CodeGenAction {
  85   virtual void anchor();
  86 public:
  87   EmitAssemblyAction(llvm::LLVMContext *_VMContext = nullptr);
  88 };
  89
  90 class EmitBCAction : public CodeGenAction {
  91   virtual void anchor();
  92 public:
  93   EmitBCAction(llvm::LLVMContext *_VMContext = nullptr);
  94 };
  95
  96 class EmitLLVMAction : public CodeGenAction {
  97   virtual void anchor();
  98 public:
  99   EmitLLVMAction(llvm::LLVMContext *_VMContext = nullptr);
 100 };
 101
 102 class EmitLLVMOnlyAction : public CodeGenAction {
 103   virtual void anchor();
 104 public:
 105   EmitLLVMOnlyAction(llvm::LLVMContext *_VMContext = nullptr);
 106 };
 107
 108 class EmitCodeGenOnlyAction : public CodeGenAction {
 109   virtual void anchor();
 110 public:
 111   EmitCodeGenOnlyAction(llvm::LLVMContext *_VMContext = nullptr);
 112 };
 113
 114 class EmitObjAction : public CodeGenAction {
 115   virtual void anchor();
 116 public:
 117   EmitObjAction(llvm::LLVMContext *_VMContext = nullptr);
 118 };
 119
 120 }
 121
 122 #endif