1193326Sed//===--- ModuleBuilder.cpp - Emit LLVM Code from ASTs ---------------------===// 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed// 8193326Sed//===----------------------------------------------------------------------===// 9193326Sed// 10193326Sed// This builds an AST and converts it to LLVM Code. 11193326Sed// 12193326Sed//===----------------------------------------------------------------------===// 13193326Sed 14193326Sed#include "clang/CodeGen/ModuleBuilder.h" 15276479Sdim#include "CGDebugInfo.h" 16193326Sed#include "CodeGenModule.h" 17193326Sed#include "clang/AST/ASTContext.h" 18193326Sed#include "clang/AST/DeclObjC.h" 19193326Sed#include "clang/AST/Expr.h" 20193326Sed#include "clang/Basic/Diagnostic.h" 21193326Sed#include "clang/Basic/TargetInfo.h" 22249423Sdim#include "clang/Frontend/CodeGenOptions.h" 23261991Sdim#include "llvm/ADT/StringRef.h" 24249423Sdim#include "llvm/IR/DataLayout.h" 25249423Sdim#include "llvm/IR/LLVMContext.h" 26249423Sdim#include "llvm/IR/Module.h" 27276479Sdim#include <memory> 28193326Sedusing namespace clang; 29193326Sed 30193326Sednamespace { 31199990Srdivacky class CodeGeneratorImpl : public CodeGenerator { 32226633Sdim DiagnosticsEngine &Diags; 33193326Sed ASTContext *Ctx; 34288943Sdim const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info. 35288943Sdim const PreprocessorOptions &PreprocessorOpts; // Only used for debug info. 36199482Srdivacky const CodeGenOptions CodeGenOpts; // Intentionally copied in. 37280031Sdim 38280031Sdim unsigned HandlingTopLevelDecls; 39280031Sdim struct HandlingTopLevelDeclRAII { 40280031Sdim CodeGeneratorImpl &Self; 41280031Sdim HandlingTopLevelDeclRAII(CodeGeneratorImpl &Self) : Self(Self) { 42280031Sdim ++Self.HandlingTopLevelDecls; 43280031Sdim } 44280031Sdim ~HandlingTopLevelDeclRAII() { 45280031Sdim if (--Self.HandlingTopLevelDecls == 0) 46280031Sdim Self.EmitDeferredDecls(); 47280031Sdim } 48280031Sdim }; 49280031Sdim 50280031Sdim CoverageSourceInfo *CoverageInfo; 51280031Sdim 52193326Sed protected: 53276479Sdim std::unique_ptr<llvm::Module> M; 54276479Sdim std::unique_ptr<CodeGen::CodeGenModule> Builder; 55276479Sdim 56280031Sdim private: 57280031Sdim SmallVector<CXXMethodDecl *, 8> DeferredInlineMethodDefinitions; 58280031Sdim 59193326Sed public: 60288943Sdim CodeGeneratorImpl(DiagnosticsEngine &diags, const std::string &ModuleName, 61288943Sdim const HeaderSearchOptions &HSO, 62288943Sdim const PreprocessorOptions &PPO, const CodeGenOptions &CGO, 63288943Sdim llvm::LLVMContext &C, 64280031Sdim CoverageSourceInfo *CoverageInfo = nullptr) 65288943Sdim : Diags(diags), Ctx(nullptr), HeaderSearchOpts(HSO), 66288943Sdim PreprocessorOpts(PPO), CodeGenOpts(CGO), HandlingTopLevelDecls(0), 67288943Sdim CoverageInfo(CoverageInfo), 68288943Sdim M(new llvm::Module(ModuleName, C)) {} 69198092Srdivacky 70288943Sdim ~CodeGeneratorImpl() override { 71280031Sdim // There should normally not be any leftover inline method definitions. 72280031Sdim assert(DeferredInlineMethodDefinitions.empty() || 73280031Sdim Diags.hasErrorOccurred()); 74280031Sdim } 75198092Srdivacky 76276479Sdim llvm::Module* GetModule() override { 77193326Sed return M.get(); 78193326Sed } 79198092Srdivacky 80276479Sdim const Decl *GetDeclForMangledName(StringRef MangledName) override { 81276479Sdim GlobalDecl Result; 82276479Sdim if (!Builder->lookupRepresentativeDecl(MangledName, Result)) 83276479Sdim return nullptr; 84276479Sdim const Decl *D = Result.getCanonicalDecl().getDecl(); 85276479Sdim if (auto FD = dyn_cast<FunctionDecl>(D)) { 86276479Sdim if (FD->hasBody(FD)) 87276479Sdim return FD; 88276479Sdim } else if (auto TD = dyn_cast<TagDecl>(D)) { 89276479Sdim if (auto Def = TD->getDefinition()) 90276479Sdim return Def; 91276479Sdim } 92276479Sdim return D; 93193326Sed } 94198092Srdivacky 95276479Sdim llvm::Module *ReleaseModule() override { return M.release(); } 96276479Sdim 97276479Sdim void Initialize(ASTContext &Context) override { 98193326Sed Ctx = &Context; 99198092Srdivacky 100226633Sdim M->setTargetTriple(Ctx->getTargetInfo().getTriple().getTriple()); 101296417Sdim M->setDataLayout(Ctx->getTargetInfo().getDataLayoutString()); 102296417Sdim Builder.reset(new CodeGen::CodeGenModule(Context, HeaderSearchOpts, 103296417Sdim PreprocessorOpts, CodeGenOpts, 104296417Sdim *M, Diags, CoverageInfo)); 105261991Sdim 106261991Sdim for (size_t i = 0, e = CodeGenOpts.DependentLibraries.size(); i < e; ++i) 107261991Sdim HandleDependentLibrary(CodeGenOpts.DependentLibraries[i]); 108193326Sed } 109198092Srdivacky 110276479Sdim void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override { 111261991Sdim if (Diags.hasErrorOccurred()) 112261991Sdim return; 113261991Sdim 114234353Sdim Builder->HandleCXXStaticMemberVarInstantiation(VD); 115234353Sdim } 116234353Sdim 117276479Sdim bool HandleTopLevelDecl(DeclGroupRef DG) override { 118261991Sdim if (Diags.hasErrorOccurred()) 119261991Sdim return true; 120261991Sdim 121280031Sdim HandlingTopLevelDeclRAII HandlingDecl(*this); 122280031Sdim 123193326Sed // Make sure to emit all elements of a Decl. 124193326Sed for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I) 125193326Sed Builder->EmitTopLevelDecl(*I); 126276479Sdim 127234353Sdim return true; 128193326Sed } 129193326Sed 130280031Sdim void EmitDeferredDecls() { 131280031Sdim if (DeferredInlineMethodDefinitions.empty()) 132280031Sdim return; 133280031Sdim 134280031Sdim // Emit any deferred inline method definitions. Note that more deferred 135280031Sdim // methods may be added during this loop, since ASTConsumer callbacks 136280031Sdim // can be invoked if AST inspection results in declarations being added. 137280031Sdim HandlingTopLevelDeclRAII HandlingDecl(*this); 138280031Sdim for (unsigned I = 0; I != DeferredInlineMethodDefinitions.size(); ++I) 139280031Sdim Builder->EmitTopLevelDecl(DeferredInlineMethodDefinitions[I]); 140280031Sdim DeferredInlineMethodDefinitions.clear(); 141280031Sdim } 142280031Sdim 143276479Sdim void HandleInlineMethodDefinition(CXXMethodDecl *D) override { 144276479Sdim if (Diags.hasErrorOccurred()) 145276479Sdim return; 146276479Sdim 147276479Sdim assert(D->doesThisDeclarationHaveABody()); 148276479Sdim 149276479Sdim // We may want to emit this definition. However, that decision might be 150276479Sdim // based on computing the linkage, and we have to defer that in case we 151276479Sdim // are inside of something that will change the method's final linkage, 152276479Sdim // e.g. 153276479Sdim // typedef struct { 154276479Sdim // void bar(); 155276479Sdim // void foo() { bar(); } 156276479Sdim // } A; 157276479Sdim DeferredInlineMethodDefinitions.push_back(D); 158280031Sdim 159280031Sdim // Provide some coverage mapping even for methods that aren't emitted. 160280031Sdim // Don't do this for templated classes though, as they may not be 161280031Sdim // instantiable. 162280031Sdim if (!D->getParent()->getDescribedClassTemplate()) 163280031Sdim Builder->AddDeferredUnusedCoverageMapping(D); 164276479Sdim } 165276479Sdim 166193326Sed /// HandleTagDeclDefinition - This callback is invoked each time a TagDecl 167193326Sed /// to (e.g. struct, union, enum, class) is completed. This allows the 168193326Sed /// client hack on the type, which can occur at any point in the file 169193326Sed /// (because these can be defined in declspecs). 170276479Sdim void HandleTagDeclDefinition(TagDecl *D) override { 171261991Sdim if (Diags.hasErrorOccurred()) 172261991Sdim return; 173261991Sdim 174193326Sed Builder->UpdateCompletedType(D); 175276479Sdim 176276479Sdim // For MSVC compatibility, treat declarations of static data members with 177276479Sdim // inline initializers as definitions. 178296417Sdim if (Ctx->getTargetInfo().getCXXABI().isMicrosoft()) { 179276479Sdim for (Decl *Member : D->decls()) { 180276479Sdim if (VarDecl *VD = dyn_cast<VarDecl>(Member)) { 181276479Sdim if (Ctx->isMSStaticDataMemberInlineDefinition(VD) && 182276479Sdim Ctx->DeclMustBeEmitted(VD)) { 183276479Sdim Builder->EmitGlobal(VD); 184276479Sdim } 185276479Sdim } 186276479Sdim } 187218893Sdim } 188193326Sed } 189193326Sed 190276479Sdim void HandleTagDeclRequiredDefinition(const TagDecl *D) override { 191261991Sdim if (Diags.hasErrorOccurred()) 192261991Sdim return; 193261991Sdim 194261991Sdim if (CodeGen::CGDebugInfo *DI = Builder->getModuleDebugInfo()) 195261991Sdim if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) 196261991Sdim DI->completeRequiredType(RD); 197261991Sdim } 198261991Sdim 199276479Sdim void HandleTranslationUnit(ASTContext &Ctx) override { 200193326Sed if (Diags.hasErrorOccurred()) { 201276479Sdim if (Builder) 202276479Sdim Builder->clear(); 203193326Sed M.reset(); 204193326Sed return; 205193326Sed } 206193326Sed 207193326Sed if (Builder) 208193326Sed Builder->Release(); 209201361Srdivacky } 210193326Sed 211276479Sdim void CompleteTentativeDefinition(VarDecl *D) override { 212193326Sed if (Diags.hasErrorOccurred()) 213193326Sed return; 214193326Sed 215193326Sed Builder->EmitTentativeDefinition(D); 216193326Sed } 217208600Srdivacky 218288943Sdim void HandleVTable(CXXRecordDecl *RD) override { 219208600Srdivacky if (Diags.hasErrorOccurred()) 220208600Srdivacky return; 221208600Srdivacky 222288943Sdim Builder->EmitVTable(RD); 223208600Srdivacky } 224261991Sdim 225276479Sdim void HandleLinkerOptionPragma(llvm::StringRef Opts) override { 226261991Sdim Builder->AppendLinkerOptions(Opts); 227261991Sdim } 228261991Sdim 229276479Sdim void HandleDetectMismatch(llvm::StringRef Name, 230276479Sdim llvm::StringRef Value) override { 231261991Sdim Builder->AddDetectMismatch(Name, Value); 232261991Sdim } 233261991Sdim 234276479Sdim void HandleDependentLibrary(llvm::StringRef Lib) override { 235261991Sdim Builder->AddDependentLib(Lib); 236261991Sdim } 237193326Sed }; 238193326Sed} 239193326Sed 240234353Sdimvoid CodeGenerator::anchor() { } 241234353Sdim 242288943SdimCodeGenerator *clang::CreateLLVMCodeGen( 243288943Sdim DiagnosticsEngine &Diags, const std::string &ModuleName, 244288943Sdim const HeaderSearchOptions &HeaderSearchOpts, 245288943Sdim const PreprocessorOptions &PreprocessorOpts, const CodeGenOptions &CGO, 246288943Sdim llvm::LLVMContext &C, CoverageSourceInfo *CoverageInfo) { 247288943Sdim return new CodeGeneratorImpl(Diags, ModuleName, HeaderSearchOpts, 248288943Sdim PreprocessorOpts, CGO, C, CoverageInfo); 249193326Sed} 250