1 //===--- ModuleBuilder.cpp - Emit LLVM Code from ASTs ---------------------===// 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 // This builds an AST and converts it to LLVM Code. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/CodeGen/ModuleBuilder.h" 14 #include "CGDebugInfo.h" 15 #include "CodeGenModule.h" 16 #include "clang/AST/ASTContext.h" 17 #include "clang/AST/DeclObjC.h" 18 #include "clang/AST/Expr.h" 19 #include "clang/Basic/CodeGenOptions.h" 20 #include "clang/Basic/Diagnostic.h" 21 #include "clang/Basic/TargetInfo.h" 22 #include "llvm/ADT/StringRef.h" 23 #include "llvm/IR/DataLayout.h" 24 #include "llvm/IR/LLVMContext.h" 25 #include "llvm/IR/Module.h" 26 #include "llvm/Support/VirtualFileSystem.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 IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS; // Only used for debug info. 37 const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info. 38 const PreprocessorOptions &PreprocessorOpts; // Only used for debug info. 39 const CodeGenOptions &CodeGenOpts; 40 41 unsigned HandlingTopLevelDecls; 42 43 /// Use this when emitting decls to block re-entrant decl emission. It will 44 /// emit all deferred decls on scope exit. Set EmitDeferred to false if decl 45 /// emission must be deferred longer, like at the end of a tag definition. 46 struct HandlingTopLevelDeclRAII { 47 CodeGeneratorImpl &Self; 48 bool EmitDeferred; 49 HandlingTopLevelDeclRAII(CodeGeneratorImpl &Self, 50 bool EmitDeferred = true) 51 : Self(Self), EmitDeferred(EmitDeferred) { 52 ++Self.HandlingTopLevelDecls; 53 } 54 ~HandlingTopLevelDeclRAII() { 55 unsigned Level = --Self.HandlingTopLevelDecls; 56 if (Level == 0 && EmitDeferred) 57 Self.EmitDeferredDecls(); 58 } 59 }; 60 61 CoverageSourceInfo *CoverageInfo; 62 63 protected: 64 std::unique_ptr<llvm::Module> M; 65 std::unique_ptr<CodeGen::CodeGenModule> Builder; 66 67 private: 68 SmallVector<FunctionDecl *, 8> DeferredInlineMemberFuncDefs; 69 70 static llvm::StringRef ExpandModuleName(llvm::StringRef ModuleName, 71 const CodeGenOptions &CGO) { 72 if (ModuleName == "-" && !CGO.MainFileName.empty()) 73 return CGO.MainFileName; 74 return ModuleName; 75 } 76 77 public: 78 CodeGeneratorImpl(DiagnosticsEngine &diags, llvm::StringRef ModuleName, 79 IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS, 80 const HeaderSearchOptions &HSO, 81 const PreprocessorOptions &PPO, const CodeGenOptions &CGO, 82 llvm::LLVMContext &C, 83 CoverageSourceInfo *CoverageInfo = nullptr) 84 : Diags(diags), Ctx(nullptr), FS(std::move(FS)), HeaderSearchOpts(HSO), 85 PreprocessorOpts(PPO), CodeGenOpts(CGO), HandlingTopLevelDecls(0), 86 CoverageInfo(CoverageInfo), 87 M(new llvm::Module(ExpandModuleName(ModuleName, CGO), C)) { 88 C.setDiscardValueNames(CGO.DiscardValueNames); 89 } 90 91 ~CodeGeneratorImpl() override { 92 // There should normally not be any leftover inline method definitions. 93 assert(DeferredInlineMemberFuncDefs.empty() || 94 Diags.hasErrorOccurred()); 95 } 96 97 CodeGenModule &CGM() { 98 return *Builder; 99 } 100 101 llvm::Module *GetModule() { 102 return M.get(); 103 } 104 105 CGDebugInfo *getCGDebugInfo() { 106 return Builder->getModuleDebugInfo(); 107 } 108 109 llvm::Module *ReleaseModule() { 110 return M.release(); 111 } 112 113 const Decl *GetDeclForMangledName(StringRef MangledName) { 114 GlobalDecl Result; 115 if (!Builder->lookupRepresentativeDecl(MangledName, Result)) 116 return nullptr; 117 const Decl *D = Result.getCanonicalDecl().getDecl(); 118 if (auto FD = dyn_cast<FunctionDecl>(D)) { 119 if (FD->hasBody(FD)) 120 return FD; 121 } else if (auto TD = dyn_cast<TagDecl>(D)) { 122 if (auto Def = TD->getDefinition()) 123 return Def; 124 } 125 return D; 126 } 127 128 llvm::StringRef GetMangledName(GlobalDecl GD) { 129 return Builder->getMangledName(GD); 130 } 131 132 llvm::Constant *GetAddrOfGlobal(GlobalDecl global, bool isForDefinition) { 133 return Builder->GetAddrOfGlobal(global, ForDefinition_t(isForDefinition)); 134 } 135 136 llvm::Module *StartModule(llvm::StringRef ModuleName, 137 llvm::LLVMContext &C) { 138 assert(!M && "Replacing existing Module?"); 139 M.reset(new llvm::Module(ExpandModuleName(ModuleName, CodeGenOpts), C)); 140 141 std::unique_ptr<CodeGenModule> OldBuilder = std::move(Builder); 142 143 Initialize(*Ctx); 144 145 if (OldBuilder) 146 OldBuilder->moveLazyEmissionStates(Builder.get()); 147 148 return M.get(); 149 } 150 151 void Initialize(ASTContext &Context) override { 152 Ctx = &Context; 153 154 M->setTargetTriple(Ctx->getTargetInfo().getTriple().getTriple()); 155 M->setDataLayout(Ctx->getTargetInfo().getDataLayoutString()); 156 const auto &SDKVersion = Ctx->getTargetInfo().getSDKVersion(); 157 if (!SDKVersion.empty()) 158 M->setSDKVersion(SDKVersion); 159 if (const auto *TVT = Ctx->getTargetInfo().getDarwinTargetVariantTriple()) 160 M->setDarwinTargetVariantTriple(TVT->getTriple()); 161 if (auto TVSDKVersion = 162 Ctx->getTargetInfo().getDarwinTargetVariantSDKVersion()) 163 M->setDarwinTargetVariantSDKVersion(*TVSDKVersion); 164 Builder.reset(new CodeGen::CodeGenModule(Context, FS, HeaderSearchOpts, 165 PreprocessorOpts, CodeGenOpts, 166 *M, Diags, CoverageInfo)); 167 168 for (auto &&Lib : CodeGenOpts.DependentLibraries) 169 Builder->AddDependentLib(Lib); 170 for (auto &&Opt : CodeGenOpts.LinkerOptions) 171 Builder->AppendLinkerOptions(Opt); 172 } 173 174 void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override { 175 if (Diags.hasErrorOccurred()) 176 return; 177 178 Builder->HandleCXXStaticMemberVarInstantiation(VD); 179 } 180 181 bool HandleTopLevelDecl(DeclGroupRef DG) override { 182 // FIXME: Why not return false and abort parsing? 183 if (Diags.hasUnrecoverableErrorOccurred()) 184 return true; 185 186 HandlingTopLevelDeclRAII HandlingDecl(*this); 187 188 // Make sure to emit all elements of a Decl. 189 for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I) 190 Builder->EmitTopLevelDecl(*I); 191 192 return true; 193 } 194 195 void EmitDeferredDecls() { 196 if (DeferredInlineMemberFuncDefs.empty()) 197 return; 198 199 // Emit any deferred inline method definitions. Note that more deferred 200 // methods may be added during this loop, since ASTConsumer callbacks 201 // can be invoked if AST inspection results in declarations being added. 202 HandlingTopLevelDeclRAII HandlingDecl(*this); 203 for (unsigned I = 0; I != DeferredInlineMemberFuncDefs.size(); ++I) 204 Builder->EmitTopLevelDecl(DeferredInlineMemberFuncDefs[I]); 205 DeferredInlineMemberFuncDefs.clear(); 206 } 207 208 void HandleInlineFunctionDefinition(FunctionDecl *D) override { 209 if (Diags.hasUnrecoverableErrorOccurred()) 210 return; 211 212 assert(D->doesThisDeclarationHaveABody()); 213 214 // We may want to emit this definition. However, that decision might be 215 // based on computing the linkage, and we have to defer that in case we 216 // are inside of something that will change the method's final linkage, 217 // e.g. 218 // typedef struct { 219 // void bar(); 220 // void foo() { bar(); } 221 // } A; 222 DeferredInlineMemberFuncDefs.push_back(D); 223 224 // Provide some coverage mapping even for methods that aren't emitted. 225 // Don't do this for templated classes though, as they may not be 226 // instantiable. 227 if (!D->getLexicalDeclContext()->isDependentContext()) 228 Builder->AddDeferredUnusedCoverageMapping(D); 229 } 230 231 /// HandleTagDeclDefinition - This callback is invoked each time a TagDecl 232 /// to (e.g. struct, union, enum, class) is completed. This allows the 233 /// client hack on the type, which can occur at any point in the file 234 /// (because these can be defined in declspecs). 235 void HandleTagDeclDefinition(TagDecl *D) override { 236 if (Diags.hasUnrecoverableErrorOccurred()) 237 return; 238 239 // Don't allow re-entrant calls to CodeGen triggered by PCH 240 // deserialization to emit deferred decls. 241 HandlingTopLevelDeclRAII HandlingDecl(*this, /*EmitDeferred=*/false); 242 243 Builder->UpdateCompletedType(D); 244 245 // For MSVC compatibility, treat declarations of static data members with 246 // inline initializers as definitions. 247 if (Ctx->getTargetInfo().getCXXABI().isMicrosoft()) { 248 for (Decl *Member : D->decls()) { 249 if (VarDecl *VD = dyn_cast<VarDecl>(Member)) { 250 if (Ctx->isMSStaticDataMemberInlineDefinition(VD) && 251 Ctx->DeclMustBeEmitted(VD)) { 252 Builder->EmitGlobal(VD); 253 } 254 } 255 } 256 } 257 // For OpenMP emit declare reduction functions, if required. 258 if (Ctx->getLangOpts().OpenMP) { 259 for (Decl *Member : D->decls()) { 260 if (auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Member)) { 261 if (Ctx->DeclMustBeEmitted(DRD)) 262 Builder->EmitGlobal(DRD); 263 } else if (auto *DMD = dyn_cast<OMPDeclareMapperDecl>(Member)) { 264 if (Ctx->DeclMustBeEmitted(DMD)) 265 Builder->EmitGlobal(DMD); 266 } 267 } 268 } 269 } 270 271 void HandleTagDeclRequiredDefinition(const TagDecl *D) override { 272 if (Diags.hasUnrecoverableErrorOccurred()) 273 return; 274 275 // Don't allow re-entrant calls to CodeGen triggered by PCH 276 // deserialization to emit deferred decls. 277 HandlingTopLevelDeclRAII HandlingDecl(*this, /*EmitDeferred=*/false); 278 279 if (CodeGen::CGDebugInfo *DI = Builder->getModuleDebugInfo()) 280 if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) 281 DI->completeRequiredType(RD); 282 } 283 284 void HandleTranslationUnit(ASTContext &Ctx) override { 285 // Release the Builder when there is no error. 286 if (!Diags.hasUnrecoverableErrorOccurred() && Builder) 287 Builder->Release(); 288 289 // If there are errors before or when releasing the Builder, reset 290 // the module to stop here before invoking the backend. 291 if (Diags.hasErrorOccurred()) { 292 if (Builder) 293 Builder->clear(); 294 M.reset(); 295 return; 296 } 297 } 298 299 void AssignInheritanceModel(CXXRecordDecl *RD) override { 300 if (Diags.hasUnrecoverableErrorOccurred()) 301 return; 302 303 Builder->RefreshTypeCacheForClass(RD); 304 } 305 306 void CompleteTentativeDefinition(VarDecl *D) override { 307 if (Diags.hasUnrecoverableErrorOccurred()) 308 return; 309 310 Builder->EmitTentativeDefinition(D); 311 } 312 313 void CompleteExternalDeclaration(DeclaratorDecl *D) override { 314 Builder->EmitExternalDeclaration(D); 315 } 316 317 void HandleVTable(CXXRecordDecl *RD) override { 318 if (Diags.hasUnrecoverableErrorOccurred()) 319 return; 320 321 Builder->EmitVTable(RD); 322 } 323 }; 324 } 325 326 void CodeGenerator::anchor() { } 327 328 CodeGenModule &CodeGenerator::CGM() { 329 return static_cast<CodeGeneratorImpl*>(this)->CGM(); 330 } 331 332 llvm::Module *CodeGenerator::GetModule() { 333 return static_cast<CodeGeneratorImpl*>(this)->GetModule(); 334 } 335 336 llvm::Module *CodeGenerator::ReleaseModule() { 337 return static_cast<CodeGeneratorImpl*>(this)->ReleaseModule(); 338 } 339 340 CGDebugInfo *CodeGenerator::getCGDebugInfo() { 341 return static_cast<CodeGeneratorImpl*>(this)->getCGDebugInfo(); 342 } 343 344 const Decl *CodeGenerator::GetDeclForMangledName(llvm::StringRef name) { 345 return static_cast<CodeGeneratorImpl*>(this)->GetDeclForMangledName(name); 346 } 347 348 llvm::StringRef CodeGenerator::GetMangledName(GlobalDecl GD) { 349 return static_cast<CodeGeneratorImpl *>(this)->GetMangledName(GD); 350 } 351 352 llvm::Constant *CodeGenerator::GetAddrOfGlobal(GlobalDecl global, 353 bool isForDefinition) { 354 return static_cast<CodeGeneratorImpl*>(this) 355 ->GetAddrOfGlobal(global, isForDefinition); 356 } 357 358 llvm::Module *CodeGenerator::StartModule(llvm::StringRef ModuleName, 359 llvm::LLVMContext &C) { 360 return static_cast<CodeGeneratorImpl*>(this)->StartModule(ModuleName, C); 361 } 362 363 CodeGenerator * 364 clang::CreateLLVMCodeGen(DiagnosticsEngine &Diags, llvm::StringRef ModuleName, 365 IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS, 366 const HeaderSearchOptions &HeaderSearchOpts, 367 const PreprocessorOptions &PreprocessorOpts, 368 const CodeGenOptions &CGO, llvm::LLVMContext &C, 369 CoverageSourceInfo *CoverageInfo) { 370 return new CodeGeneratorImpl(Diags, ModuleName, std::move(FS), 371 HeaderSearchOpts, PreprocessorOpts, CGO, C, 372 CoverageInfo); 373 } 374