1 //===--- DIBuilder.cpp - Debug Information Builder ------------------------===// 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 file implements the DIBuilder. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/IR/DIBuilder.h" 14 #include "llvm/IR/IRBuilder.h" 15 #include "LLVMContextImpl.h" 16 #include "llvm/ADT/Optional.h" 17 #include "llvm/ADT/STLExtras.h" 18 #include "llvm/BinaryFormat/Dwarf.h" 19 #include "llvm/IR/Constants.h" 20 #include "llvm/IR/DebugInfo.h" 21 #include "llvm/IR/IntrinsicInst.h" 22 #include "llvm/IR/Module.h" 23 #include "llvm/Support/Debug.h" 24 25 using namespace llvm; 26 using namespace llvm::dwarf; 27 28 cl::opt<bool> 29 UseDbgAddr("use-dbg-addr", 30 llvm::cl::desc("Use llvm.dbg.addr for all local variables"), 31 cl::init(false), cl::Hidden); 32 33 DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes, DICompileUnit *CU) 34 : M(m), VMContext(M.getContext()), CUNode(CU), 35 DeclareFn(nullptr), ValueFn(nullptr), LabelFn(nullptr), 36 AllowUnresolvedNodes(AllowUnresolvedNodes) {} 37 38 void DIBuilder::trackIfUnresolved(MDNode *N) { 39 if (!N) 40 return; 41 if (N->isResolved()) 42 return; 43 44 assert(AllowUnresolvedNodes && "Cannot handle unresolved nodes"); 45 UnresolvedNodes.emplace_back(N); 46 } 47 48 void DIBuilder::finalizeSubprogram(DISubprogram *SP) { 49 MDTuple *Temp = SP->getRetainedNodes().get(); 50 if (!Temp || !Temp->isTemporary()) 51 return; 52 53 SmallVector<Metadata *, 16> RetainedNodes; 54 55 auto PV = PreservedVariables.find(SP); 56 if (PV != PreservedVariables.end()) 57 RetainedNodes.append(PV->second.begin(), PV->second.end()); 58 59 auto PL = PreservedLabels.find(SP); 60 if (PL != PreservedLabels.end()) 61 RetainedNodes.append(PL->second.begin(), PL->second.end()); 62 63 DINodeArray Node = getOrCreateArray(RetainedNodes); 64 65 TempMDTuple(Temp)->replaceAllUsesWith(Node.get()); 66 } 67 68 void DIBuilder::finalize() { 69 if (!CUNode) { 70 assert(!AllowUnresolvedNodes && 71 "creating type nodes without a CU is not supported"); 72 return; 73 } 74 75 CUNode->replaceEnumTypes(MDTuple::get(VMContext, AllEnumTypes)); 76 77 SmallVector<Metadata *, 16> RetainValues; 78 // Declarations and definitions of the same type may be retained. Some 79 // clients RAUW these pairs, leaving duplicates in the retained types 80 // list. Use a set to remove the duplicates while we transform the 81 // TrackingVHs back into Values. 82 SmallPtrSet<Metadata *, 16> RetainSet; 83 for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++) 84 if (RetainSet.insert(AllRetainTypes[I]).second) 85 RetainValues.push_back(AllRetainTypes[I]); 86 87 if (!RetainValues.empty()) 88 CUNode->replaceRetainedTypes(MDTuple::get(VMContext, RetainValues)); 89 90 DISubprogramArray SPs = MDTuple::get(VMContext, AllSubprograms); 91 for (auto *SP : SPs) 92 finalizeSubprogram(SP); 93 for (auto *N : RetainValues) 94 if (auto *SP = dyn_cast<DISubprogram>(N)) 95 finalizeSubprogram(SP); 96 97 if (!AllGVs.empty()) 98 CUNode->replaceGlobalVariables(MDTuple::get(VMContext, AllGVs)); 99 100 if (!AllImportedModules.empty()) 101 CUNode->replaceImportedEntities(MDTuple::get( 102 VMContext, SmallVector<Metadata *, 16>(AllImportedModules.begin(), 103 AllImportedModules.end()))); 104 105 for (const auto &I : AllMacrosPerParent) { 106 // DIMacroNode's with nullptr parent are DICompileUnit direct children. 107 if (!I.first) { 108 CUNode->replaceMacros(MDTuple::get(VMContext, I.second.getArrayRef())); 109 continue; 110 } 111 // Otherwise, it must be a temporary DIMacroFile that need to be resolved. 112 auto *TMF = cast<DIMacroFile>(I.first); 113 auto *MF = DIMacroFile::get(VMContext, dwarf::DW_MACINFO_start_file, 114 TMF->getLine(), TMF->getFile(), 115 getOrCreateMacroArray(I.second.getArrayRef())); 116 replaceTemporary(llvm::TempDIMacroNode(TMF), MF); 117 } 118 119 // Now that all temp nodes have been replaced or deleted, resolve remaining 120 // cycles. 121 for (const auto &N : UnresolvedNodes) 122 if (N && !N->isResolved()) 123 N->resolveCycles(); 124 UnresolvedNodes.clear(); 125 126 // Can't handle unresolved nodes anymore. 127 AllowUnresolvedNodes = false; 128 } 129 130 /// If N is compile unit return NULL otherwise return N. 131 static DIScope *getNonCompileUnitScope(DIScope *N) { 132 if (!N || isa<DICompileUnit>(N)) 133 return nullptr; 134 return cast<DIScope>(N); 135 } 136 137 DICompileUnit *DIBuilder::createCompileUnit( 138 unsigned Lang, DIFile *File, StringRef Producer, bool isOptimized, 139 StringRef Flags, unsigned RunTimeVer, StringRef SplitName, 140 DICompileUnit::DebugEmissionKind Kind, uint64_t DWOId, 141 bool SplitDebugInlining, bool DebugInfoForProfiling, 142 DICompileUnit::DebugNameTableKind NameTableKind, bool RangesBaseAddress) { 143 144 assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) || 145 (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) && 146 "Invalid Language tag"); 147 148 assert(!CUNode && "Can only make one compile unit per DIBuilder instance"); 149 CUNode = DICompileUnit::getDistinct( 150 VMContext, Lang, File, Producer, isOptimized, Flags, RunTimeVer, 151 SplitName, Kind, nullptr, nullptr, nullptr, nullptr, nullptr, DWOId, 152 SplitDebugInlining, DebugInfoForProfiling, NameTableKind, 153 RangesBaseAddress); 154 155 // Create a named metadata so that it is easier to find cu in a module. 156 NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu"); 157 NMD->addOperand(CUNode); 158 trackIfUnresolved(CUNode); 159 return CUNode; 160 } 161 162 static DIImportedEntity * 163 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context, 164 Metadata *NS, DIFile *File, unsigned Line, StringRef Name, 165 SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) { 166 if (Line) 167 assert(File && "Source location has line number but no file"); 168 unsigned EntitiesCount = C.pImpl->DIImportedEntitys.size(); 169 auto *M = DIImportedEntity::get(C, Tag, Context, cast_or_null<DINode>(NS), 170 File, Line, Name); 171 if (EntitiesCount < C.pImpl->DIImportedEntitys.size()) 172 // A new Imported Entity was just added to the context. 173 // Add it to the Imported Modules list. 174 AllImportedModules.emplace_back(M); 175 return M; 176 } 177 178 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context, 179 DINamespace *NS, DIFile *File, 180 unsigned Line) { 181 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module, 182 Context, NS, File, Line, StringRef(), 183 AllImportedModules); 184 } 185 186 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context, 187 DIImportedEntity *NS, 188 DIFile *File, unsigned Line) { 189 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module, 190 Context, NS, File, Line, StringRef(), 191 AllImportedModules); 192 } 193 194 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context, DIModule *M, 195 DIFile *File, unsigned Line) { 196 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module, 197 Context, M, File, Line, StringRef(), 198 AllImportedModules); 199 } 200 201 DIImportedEntity *DIBuilder::createImportedDeclaration(DIScope *Context, 202 DINode *Decl, 203 DIFile *File, 204 unsigned Line, 205 StringRef Name) { 206 // Make sure to use the unique identifier based metadata reference for 207 // types that have one. 208 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration, 209 Context, Decl, File, Line, Name, 210 AllImportedModules); 211 } 212 213 DIFile *DIBuilder::createFile(StringRef Filename, StringRef Directory, 214 Optional<DIFile::ChecksumInfo<StringRef>> CS, 215 Optional<StringRef> Source) { 216 return DIFile::get(VMContext, Filename, Directory, CS, Source); 217 } 218 219 DIMacro *DIBuilder::createMacro(DIMacroFile *Parent, unsigned LineNumber, 220 unsigned MacroType, StringRef Name, 221 StringRef Value) { 222 assert(!Name.empty() && "Unable to create macro without name"); 223 assert((MacroType == dwarf::DW_MACINFO_undef || 224 MacroType == dwarf::DW_MACINFO_define) && 225 "Unexpected macro type"); 226 auto *M = DIMacro::get(VMContext, MacroType, LineNumber, Name, Value); 227 AllMacrosPerParent[Parent].insert(M); 228 return M; 229 } 230 231 DIMacroFile *DIBuilder::createTempMacroFile(DIMacroFile *Parent, 232 unsigned LineNumber, DIFile *File) { 233 auto *MF = DIMacroFile::getTemporary(VMContext, dwarf::DW_MACINFO_start_file, 234 LineNumber, File, DIMacroNodeArray()) 235 .release(); 236 AllMacrosPerParent[Parent].insert(MF); 237 // Add the new temporary DIMacroFile to the macro per parent map as a parent. 238 // This is needed to assure DIMacroFile with no children to have an entry in 239 // the map. Otherwise, it will not be resolved in DIBuilder::finalize(). 240 AllMacrosPerParent.insert({MF, {}}); 241 return MF; 242 } 243 244 DIEnumerator *DIBuilder::createEnumerator(StringRef Name, int64_t Val, 245 bool IsUnsigned) { 246 assert(!Name.empty() && "Unable to create enumerator without name"); 247 return DIEnumerator::get(VMContext, Val, IsUnsigned, Name); 248 } 249 250 DIBasicType *DIBuilder::createUnspecifiedType(StringRef Name) { 251 assert(!Name.empty() && "Unable to create type without name"); 252 return DIBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name); 253 } 254 255 DIBasicType *DIBuilder::createNullPtrType() { 256 return createUnspecifiedType("decltype(nullptr)"); 257 } 258 259 DIBasicType *DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits, 260 unsigned Encoding, 261 DINode::DIFlags Flags) { 262 assert(!Name.empty() && "Unable to create type without name"); 263 return DIBasicType::get(VMContext, dwarf::DW_TAG_base_type, Name, SizeInBits, 264 0, Encoding, Flags); 265 } 266 267 DIDerivedType *DIBuilder::createQualifiedType(unsigned Tag, DIType *FromTy) { 268 return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, FromTy, 0, 269 0, 0, None, DINode::FlagZero); 270 } 271 272 DIDerivedType *DIBuilder::createPointerType( 273 DIType *PointeeTy, 274 uint64_t SizeInBits, 275 uint32_t AlignInBits, 276 Optional<unsigned> DWARFAddressSpace, 277 StringRef Name) { 278 // FIXME: Why is there a name here? 279 return DIDerivedType::get(VMContext, dwarf::DW_TAG_pointer_type, Name, 280 nullptr, 0, nullptr, PointeeTy, SizeInBits, 281 AlignInBits, 0, DWARFAddressSpace, 282 DINode::FlagZero); 283 } 284 285 DIDerivedType *DIBuilder::createMemberPointerType(DIType *PointeeTy, 286 DIType *Base, 287 uint64_t SizeInBits, 288 uint32_t AlignInBits, 289 DINode::DIFlags Flags) { 290 return DIDerivedType::get(VMContext, dwarf::DW_TAG_ptr_to_member_type, "", 291 nullptr, 0, nullptr, PointeeTy, SizeInBits, 292 AlignInBits, 0, None, Flags, Base); 293 } 294 295 DIDerivedType *DIBuilder::createReferenceType( 296 unsigned Tag, DIType *RTy, 297 uint64_t SizeInBits, 298 uint32_t AlignInBits, 299 Optional<unsigned> DWARFAddressSpace) { 300 assert(RTy && "Unable to create reference type"); 301 return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, RTy, 302 SizeInBits, AlignInBits, 0, DWARFAddressSpace, 303 DINode::FlagZero); 304 } 305 306 DIDerivedType *DIBuilder::createTypedef(DIType *Ty, StringRef Name, 307 DIFile *File, unsigned LineNo, 308 DIScope *Context) { 309 return DIDerivedType::get(VMContext, dwarf::DW_TAG_typedef, Name, File, 310 LineNo, getNonCompileUnitScope(Context), Ty, 0, 0, 311 0, None, DINode::FlagZero); 312 } 313 314 DIDerivedType *DIBuilder::createFriend(DIType *Ty, DIType *FriendTy) { 315 assert(Ty && "Invalid type!"); 316 assert(FriendTy && "Invalid friend type!"); 317 return DIDerivedType::get(VMContext, dwarf::DW_TAG_friend, "", nullptr, 0, Ty, 318 FriendTy, 0, 0, 0, None, DINode::FlagZero); 319 } 320 321 DIDerivedType *DIBuilder::createInheritance(DIType *Ty, DIType *BaseTy, 322 uint64_t BaseOffset, 323 uint32_t VBPtrOffset, 324 DINode::DIFlags Flags) { 325 assert(Ty && "Unable to create inheritance"); 326 Metadata *ExtraData = ConstantAsMetadata::get( 327 ConstantInt::get(IntegerType::get(VMContext, 32), VBPtrOffset)); 328 return DIDerivedType::get(VMContext, dwarf::DW_TAG_inheritance, "", nullptr, 329 0, Ty, BaseTy, 0, 0, BaseOffset, None, 330 Flags, ExtraData); 331 } 332 333 DIDerivedType *DIBuilder::createMemberType(DIScope *Scope, StringRef Name, 334 DIFile *File, unsigned LineNumber, 335 uint64_t SizeInBits, 336 uint32_t AlignInBits, 337 uint64_t OffsetInBits, 338 DINode::DIFlags Flags, DIType *Ty) { 339 return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File, 340 LineNumber, getNonCompileUnitScope(Scope), Ty, 341 SizeInBits, AlignInBits, OffsetInBits, None, Flags); 342 } 343 344 static ConstantAsMetadata *getConstantOrNull(Constant *C) { 345 if (C) 346 return ConstantAsMetadata::get(C); 347 return nullptr; 348 } 349 350 DIDerivedType *DIBuilder::createVariantMemberType( 351 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, 352 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, 353 Constant *Discriminant, DINode::DIFlags Flags, DIType *Ty) { 354 return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File, 355 LineNumber, getNonCompileUnitScope(Scope), Ty, 356 SizeInBits, AlignInBits, OffsetInBits, None, Flags, 357 getConstantOrNull(Discriminant)); 358 } 359 360 DIDerivedType *DIBuilder::createBitFieldMemberType( 361 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, 362 uint64_t SizeInBits, uint64_t OffsetInBits, uint64_t StorageOffsetInBits, 363 DINode::DIFlags Flags, DIType *Ty) { 364 Flags |= DINode::FlagBitField; 365 return DIDerivedType::get( 366 VMContext, dwarf::DW_TAG_member, Name, File, LineNumber, 367 getNonCompileUnitScope(Scope), Ty, SizeInBits, /* AlignInBits */ 0, 368 OffsetInBits, None, Flags, 369 ConstantAsMetadata::get(ConstantInt::get(IntegerType::get(VMContext, 64), 370 StorageOffsetInBits))); 371 } 372 373 DIDerivedType * 374 DIBuilder::createStaticMemberType(DIScope *Scope, StringRef Name, DIFile *File, 375 unsigned LineNumber, DIType *Ty, 376 DINode::DIFlags Flags, llvm::Constant *Val, 377 uint32_t AlignInBits) { 378 Flags |= DINode::FlagStaticMember; 379 return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File, 380 LineNumber, getNonCompileUnitScope(Scope), Ty, 0, 381 AlignInBits, 0, None, Flags, 382 getConstantOrNull(Val)); 383 } 384 385 DIDerivedType * 386 DIBuilder::createObjCIVar(StringRef Name, DIFile *File, unsigned LineNumber, 387 uint64_t SizeInBits, uint32_t AlignInBits, 388 uint64_t OffsetInBits, DINode::DIFlags Flags, 389 DIType *Ty, MDNode *PropertyNode) { 390 return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File, 391 LineNumber, getNonCompileUnitScope(File), Ty, 392 SizeInBits, AlignInBits, OffsetInBits, None, Flags, 393 PropertyNode); 394 } 395 396 DIObjCProperty * 397 DIBuilder::createObjCProperty(StringRef Name, DIFile *File, unsigned LineNumber, 398 StringRef GetterName, StringRef SetterName, 399 unsigned PropertyAttributes, DIType *Ty) { 400 return DIObjCProperty::get(VMContext, Name, File, LineNumber, GetterName, 401 SetterName, PropertyAttributes, Ty); 402 } 403 404 DITemplateTypeParameter * 405 DIBuilder::createTemplateTypeParameter(DIScope *Context, StringRef Name, 406 DIType *Ty) { 407 assert((!Context || isa<DICompileUnit>(Context)) && "Expected compile unit"); 408 return DITemplateTypeParameter::get(VMContext, Name, Ty); 409 } 410 411 static DITemplateValueParameter * 412 createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag, 413 DIScope *Context, StringRef Name, DIType *Ty, 414 Metadata *MD) { 415 assert((!Context || isa<DICompileUnit>(Context)) && "Expected compile unit"); 416 return DITemplateValueParameter::get(VMContext, Tag, Name, Ty, MD); 417 } 418 419 DITemplateValueParameter * 420 DIBuilder::createTemplateValueParameter(DIScope *Context, StringRef Name, 421 DIType *Ty, Constant *Val) { 422 return createTemplateValueParameterHelper( 423 VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty, 424 getConstantOrNull(Val)); 425 } 426 427 DITemplateValueParameter * 428 DIBuilder::createTemplateTemplateParameter(DIScope *Context, StringRef Name, 429 DIType *Ty, StringRef Val) { 430 return createTemplateValueParameterHelper( 431 VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty, 432 MDString::get(VMContext, Val)); 433 } 434 435 DITemplateValueParameter * 436 DIBuilder::createTemplateParameterPack(DIScope *Context, StringRef Name, 437 DIType *Ty, DINodeArray Val) { 438 return createTemplateValueParameterHelper( 439 VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty, 440 Val.get()); 441 } 442 443 DICompositeType *DIBuilder::createClassType( 444 DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber, 445 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, 446 DINode::DIFlags Flags, DIType *DerivedFrom, DINodeArray Elements, 447 DIType *VTableHolder, MDNode *TemplateParams, StringRef UniqueIdentifier) { 448 assert((!Context || isa<DIScope>(Context)) && 449 "createClassType should be called with a valid Context"); 450 451 auto *R = DICompositeType::get( 452 VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber, 453 getNonCompileUnitScope(Context), DerivedFrom, SizeInBits, AlignInBits, 454 OffsetInBits, Flags, Elements, 0, VTableHolder, 455 cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier); 456 trackIfUnresolved(R); 457 return R; 458 } 459 460 DICompositeType *DIBuilder::createStructType( 461 DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber, 462 uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags, 463 DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang, 464 DIType *VTableHolder, StringRef UniqueIdentifier) { 465 auto *R = DICompositeType::get( 466 VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber, 467 getNonCompileUnitScope(Context), DerivedFrom, SizeInBits, AlignInBits, 0, 468 Flags, Elements, RunTimeLang, VTableHolder, nullptr, UniqueIdentifier); 469 trackIfUnresolved(R); 470 return R; 471 } 472 473 DICompositeType *DIBuilder::createUnionType( 474 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, 475 uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags, 476 DINodeArray Elements, unsigned RunTimeLang, StringRef UniqueIdentifier) { 477 auto *R = DICompositeType::get( 478 VMContext, dwarf::DW_TAG_union_type, Name, File, LineNumber, 479 getNonCompileUnitScope(Scope), nullptr, SizeInBits, AlignInBits, 0, Flags, 480 Elements, RunTimeLang, nullptr, nullptr, UniqueIdentifier); 481 trackIfUnresolved(R); 482 return R; 483 } 484 485 DICompositeType *DIBuilder::createVariantPart( 486 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, 487 uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags, 488 DIDerivedType *Discriminator, DINodeArray Elements, StringRef UniqueIdentifier) { 489 auto *R = DICompositeType::get( 490 VMContext, dwarf::DW_TAG_variant_part, Name, File, LineNumber, 491 getNonCompileUnitScope(Scope), nullptr, SizeInBits, AlignInBits, 0, Flags, 492 Elements, 0, nullptr, nullptr, UniqueIdentifier, Discriminator); 493 trackIfUnresolved(R); 494 return R; 495 } 496 497 DISubroutineType *DIBuilder::createSubroutineType(DITypeRefArray ParameterTypes, 498 DINode::DIFlags Flags, 499 unsigned CC) { 500 return DISubroutineType::get(VMContext, Flags, CC, ParameterTypes); 501 } 502 503 DICompositeType *DIBuilder::createEnumerationType( 504 DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber, 505 uint64_t SizeInBits, uint32_t AlignInBits, DINodeArray Elements, 506 DIType *UnderlyingType, StringRef UniqueIdentifier, bool IsScoped) { 507 auto *CTy = DICompositeType::get( 508 VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber, 509 getNonCompileUnitScope(Scope), UnderlyingType, SizeInBits, AlignInBits, 0, 510 IsScoped ? DINode::FlagEnumClass : DINode::FlagZero, Elements, 0, nullptr, 511 nullptr, UniqueIdentifier); 512 AllEnumTypes.push_back(CTy); 513 trackIfUnresolved(CTy); 514 return CTy; 515 } 516 517 DICompositeType *DIBuilder::createArrayType(uint64_t Size, 518 uint32_t AlignInBits, DIType *Ty, 519 DINodeArray Subscripts) { 520 auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "", 521 nullptr, 0, nullptr, Ty, Size, AlignInBits, 0, 522 DINode::FlagZero, Subscripts, 0, nullptr); 523 trackIfUnresolved(R); 524 return R; 525 } 526 527 DICompositeType *DIBuilder::createVectorType(uint64_t Size, 528 uint32_t AlignInBits, DIType *Ty, 529 DINodeArray Subscripts) { 530 auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "", 531 nullptr, 0, nullptr, Ty, Size, AlignInBits, 0, 532 DINode::FlagVector, Subscripts, 0, nullptr); 533 trackIfUnresolved(R); 534 return R; 535 } 536 537 DISubprogram *DIBuilder::createArtificialSubprogram(DISubprogram *SP) { 538 auto NewSP = SP->cloneWithFlags(SP->getFlags() | DINode::FlagArtificial); 539 return MDNode::replaceWithDistinct(std::move(NewSP)); 540 } 541 542 static DIType *createTypeWithFlags(const DIType *Ty, 543 DINode::DIFlags FlagsToSet) { 544 auto NewTy = Ty->cloneWithFlags(Ty->getFlags() | FlagsToSet); 545 return MDNode::replaceWithUniqued(std::move(NewTy)); 546 } 547 548 DIType *DIBuilder::createArtificialType(DIType *Ty) { 549 // FIXME: Restrict this to the nodes where it's valid. 550 if (Ty->isArtificial()) 551 return Ty; 552 return createTypeWithFlags(Ty, DINode::FlagArtificial); 553 } 554 555 DIType *DIBuilder::createObjectPointerType(DIType *Ty) { 556 // FIXME: Restrict this to the nodes where it's valid. 557 if (Ty->isObjectPointer()) 558 return Ty; 559 DINode::DIFlags Flags = DINode::FlagObjectPointer | DINode::FlagArtificial; 560 return createTypeWithFlags(Ty, Flags); 561 } 562 563 void DIBuilder::retainType(DIScope *T) { 564 assert(T && "Expected non-null type"); 565 assert((isa<DIType>(T) || (isa<DISubprogram>(T) && 566 cast<DISubprogram>(T)->isDefinition() == false)) && 567 "Expected type or subprogram declaration"); 568 AllRetainTypes.emplace_back(T); 569 } 570 571 DIBasicType *DIBuilder::createUnspecifiedParameter() { return nullptr; } 572 573 DICompositeType * 574 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIScope *Scope, 575 DIFile *F, unsigned Line, unsigned RuntimeLang, 576 uint64_t SizeInBits, uint32_t AlignInBits, 577 StringRef UniqueIdentifier) { 578 // FIXME: Define in terms of createReplaceableForwardDecl() by calling 579 // replaceWithUniqued(). 580 auto *RetTy = DICompositeType::get( 581 VMContext, Tag, Name, F, Line, getNonCompileUnitScope(Scope), nullptr, 582 SizeInBits, AlignInBits, 0, DINode::FlagFwdDecl, nullptr, RuntimeLang, 583 nullptr, nullptr, UniqueIdentifier); 584 trackIfUnresolved(RetTy); 585 return RetTy; 586 } 587 588 DICompositeType *DIBuilder::createReplaceableCompositeType( 589 unsigned Tag, StringRef Name, DIScope *Scope, DIFile *F, unsigned Line, 590 unsigned RuntimeLang, uint64_t SizeInBits, uint32_t AlignInBits, 591 DINode::DIFlags Flags, StringRef UniqueIdentifier) { 592 auto *RetTy = 593 DICompositeType::getTemporary( 594 VMContext, Tag, Name, F, Line, getNonCompileUnitScope(Scope), nullptr, 595 SizeInBits, AlignInBits, 0, Flags, nullptr, RuntimeLang, nullptr, 596 nullptr, UniqueIdentifier) 597 .release(); 598 trackIfUnresolved(RetTy); 599 return RetTy; 600 } 601 602 DINodeArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) { 603 return MDTuple::get(VMContext, Elements); 604 } 605 606 DIMacroNodeArray 607 DIBuilder::getOrCreateMacroArray(ArrayRef<Metadata *> Elements) { 608 return MDTuple::get(VMContext, Elements); 609 } 610 611 DITypeRefArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) { 612 SmallVector<llvm::Metadata *, 16> Elts; 613 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 614 if (Elements[i] && isa<MDNode>(Elements[i])) 615 Elts.push_back(cast<DIType>(Elements[i])); 616 else 617 Elts.push_back(Elements[i]); 618 } 619 return DITypeRefArray(MDNode::get(VMContext, Elts)); 620 } 621 622 DISubrange *DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) { 623 return DISubrange::get(VMContext, Count, Lo); 624 } 625 626 DISubrange *DIBuilder::getOrCreateSubrange(int64_t Lo, Metadata *CountNode) { 627 return DISubrange::get(VMContext, CountNode, Lo); 628 } 629 630 static void checkGlobalVariableScope(DIScope *Context) { 631 #ifndef NDEBUG 632 if (auto *CT = 633 dyn_cast_or_null<DICompositeType>(getNonCompileUnitScope(Context))) 634 assert(CT->getIdentifier().empty() && 635 "Context of a global variable should not be a type with identifier"); 636 #endif 637 } 638 639 DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression( 640 DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F, 641 unsigned LineNumber, DIType *Ty, bool isLocalToUnit, DIExpression *Expr, 642 MDNode *Decl, MDTuple *templateParams, uint32_t AlignInBits) { 643 checkGlobalVariableScope(Context); 644 645 auto *GV = DIGlobalVariable::getDistinct( 646 VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F, 647 LineNumber, Ty, isLocalToUnit, true, cast_or_null<DIDerivedType>(Decl), 648 templateParams, AlignInBits); 649 if (!Expr) 650 Expr = createExpression(); 651 auto *N = DIGlobalVariableExpression::get(VMContext, GV, Expr); 652 AllGVs.push_back(N); 653 return N; 654 } 655 656 DIGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl( 657 DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F, 658 unsigned LineNumber, DIType *Ty, bool isLocalToUnit, MDNode *Decl, 659 MDTuple *templateParams, uint32_t AlignInBits) { 660 checkGlobalVariableScope(Context); 661 662 return DIGlobalVariable::getTemporary( 663 VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F, 664 LineNumber, Ty, isLocalToUnit, false, 665 cast_or_null<DIDerivedType>(Decl), templateParams, AlignInBits) 666 .release(); 667 } 668 669 static DILocalVariable *createLocalVariable( 670 LLVMContext &VMContext, 671 DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> &PreservedVariables, 672 DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File, 673 unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags, 674 uint32_t AlignInBits) { 675 // FIXME: Why getNonCompileUnitScope()? 676 // FIXME: Why is "!Context" okay here? 677 // FIXME: Why doesn't this check for a subprogram or lexical block (AFAICT 678 // the only valid scopes)? 679 DIScope *Context = getNonCompileUnitScope(Scope); 680 681 auto *Node = 682 DILocalVariable::get(VMContext, cast_or_null<DILocalScope>(Context), Name, 683 File, LineNo, Ty, ArgNo, Flags, AlignInBits); 684 if (AlwaysPreserve) { 685 // The optimizer may remove local variables. If there is an interest 686 // to preserve variable info in such situation then stash it in a 687 // named mdnode. 688 DISubprogram *Fn = getDISubprogram(Scope); 689 assert(Fn && "Missing subprogram for local variable"); 690 PreservedVariables[Fn].emplace_back(Node); 691 } 692 return Node; 693 } 694 695 DILocalVariable *DIBuilder::createAutoVariable(DIScope *Scope, StringRef Name, 696 DIFile *File, unsigned LineNo, 697 DIType *Ty, bool AlwaysPreserve, 698 DINode::DIFlags Flags, 699 uint32_t AlignInBits) { 700 return createLocalVariable(VMContext, PreservedVariables, Scope, Name, 701 /* ArgNo */ 0, File, LineNo, Ty, AlwaysPreserve, 702 Flags, AlignInBits); 703 } 704 705 DILocalVariable *DIBuilder::createParameterVariable( 706 DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File, 707 unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags) { 708 assert(ArgNo && "Expected non-zero argument number for parameter"); 709 return createLocalVariable(VMContext, PreservedVariables, Scope, Name, ArgNo, 710 File, LineNo, Ty, AlwaysPreserve, Flags, 711 /* AlignInBits */0); 712 } 713 714 DILabel *DIBuilder::createLabel( 715 DIScope *Scope, StringRef Name, DIFile *File, 716 unsigned LineNo, bool AlwaysPreserve) { 717 DIScope *Context = getNonCompileUnitScope(Scope); 718 719 auto *Node = 720 DILabel::get(VMContext, cast_or_null<DILocalScope>(Context), Name, 721 File, LineNo); 722 723 if (AlwaysPreserve) { 724 /// The optimizer may remove labels. If there is an interest 725 /// to preserve label info in such situation then append it to 726 /// the list of retained nodes of the DISubprogram. 727 DISubprogram *Fn = getDISubprogram(Scope); 728 assert(Fn && "Missing subprogram for label"); 729 PreservedLabels[Fn].emplace_back(Node); 730 } 731 return Node; 732 } 733 734 DIExpression *DIBuilder::createExpression(ArrayRef<uint64_t> Addr) { 735 return DIExpression::get(VMContext, Addr); 736 } 737 738 DIExpression *DIBuilder::createExpression(ArrayRef<int64_t> Signed) { 739 // TODO: Remove the callers of this signed version and delete. 740 SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end()); 741 return createExpression(Addr); 742 } 743 744 template <class... Ts> 745 static DISubprogram *getSubprogram(bool IsDistinct, Ts &&... Args) { 746 if (IsDistinct) 747 return DISubprogram::getDistinct(std::forward<Ts>(Args)...); 748 return DISubprogram::get(std::forward<Ts>(Args)...); 749 } 750 751 DISubprogram *DIBuilder::createFunction( 752 DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File, 753 unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine, 754 DINode::DIFlags Flags, DISubprogram::DISPFlags SPFlags, 755 DITemplateParameterArray TParams, DISubprogram *Decl, 756 DITypeArray ThrownTypes) { 757 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition; 758 auto *Node = getSubprogram( 759 /*IsDistinct=*/IsDefinition, VMContext, getNonCompileUnitScope(Context), 760 Name, LinkageName, File, LineNo, Ty, ScopeLine, nullptr, 0, 0, Flags, 761 SPFlags, IsDefinition ? CUNode : nullptr, TParams, Decl, 762 MDTuple::getTemporary(VMContext, None).release(), ThrownTypes); 763 764 if (IsDefinition) 765 AllSubprograms.push_back(Node); 766 trackIfUnresolved(Node); 767 return Node; 768 } 769 770 DISubprogram *DIBuilder::createTempFunctionFwdDecl( 771 DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File, 772 unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine, 773 DINode::DIFlags Flags, DISubprogram::DISPFlags SPFlags, 774 DITemplateParameterArray TParams, DISubprogram *Decl, 775 DITypeArray ThrownTypes) { 776 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition; 777 return DISubprogram::getTemporary(VMContext, getNonCompileUnitScope(Context), 778 Name, LinkageName, File, LineNo, Ty, 779 ScopeLine, nullptr, 0, 0, Flags, SPFlags, 780 IsDefinition ? CUNode : nullptr, TParams, 781 Decl, nullptr, ThrownTypes) 782 .release(); 783 } 784 785 DISubprogram *DIBuilder::createMethod( 786 DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F, 787 unsigned LineNo, DISubroutineType *Ty, unsigned VIndex, int ThisAdjustment, 788 DIType *VTableHolder, DINode::DIFlags Flags, 789 DISubprogram::DISPFlags SPFlags, DITemplateParameterArray TParams, 790 DITypeArray ThrownTypes) { 791 assert(getNonCompileUnitScope(Context) && 792 "Methods should have both a Context and a context that isn't " 793 "the compile unit."); 794 // FIXME: Do we want to use different scope/lines? 795 bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition; 796 auto *SP = getSubprogram( 797 /*IsDistinct=*/IsDefinition, VMContext, cast<DIScope>(Context), Name, 798 LinkageName, F, LineNo, Ty, LineNo, VTableHolder, VIndex, ThisAdjustment, 799 Flags, SPFlags, IsDefinition ? CUNode : nullptr, TParams, nullptr, 800 nullptr, ThrownTypes); 801 802 if (IsDefinition) 803 AllSubprograms.push_back(SP); 804 trackIfUnresolved(SP); 805 return SP; 806 } 807 808 DICommonBlock *DIBuilder::createCommonBlock( 809 DIScope *Scope, DIGlobalVariable *Decl, StringRef Name, DIFile *File, 810 unsigned LineNo) { 811 return DICommonBlock::get( 812 VMContext, Scope, Decl, Name, File, LineNo); 813 } 814 815 DINamespace *DIBuilder::createNameSpace(DIScope *Scope, StringRef Name, 816 bool ExportSymbols) { 817 818 // It is okay to *not* make anonymous top-level namespaces distinct, because 819 // all nodes that have an anonymous namespace as their parent scope are 820 // guaranteed to be unique and/or are linked to their containing 821 // DICompileUnit. This decision is an explicit tradeoff of link time versus 822 // memory usage versus code simplicity and may get revisited in the future. 823 return DINamespace::get(VMContext, getNonCompileUnitScope(Scope), Name, 824 ExportSymbols); 825 } 826 827 DIModule *DIBuilder::createModule(DIScope *Scope, StringRef Name, 828 StringRef ConfigurationMacros, 829 StringRef IncludePath, 830 StringRef ISysRoot) { 831 return DIModule::get(VMContext, getNonCompileUnitScope(Scope), Name, 832 ConfigurationMacros, IncludePath, ISysRoot); 833 } 834 835 DILexicalBlockFile *DIBuilder::createLexicalBlockFile(DIScope *Scope, 836 DIFile *File, 837 unsigned Discriminator) { 838 return DILexicalBlockFile::get(VMContext, Scope, File, Discriminator); 839 } 840 841 DILexicalBlock *DIBuilder::createLexicalBlock(DIScope *Scope, DIFile *File, 842 unsigned Line, unsigned Col) { 843 // Make these distinct, to avoid merging two lexical blocks on the same 844 // file/line/column. 845 return DILexicalBlock::getDistinct(VMContext, getNonCompileUnitScope(Scope), 846 File, Line, Col); 847 } 848 849 Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo, 850 DIExpression *Expr, const DILocation *DL, 851 Instruction *InsertBefore) { 852 return insertDeclare(Storage, VarInfo, Expr, DL, InsertBefore->getParent(), 853 InsertBefore); 854 } 855 856 Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo, 857 DIExpression *Expr, const DILocation *DL, 858 BasicBlock *InsertAtEnd) { 859 // If this block already has a terminator then insert this intrinsic before 860 // the terminator. Otherwise, put it at the end of the block. 861 Instruction *InsertBefore = InsertAtEnd->getTerminator(); 862 return insertDeclare(Storage, VarInfo, Expr, DL, InsertAtEnd, InsertBefore); 863 } 864 865 Instruction *DIBuilder::insertLabel(DILabel *LabelInfo, const DILocation *DL, 866 Instruction *InsertBefore) { 867 return insertLabel( 868 LabelInfo, DL, InsertBefore ? InsertBefore->getParent() : nullptr, 869 InsertBefore); 870 } 871 872 Instruction *DIBuilder::insertLabel(DILabel *LabelInfo, const DILocation *DL, 873 BasicBlock *InsertAtEnd) { 874 return insertLabel(LabelInfo, DL, InsertAtEnd, nullptr); 875 } 876 877 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, 878 DILocalVariable *VarInfo, 879 DIExpression *Expr, 880 const DILocation *DL, 881 Instruction *InsertBefore) { 882 return insertDbgValueIntrinsic( 883 V, VarInfo, Expr, DL, InsertBefore ? InsertBefore->getParent() : nullptr, 884 InsertBefore); 885 } 886 887 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, 888 DILocalVariable *VarInfo, 889 DIExpression *Expr, 890 const DILocation *DL, 891 BasicBlock *InsertAtEnd) { 892 return insertDbgValueIntrinsic(V, VarInfo, Expr, DL, InsertAtEnd, nullptr); 893 } 894 895 /// Return an IRBuilder for inserting dbg.declare and dbg.value intrinsics. This 896 /// abstracts over the various ways to specify an insert position. 897 static IRBuilder<> getIRBForDbgInsertion(const DILocation *DL, 898 BasicBlock *InsertBB, 899 Instruction *InsertBefore) { 900 IRBuilder<> B(DL->getContext()); 901 if (InsertBefore) 902 B.SetInsertPoint(InsertBefore); 903 else if (InsertBB) 904 B.SetInsertPoint(InsertBB); 905 B.SetCurrentDebugLocation(DL); 906 return B; 907 } 908 909 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) { 910 assert(V && "no value passed to dbg intrinsic"); 911 return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V)); 912 } 913 914 static Function *getDeclareIntrin(Module &M) { 915 return Intrinsic::getDeclaration(&M, UseDbgAddr ? Intrinsic::dbg_addr 916 : Intrinsic::dbg_declare); 917 } 918 919 Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo, 920 DIExpression *Expr, const DILocation *DL, 921 BasicBlock *InsertBB, Instruction *InsertBefore) { 922 assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.declare"); 923 assert(DL && "Expected debug loc"); 924 assert(DL->getScope()->getSubprogram() == 925 VarInfo->getScope()->getSubprogram() && 926 "Expected matching subprograms"); 927 if (!DeclareFn) 928 DeclareFn = getDeclareIntrin(M); 929 930 trackIfUnresolved(VarInfo); 931 trackIfUnresolved(Expr); 932 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage), 933 MetadataAsValue::get(VMContext, VarInfo), 934 MetadataAsValue::get(VMContext, Expr)}; 935 936 IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore); 937 return B.CreateCall(DeclareFn, Args); 938 } 939 940 Instruction *DIBuilder::insertDbgValueIntrinsic( 941 Value *V, DILocalVariable *VarInfo, DIExpression *Expr, 942 const DILocation *DL, BasicBlock *InsertBB, Instruction *InsertBefore) { 943 assert(V && "no value passed to dbg.value"); 944 assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.value"); 945 assert(DL && "Expected debug loc"); 946 assert(DL->getScope()->getSubprogram() == 947 VarInfo->getScope()->getSubprogram() && 948 "Expected matching subprograms"); 949 if (!ValueFn) 950 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value); 951 952 trackIfUnresolved(VarInfo); 953 trackIfUnresolved(Expr); 954 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V), 955 MetadataAsValue::get(VMContext, VarInfo), 956 MetadataAsValue::get(VMContext, Expr)}; 957 958 IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore); 959 return B.CreateCall(ValueFn, Args); 960 } 961 962 Instruction *DIBuilder::insertLabel( 963 DILabel *LabelInfo, const DILocation *DL, 964 BasicBlock *InsertBB, Instruction *InsertBefore) { 965 assert(LabelInfo && "empty or invalid DILabel* passed to dbg.label"); 966 assert(DL && "Expected debug loc"); 967 assert(DL->getScope()->getSubprogram() == 968 LabelInfo->getScope()->getSubprogram() && 969 "Expected matching subprograms"); 970 if (!LabelFn) 971 LabelFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_label); 972 973 trackIfUnresolved(LabelInfo); 974 Value *Args[] = {MetadataAsValue::get(VMContext, LabelInfo)}; 975 976 IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore); 977 return B.CreateCall(LabelFn, Args); 978 } 979 980 void DIBuilder::replaceVTableHolder(DICompositeType *&T, 981 DIType *VTableHolder) { 982 { 983 TypedTrackingMDRef<DICompositeType> N(T); 984 N->replaceVTableHolder(VTableHolder); 985 T = N.get(); 986 } 987 988 // If this didn't create a self-reference, just return. 989 if (T != VTableHolder) 990 return; 991 992 // Look for unresolved operands. T will drop RAUW support, orphaning any 993 // cycles underneath it. 994 if (T->isResolved()) 995 for (const MDOperand &O : T->operands()) 996 if (auto *N = dyn_cast_or_null<MDNode>(O)) 997 trackIfUnresolved(N); 998 } 999 1000 void DIBuilder::replaceArrays(DICompositeType *&T, DINodeArray Elements, 1001 DINodeArray TParams) { 1002 { 1003 TypedTrackingMDRef<DICompositeType> N(T); 1004 if (Elements) 1005 N->replaceElements(Elements); 1006 if (TParams) 1007 N->replaceTemplateParams(DITemplateParameterArray(TParams)); 1008 T = N.get(); 1009 } 1010 1011 // If T isn't resolved, there's no problem. 1012 if (!T->isResolved()) 1013 return; 1014 1015 // If T is resolved, it may be due to a self-reference cycle. Track the 1016 // arrays explicitly if they're unresolved, or else the cycles will be 1017 // orphaned. 1018 if (Elements) 1019 trackIfUnresolved(Elements.get()); 1020 if (TParams) 1021 trackIfUnresolved(TParams.get()); 1022 } 1023