granicus.if.org Git - clang/blob - lib/CodeGen/ModuleBuilder.cpp

   1 //===--- ModuleBuilder.cpp - Emit LLVM Code from ASTs ---------------------===//
   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 // This builds an AST and converts it to LLVM Code.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/CodeGen/ModuleBuilder.h"
  15 #include "CGDebugInfo.h"
  16 #include "CodeGenModule.h"
  17 #include "clang/AST/ASTContext.h"
  18 #include "clang/AST/DeclObjC.h"
  19 #include "clang/AST/Expr.h"
  20 #include "clang/Basic/Diagnostic.h"
  21 #include "clang/Basic/TargetInfo.h"
  22 #include "clang/Frontend/CodeGenOptions.h"
  23 #include "llvm/ADT/StringRef.h"
  24 #include "llvm/IR/DataLayout.h"
  25 #include "llvm/IR/LLVMContext.h"
  26 #include "llvm/IR/Module.h"
  27 #include <memory>
  28 using namespace clang;
  29
  30 namespace {
  31   class CodeGeneratorImpl : public CodeGenerator {
  32     DiagnosticsEngine &Diags;
  33     std::unique_ptr<const llvm::DataLayout> TD;
  34     ASTContext *Ctx;
  35     const CodeGenOptions CodeGenOpts;  // Intentionally copied in.
  36
  37     unsigned HandlingTopLevelDecls;
  38     struct HandlingTopLevelDeclRAII {
  39       CodeGeneratorImpl &Self;
  40       HandlingTopLevelDeclRAII(CodeGeneratorImpl &Self) : Self(Self) {
  41         ++Self.HandlingTopLevelDecls;
  42       }
  43       ~HandlingTopLevelDeclRAII() {
  44         if (--Self.HandlingTopLevelDecls == 0)
  45           Self.EmitDeferredDecls();
  46       }
  47     };
  48
  49     CoverageSourceInfo *CoverageInfo;
  50
  51   protected:
  52     std::unique_ptr<llvm::Module> M;
  53     std::unique_ptr<CodeGen::CodeGenModule> Builder;
  54
  55   public:
  56     CodeGeneratorImpl(DiagnosticsEngine &diags, const std::string& ModuleName,
  57                       const CodeGenOptions &CGO, llvm::LLVMContext& C,
  58                       CoverageSourceInfo *CoverageInfo = nullptr)
  59       : Diags(diags), CodeGenOpts(CGO), HandlingTopLevelDecls(0),
  60         CoverageInfo(CoverageInfo),
  61         M(new llvm::Module(ModuleName, C)) {}
  62
  63     virtual ~CodeGeneratorImpl() {}
  64
  65     llvm::Module* GetModule() override {
  66       return M.get();
  67     }
  68
  69     const Decl *GetDeclForMangledName(StringRef MangledName) override {
  70       GlobalDecl Result;
  71       if (!Builder->lookupRepresentativeDecl(MangledName, Result))
  72         return nullptr;
  73       const Decl *D = Result.getCanonicalDecl().getDecl();
  74       if (auto FD = dyn_cast<FunctionDecl>(D)) {
  75         if (FD->hasBody(FD))
  76           return FD;
  77       } else if (auto TD = dyn_cast<TagDecl>(D)) {
  78         if (auto Def = TD->getDefinition())
  79           return Def;
  80       }
  81       return D;
  82     }
  83
  84     llvm::Module *ReleaseModule() override { return M.release(); }
  85
  86     void Initialize(ASTContext &Context) override {
  87       Ctx = &Context;
  88
  89       M->setTargetTriple(Ctx->getTargetInfo().getTriple().getTriple());
  90       M->setDataLayout(Ctx->getTargetInfo().getTargetDescription());
  91       TD.reset(new llvm::DataLayout(Ctx->getTargetInfo().getTargetDescription()));
  92       Builder.reset(new CodeGen::CodeGenModule(Context, CodeGenOpts, *M, *TD,
  93                                                Diags, CoverageInfo));
  94
  95       for (size_t i = 0, e = CodeGenOpts.DependentLibraries.size(); i < e; ++i)
  96         HandleDependentLibrary(CodeGenOpts.DependentLibraries[i]);
  97     }
  98
  99     void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override {
 100       if (Diags.hasErrorOccurred())
 101         return;
 102
 103       Builder->HandleCXXStaticMemberVarInstantiation(VD);
 104     }
 105
 106     bool HandleTopLevelDecl(DeclGroupRef DG) override {
 107       if (Diags.hasErrorOccurred())
 108         return true;
 109
 110       HandlingTopLevelDeclRAII HandlingDecl(*this);
 111
 112       // Make sure to emit all elements of a Decl.
 113       for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
 114         Builder->EmitTopLevelDecl(*I);
 115
 116       return true;
 117     }
 118
 119     void EmitDeferredDecls() {
 120       // Emit any deferred inline method definitions. Note that more deferred
 121       // methods may be added during this loop, since ASTConsumer callbacks
 122       // can be invoked if AST inspection results in declarations being added.
 123       for (unsigned I = 0; I < DeferredInlineMethodDefinitions.size(); ++I)
 124         Builder->EmitTopLevelDecl(DeferredInlineMethodDefinitions[I]);
 125       DeferredInlineMethodDefinitions.clear();
 126     }
 127
 128     void HandleInlineMethodDefinition(CXXMethodDecl *D) override {
 129       if (Diags.hasErrorOccurred())
 130         return;
 131
 132       assert(D->doesThisDeclarationHaveABody());
 133
 134       // We may want to emit this definition. However, that decision might be
 135       // based on computing the linkage, and we have to defer that in case we
 136       // are inside of something that will change the method's final linkage,
 137       // e.g.
 138       //   typedef struct {
 139       //     void bar();
 140       //     void foo() { bar(); }
 141       //   } A;
 142       DeferredInlineMethodDefinitions.push_back(D);
 143
 144       // Always provide some coverage mapping
 145       // even for the methods that aren't emitted.
 146       Builder->AddDeferredUnusedCoverageMapping(D);
 147     }
 148
 149     /// HandleTagDeclDefinition - This callback is invoked each time a TagDecl
 150     /// to (e.g. struct, union, enum, class) is completed. This allows the
 151     /// client hack on the type, which can occur at any point in the file
 152     /// (because these can be defined in declspecs).
 153     void HandleTagDeclDefinition(TagDecl *D) override {
 154       if (Diags.hasErrorOccurred())
 155         return;
 156
 157       Builder->UpdateCompletedType(D);
 158
 159       // For MSVC compatibility, treat declarations of static data members with
 160       // inline initializers as definitions.
 161       if (Ctx->getLangOpts().MSVCCompat) {
 162         for (Decl *Member : D->decls()) {
 163           if (VarDecl *VD = dyn_cast<VarDecl>(Member)) {
 164             if (Ctx->isMSStaticDataMemberInlineDefinition(VD) &&
 165                 Ctx->DeclMustBeEmitted(VD)) {
 166               Builder->EmitGlobal(VD);
 167             }
 168           }
 169         }
 170       }
 171     }
 172
 173     void HandleTagDeclRequiredDefinition(const TagDecl *D) override {
 174       if (Diags.hasErrorOccurred())
 175         return;
 176
 177       if (CodeGen::CGDebugInfo *DI = Builder->getModuleDebugInfo())
 178         if (const RecordDecl *RD = dyn_cast<RecordDecl>(D))
 179           DI->completeRequiredType(RD);
 180     }
 181
 182     void HandleTranslationUnit(ASTContext &Ctx) override {
 183       if (Diags.hasErrorOccurred()) {
 184         if (Builder)
 185           Builder->clear();
 186         M.reset();
 187         return;
 188       }
 189
 190       if (Builder)
 191         Builder->Release();
 192     }
 193
 194     void CompleteTentativeDefinition(VarDecl *D) override {
 195       if (Diags.hasErrorOccurred())
 196         return;
 197
 198       Builder->EmitTentativeDefinition(D);
 199     }
 200
 201     void HandleVTable(CXXRecordDecl *RD, bool DefinitionRequired) override {
 202       if (Diags.hasErrorOccurred())
 203         return;
 204
 205       Builder->EmitVTable(RD, DefinitionRequired);
 206     }
 207
 208     void HandleLinkerOptionPragma(llvm::StringRef Opts) override {
 209       Builder->AppendLinkerOptions(Opts);
 210     }
 211
 212     void HandleDetectMismatch(llvm::StringRef Name,
 213                               llvm::StringRef Value) override {
 214       Builder->AddDetectMismatch(Name, Value);
 215     }
 216
 217     void HandleDependentLibrary(llvm::StringRef Lib) override {
 218       Builder->AddDependentLib(Lib);
 219     }
 220
 221   private:
 222     std::vector<CXXMethodDecl *> DeferredInlineMethodDefinitions;
 223   };
 224 }
 225
 226 void CodeGenerator::anchor() { }
 227
 228 CodeGenerator *clang::CreateLLVMCodeGen(DiagnosticsEngine &Diags,
 229                                         const std::string& ModuleName,
 230                                         const CodeGenOptions &CGO,
 231                                         const TargetOptions &/*TO*/,
 232                                         llvm::LLVMContext& C,
 233                                         CoverageSourceInfo *CoverageInfo) {
 234   return new CodeGeneratorImpl(Diags, ModuleName, CGO, C, CoverageInfo);
 235 }