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