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