Home | History | Annotate | Download | only in CodeGen 
      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
    123