1 //===--- CodeGenAction.h - LLVM Code Generation Frontend Action -*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLVM_CLANG_CODEGEN_CODEGENACTION_H 10 #define LLVM_CLANG_CODEGEN_CODEGENACTION_H 11 12 #include "clang/Frontend/FrontendAction.h" 13 #include <memory> 14 15 namespace llvm { 16 class LLVMContext; 17 class Module; 18 } 19 20 namespace clang { 21 class BackendConsumer; 22 class CodeGenerator; 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 /// Load bitcode modules to link into our module from the options. 57 bool loadLinkModules(CompilerInstance &CI); 58 59 protected: 60 bool BeginSourceFileAction(CompilerInstance &CI) override; 61 62 /// Create a new code generation action. If the optional \p _VMContext 63 /// parameter is supplied, the action uses it without taking ownership, 64 /// otherwise it creates a fresh LLVM context and takes ownership. 65 CodeGenAction(unsigned _Act, llvm::LLVMContext *_VMContext = nullptr); 66 67 bool hasIRSupport() const override; 68 69 std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI, 70 StringRef InFile) override; 71 72 void ExecuteAction() override; 73 74 void EndSourceFileAction() override; 75 76 public: 77 ~CodeGenAction() override; 78 79 /// Take the generated LLVM module, for use after the action has been run. 80 /// The result may be null on failure. 81 std::unique_ptr<llvm::Module> takeModule(); 82 83 /// Take the LLVM context used by this action. 84 llvm::LLVMContext *takeLLVMContext(); 85 86 CodeGenerator *getCodeGenerator() const; 87 88 BackendConsumer *BEConsumer = nullptr; 89 }; 90 91 class EmitAssemblyAction : public CodeGenAction { 92 virtual void anchor(); 93 public: 94 EmitAssemblyAction(llvm::LLVMContext *_VMContext = nullptr); 95 }; 96 97 class EmitBCAction : public CodeGenAction { 98 virtual void anchor(); 99 public: 100 EmitBCAction(llvm::LLVMContext *_VMContext = nullptr); 101 }; 102 103 class EmitLLVMAction : public CodeGenAction { 104 virtual void anchor(); 105 public: 106 EmitLLVMAction(llvm::LLVMContext *_VMContext = nullptr); 107 }; 108 109 class EmitLLVMOnlyAction : public CodeGenAction { 110 virtual void anchor(); 111 public: 112 EmitLLVMOnlyAction(llvm::LLVMContext *_VMContext = nullptr); 113 }; 114 115 class EmitCodeGenOnlyAction : public CodeGenAction { 116 virtual void anchor(); 117 public: 118 EmitCodeGenOnlyAction(llvm::LLVMContext *_VMContext = nullptr); 119 }; 120 121 class EmitObjAction : public CodeGenAction { 122 virtual void anchor(); 123 public: 124 EmitObjAction(llvm::LLVMContext *_VMContext = nullptr); 125 }; 126 127 } 128 129 #endif 130