contrib/llvm/tools/clang/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
  29 using namespace clang;
  30 using namespace CodeGen;
  31
  32 namespace {
  33   class CodeGeneratorImpl : public CodeGenerator {
  34     DiagnosticsEngine &Diags;
  35     ASTContext *Ctx;
  36     const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info.
  37     const PreprocessorOptions &PreprocessorOpts; // Only used for debug info.
  38     const CodeGenOptions CodeGenOpts;  // Intentionally copied in.
  39
  40     unsigned HandlingTopLevelDecls;
  41
  42     /// Use this when emitting decls to block re-entrant decl emission. It will
  43     /// emit all deferred decls on scope exit. Set EmitDeferred to false if decl
  44     /// emission must be deferred longer, like at the end of a tag definition.
  45     struct HandlingTopLevelDeclRAII {
  46       CodeGeneratorImpl &Self;
  47       bool EmitDeferred;
  48       HandlingTopLevelDeclRAII(CodeGeneratorImpl &Self,
  49                                bool EmitDeferred = true)
  50           : Self(Self), EmitDeferred(EmitDeferred) {
  51         ++Self.HandlingTopLevelDecls;
  52       }
  53       ~HandlingTopLevelDeclRAII() {
  54         unsigned Level = --Self.HandlingTopLevelDecls;
  55         if (Level == 0 && EmitDeferred)
  56           Self.EmitDeferredDecls();
  57       }
  58     };
  59
  60     CoverageSourceInfo *CoverageInfo;
  61
  62   protected:
  63     std::unique_ptr<llvm::Module> M;
  64     std::unique_ptr<CodeGen::CodeGenModule> Builder;
  65
  66   private:
  67     SmallVector<CXXMethodDecl *, 8> DeferredInlineMethodDefinitions;
  68
  69   public:
  70     CodeGeneratorImpl(DiagnosticsEngine &diags, llvm::StringRef ModuleName,
  71                       const HeaderSearchOptions &HSO,
  72                       const PreprocessorOptions &PPO, const CodeGenOptions &CGO,
  73                       llvm::LLVMContext &C,
  74                       CoverageSourceInfo *CoverageInfo = nullptr)
  75         : Diags(diags), Ctx(nullptr), HeaderSearchOpts(HSO),
  76           PreprocessorOpts(PPO), CodeGenOpts(CGO), HandlingTopLevelDecls(0),
  77           CoverageInfo(CoverageInfo), M(new llvm::Module(ModuleName, C)) {
  78       C.setDiscardValueNames(CGO.DiscardValueNames);
  79     }
  80
  81     ~CodeGeneratorImpl() override {
  82       // There should normally not be any leftover inline method definitions.
  83       assert(DeferredInlineMethodDefinitions.empty() ||
  84              Diags.hasErrorOccurred());
  85     }
  86
  87     CodeGenModule &CGM() {
  88       return *Builder;
  89     }
  90
  91     llvm::Module *GetModule() {
  92       return M.get();
  93     }
  94
  95     llvm::Module *ReleaseModule() {
  96       return M.release();
  97     }
  98
  99     const Decl *GetDeclForMangledName(StringRef MangledName) {
 100       GlobalDecl Result;
 101       if (!Builder->lookupRepresentativeDecl(MangledName, Result))
 102         return nullptr;
 103       const Decl *D = Result.getCanonicalDecl().getDecl();
 104       if (auto FD = dyn_cast<FunctionDecl>(D)) {
 105         if (FD->hasBody(FD))
 106           return FD;
 107       } else if (auto TD = dyn_cast<TagDecl>(D)) {
 108         if (auto Def = TD->getDefinition())
 109           return Def;
 110       }
 111       return D;
 112     }
 113
 114     llvm::Constant *GetAddrOfGlobal(GlobalDecl global, bool isForDefinition) {
 115       return Builder->GetAddrOfGlobal(global, ForDefinition_t(isForDefinition));
 116     }
 117
 118     void Initialize(ASTContext &Context) override {
 119       Ctx = &Context;
 120
 121       M->setTargetTriple(Ctx->getTargetInfo().getTriple().getTriple());
 122       M->setDataLayout(Ctx->getTargetInfo().getDataLayout());
 123       Builder.reset(new CodeGen::CodeGenModule(Context, HeaderSearchOpts,
 124                                                PreprocessorOpts, CodeGenOpts,
 125                                                *M, Diags, CoverageInfo));
 126
 127       for (auto &&Lib : CodeGenOpts.DependentLibraries)
 128         Builder->AddDependentLib(Lib);
 129       for (auto &&Opt : CodeGenOpts.LinkerOptions)
 130         Builder->AppendLinkerOptions(Opt);
 131     }
 132
 133     void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override {
 134       if (Diags.hasErrorOccurred())
 135         return;
 136
 137       Builder->HandleCXXStaticMemberVarInstantiation(VD);
 138     }
 139
 140     bool HandleTopLevelDecl(DeclGroupRef DG) override {
 141       if (Diags.hasErrorOccurred())
 142         return true;
 143
 144       HandlingTopLevelDeclRAII HandlingDecl(*this);
 145
 146       // Make sure to emit all elements of a Decl.
 147       for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
 148         Builder->EmitTopLevelDecl(*I);
 149
 150       return true;
 151     }
 152
 153     void EmitDeferredDecls() {
 154       if (DeferredInlineMethodDefinitions.empty())
 155         return;
 156
 157       // Emit any deferred inline method definitions. Note that more deferred
 158       // methods may be added during this loop, since ASTConsumer callbacks
 159       // can be invoked if AST inspection results in declarations being added.
 160       HandlingTopLevelDeclRAII HandlingDecl(*this);
 161       for (unsigned I = 0; I != DeferredInlineMethodDefinitions.size(); ++I)
 162         Builder->EmitTopLevelDecl(DeferredInlineMethodDefinitions[I]);
 163       DeferredInlineMethodDefinitions.clear();
 164     }
 165
 166     void HandleInlineFunctionDefinition(FunctionDecl *D) override {
 167       if (Diags.hasErrorOccurred())
 168         return;
 169
 170       assert(D->doesThisDeclarationHaveABody());
 171
 172       // Handle friend functions.
 173       if (D->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend)) {
 174         if (Ctx->getTargetInfo().getCXXABI().isMicrosoft()
 175             && !D->getLexicalDeclContext()->isDependentContext())
 176           Builder->EmitTopLevelDecl(D);
 177         return;
 178       }
 179
 180       // Otherwise, must be a method.
 181       auto MD = cast<CXXMethodDecl>(D);
 182
 183       // We may want to emit this definition. However, that decision might be
 184       // based on computing the linkage, and we have to defer that in case we
 185       // are inside of something that will change the method's final linkage,
 186       // e.g.
 187       //   typedef struct {
 188       //     void bar();
 189       //     void foo() { bar(); }
 190       //   } A;
 191       DeferredInlineMethodDefinitions.push_back(MD);
 192
 193       // Provide some coverage mapping even for methods that aren't emitted.
 194       // Don't do this for templated classes though, as they may not be
 195       // instantiable.
 196       if (!MD->getParent()->getDescribedClassTemplate())
 197         Builder->AddDeferredUnusedCoverageMapping(MD);
 198     }
 199
 200     /// HandleTagDeclDefinition - This callback is invoked each time a TagDecl
 201     /// to (e.g. struct, union, enum, class) is completed. This allows the
 202     /// client hack on the type, which can occur at any point in the file
 203     /// (because these can be defined in declspecs).
 204     void HandleTagDeclDefinition(TagDecl *D) override {
 205       if (Diags.hasErrorOccurred())
 206         return;
 207
 208       // Don't allow re-entrant calls to CodeGen triggered by PCH
 209       // deserialization to emit deferred decls.
 210       HandlingTopLevelDeclRAII HandlingDecl(*this, /*EmitDeferred=*/false);
 211
 212       Builder->UpdateCompletedType(D);
 213
 214       // For MSVC compatibility, treat declarations of static data members with
 215       // inline initializers as definitions.
 216       if (Ctx->getTargetInfo().getCXXABI().isMicrosoft()) {
 217         for (Decl *Member : D->decls()) {
 218           if (VarDecl *VD = dyn_cast<VarDecl>(Member)) {
 219             if (Ctx->isMSStaticDataMemberInlineDefinition(VD) &&
 220                 Ctx->DeclMustBeEmitted(VD)) {
 221               Builder->EmitGlobal(VD);
 222             }
 223           }
 224         }
 225       }
 226       // For OpenMP emit declare reduction functions, if required.
 227       if (Ctx->getLangOpts().OpenMP) {
 228         for (Decl *Member : D->decls()) {
 229           if (auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Member)) {
 230             if (Ctx->DeclMustBeEmitted(DRD))
 231               Builder->EmitGlobal(DRD);
 232           }
 233         }
 234       }
 235     }
 236
 237     void HandleTagDeclRequiredDefinition(const TagDecl *D) override {
 238       if (Diags.hasErrorOccurred())
 239         return;
 240
 241       // Don't allow re-entrant calls to CodeGen triggered by PCH
 242       // deserialization to emit deferred decls.
 243       HandlingTopLevelDeclRAII HandlingDecl(*this, /*EmitDeferred=*/false);
 244
 245       if (CodeGen::CGDebugInfo *DI = Builder->getModuleDebugInfo())
 246         if (const RecordDecl *RD = dyn_cast<RecordDecl>(D))
 247           DI->completeRequiredType(RD);
 248     }
 249
 250     void HandleTranslationUnit(ASTContext &Ctx) override {
 251       // Release the Builder when there is no error.
 252       if (!Diags.hasErrorOccurred() && Builder)
 253         Builder->Release();
 254
 255       // If there are errors before or when releasing the Builder, reset
 256       // the module to stop here before invoking the backend.
 257       if (Diags.hasErrorOccurred()) {
 258         if (Builder)
 259           Builder->clear();
 260         M.reset();
 261         return;
 262       }
 263     }
 264
 265     void AssignInheritanceModel(CXXRecordDecl *RD) override {
 266       if (Diags.hasErrorOccurred())
 267         return;
 268
 269       Builder->RefreshTypeCacheForClass(RD);
 270     }
 271
 272     void CompleteTentativeDefinition(VarDecl *D) override {
 273       if (Diags.hasErrorOccurred())
 274         return;
 275
 276       Builder->EmitTentativeDefinition(D);
 277     }
 278
 279     void HandleVTable(CXXRecordDecl *RD) override {
 280       if (Diags.hasErrorOccurred())
 281         return;
 282
 283       Builder->EmitVTable(RD);
 284     }
 285   };
 286 }
 287
 288 void CodeGenerator::anchor() { }
 289
 290 CodeGenModule &CodeGenerator::CGM() {
 291   return static_cast<CodeGeneratorImpl*>(this)->CGM();
 292 }
 293
 294 llvm::Module *CodeGenerator::GetModule() {
 295   return static_cast<CodeGeneratorImpl*>(this)->GetModule();
 296 }
 297
 298 llvm::Module *CodeGenerator::ReleaseModule() {
 299   return static_cast<CodeGeneratorImpl*>(this)->ReleaseModule();
 300 }
 301
 302 const Decl *CodeGenerator::GetDeclForMangledName(llvm::StringRef name) {
 303   return static_cast<CodeGeneratorImpl*>(this)->GetDeclForMangledName(name);
 304 }
 305
 306 llvm::Constant *CodeGenerator::GetAddrOfGlobal(GlobalDecl global,
 307                                                bool isForDefinition) {
 308   return static_cast<CodeGeneratorImpl*>(this)
 309            ->GetAddrOfGlobal(global, isForDefinition);
 310 }
 311
 312 CodeGenerator *clang::CreateLLVMCodeGen(
 313     DiagnosticsEngine &Diags, llvm::StringRef ModuleName,
 314     const HeaderSearchOptions &HeaderSearchOpts,
 315     const PreprocessorOptions &PreprocessorOpts, const CodeGenOptions &CGO,
 316     llvm::LLVMContext &C, CoverageSourceInfo *CoverageInfo) {
 317   return new CodeGeneratorImpl(Diags, ModuleName, HeaderSearchOpts,
 318                                PreprocessorOpts, CGO, C, CoverageInfo);
 319 }