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, bool GnuPubnames) { 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, GnuPubnames); 153 154 // Create a named metadata so that it is easier to find cu in a module. 155 NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu"); 156 NMD->addOperand(CUNode); 157 trackIfUnresolved(CUNode); 158 return CUNode; 159 } 160 161 static DIImportedEntity * 162 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context, 163 Metadata *NS, DIFile *File, unsigned Line, StringRef Name, 164 SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) { 165 if (Line) 166 assert(File && "Source location has line number but no file"); 167 unsigned EntitiesCount = C.pImpl->DIImportedEntitys.size(); 168 auto *M = 169 DIImportedEntity::get(C, Tag, Context, DINodeRef(NS), File, Line, Name); 170 if (EntitiesCount < C.pImpl->DIImportedEntitys.size()) 171 // A new Imported Entity was just added to the context. 172 // Add it to the Imported Modules list. 173 AllImportedModules.emplace_back(M); 174 return M; 175 } 176 177 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context, 178 DINamespace *NS, DIFile *File, 179 unsigned Line) { 180 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module, 181 Context, NS, File, Line, StringRef(), 182 AllImportedModules); 183 } 184 185 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context, 186 DIImportedEntity *NS, 187 DIFile *File, unsigned Line) { 188 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module, 189 Context, NS, File, Line, StringRef(), 190 AllImportedModules); 191 } 192 193 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context, DIModule *M, 194 DIFile *File, unsigned Line) { 195 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module, 196 Context, M, File, Line, StringRef(), 197 AllImportedModules); 198 } 199 200 DIImportedEntity *DIBuilder::createImportedDeclaration(DIScope *Context, 201 DINode *Decl, 202 DIFile *File, 203 unsigned Line, 204 StringRef Name) { 205 // Make sure to use the unique identifier based metadata reference for 206 // types that have one. 207 return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration, 208 Context, Decl, File, Line, Name, 209 AllImportedModules); 210 } 211 212 DIFile *DIBuilder::createFile(StringRef Filename, StringRef Directory, 213 Optional<DIFile::ChecksumInfo<StringRef>> CS, 214 Optional<StringRef> Source) { 215 return DIFile::get(VMContext, Filename, Directory, CS, Source); 216 } 217 218 DIMacro *DIBuilder::createMacro(DIMacroFile *Parent, unsigned LineNumber, 219 unsigned MacroType, StringRef Name, 220 StringRef Value) { 221 assert(!Name.empty() && "Unable to create macro without name"); 222 assert((MacroType == dwarf::DW_MACINFO_undef || 223 MacroType == dwarf::DW_MACINFO_define) && 224 "Unexpected macro type"); 225 auto *M = DIMacro::get(VMContext, MacroType, LineNumber, Name, Value); 226 AllMacrosPerParent[Parent].insert(M); 227 return M; 228 } 229 230 DIMacroFile *DIBuilder::createTempMacroFile(DIMacroFile *Parent, 231 unsigned LineNumber, DIFile *File) { 232 auto *MF = DIMacroFile::getTemporary(VMContext, dwarf::DW_MACINFO_start_file, 233 LineNumber, File, DIMacroNodeArray()) 234 .release(); 235 AllMacrosPerParent[Parent].insert(MF); 236 // Add the new temporary DIMacroFile to the macro per parent map as a parent. 237 // This is needed to assure DIMacroFile with no children to have an entry in 238 // the map. Otherwise, it will not be resolved in DIBuilder::finalize(). 239 AllMacrosPerParent.insert({MF, {}}); 240 return MF; 241 } 242 243 DIEnumerator *DIBuilder::createEnumerator(StringRef Name, int64_t Val, 244 bool IsUnsigned) { 245 assert(!Name.empty() && "Unable to create enumerator without name"); 246 return DIEnumerator::get(VMContext, Val, IsUnsigned, Name); 247 } 248 249 DIBasicType *DIBuilder::createUnspecifiedType(StringRef Name) { 250 assert(!Name.empty() && "Unable to create type without name"); 251 return DIBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name); 252 } 253 254 DIBasicType *DIBuilder::createNullPtrType() { 255 return createUnspecifiedType("decltype(nullptr)"); 256 } 257 258 DIBasicType *DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits, 259 unsigned Encoding) { 260 assert(!Name.empty() && "Unable to create type without name"); 261 return DIBasicType::get(VMContext, dwarf::DW_TAG_base_type, Name, SizeInBits, 262 0, Encoding); 263 } 264 265 DIDerivedType *DIBuilder::createQualifiedType(unsigned Tag, DIType *FromTy) { 266 return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, FromTy, 0, 267 0, 0, None, DINode::FlagZero); 268 } 269 270 DIDerivedType *DIBuilder::createPointerType( 271 DIType *PointeeTy, 272 uint64_t SizeInBits, 273 uint32_t AlignInBits, 274 Optional<unsigned> DWARFAddressSpace, 275 StringRef Name) { 276 // FIXME: Why is there a name here? 277 return DIDerivedType::get(VMContext, dwarf::DW_TAG_pointer_type, Name, 278 nullptr, 0, nullptr, PointeeTy, SizeInBits, 279 AlignInBits, 0, DWARFAddressSpace, 280 DINode::FlagZero); 281 } 282 283 DIDerivedType *DIBuilder::createMemberPointerType(DIType *PointeeTy, 284 DIType *Base, 285 uint64_t SizeInBits, 286 uint32_t AlignInBits, 287 DINode::DIFlags Flags) { 288 return DIDerivedType::get(VMContext, dwarf::DW_TAG_ptr_to_member_type, "", 289 nullptr, 0, nullptr, PointeeTy, SizeInBits, 290 AlignInBits, 0, None, Flags, Base); 291 } 292 293 DIDerivedType *DIBuilder::createReferenceType( 294 unsigned Tag, DIType *RTy, 295 uint64_t SizeInBits, 296 uint32_t AlignInBits, 297 Optional<unsigned> DWARFAddressSpace) { 298 assert(RTy && "Unable to create reference type"); 299 return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, RTy, 300 SizeInBits, AlignInBits, 0, DWARFAddressSpace, 301 DINode::FlagZero); 302 } 303 304 DIDerivedType *DIBuilder::createTypedef(DIType *Ty, StringRef Name, 305 DIFile *File, unsigned LineNo, 306 DIScope *Context) { 307 return DIDerivedType::get(VMContext, dwarf::DW_TAG_typedef, Name, File, 308 LineNo, getNonCompileUnitScope(Context), Ty, 0, 0, 309 0, None, DINode::FlagZero); 310 } 311 312 DIDerivedType *DIBuilder::createFriend(DIType *Ty, DIType *FriendTy) { 313 assert(Ty && "Invalid type!"); 314 assert(FriendTy && "Invalid friend type!"); 315 return DIDerivedType::get(VMContext, dwarf::DW_TAG_friend, "", nullptr, 0, Ty, 316 FriendTy, 0, 0, 0, None, DINode::FlagZero); 317 } 318 319 DIDerivedType *DIBuilder::createInheritance(DIType *Ty, DIType *BaseTy, 320 uint64_t BaseOffset, 321 uint32_t VBPtrOffset, 322 DINode::DIFlags Flags) { 323 assert(Ty && "Unable to create inheritance"); 324 Metadata *ExtraData = ConstantAsMetadata::get( 325 ConstantInt::get(IntegerType::get(VMContext, 32), VBPtrOffset)); 326 return DIDerivedType::get(VMContext, dwarf::DW_TAG_inheritance, "", nullptr, 327 0, Ty, BaseTy, 0, 0, BaseOffset, None, 328 Flags, ExtraData); 329 } 330 331 DIDerivedType *DIBuilder::createMemberType(DIScope *Scope, StringRef Name, 332 DIFile *File, unsigned LineNumber, 333 uint64_t SizeInBits, 334 uint32_t AlignInBits, 335 uint64_t OffsetInBits, 336 DINode::DIFlags Flags, DIType *Ty) { 337 return DIDerivedType::get(VMContext, dwarf::DW_TAG_member, Name, File, 338 LineNumber, getNonCompileUnitScope(Scope), Ty, 339 SizeInBits, AlignInBits, OffsetInBits, None, Flags); 340 } 341 342 static ConstantAsMetadata *getConstantOrNull(Constant *C) { 343 if (C) 344 return ConstantAsMetadata::get(C); 345 return nullptr; 346 } 347 348 DIDerivedType *DIBuilder::createVariantMemberType(DIScope *Scope, StringRef Name, 349 DIFile *File, unsigned LineNumber, 350 uint64_t SizeInBits, 351 uint32_t AlignInBits, 352 uint64_t OffsetInBits, 353 Constant *Discriminant, 354 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 IsFixed) { 508 auto *CTy = DICompositeType::get( 509 VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber, 510 getNonCompileUnitScope(Scope), UnderlyingType, SizeInBits, AlignInBits, 0, 511 IsFixed ? DINode::FlagFixedEnum : 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, 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 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 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), 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, bool isLocalToUnit, 755 bool isDefinition, unsigned ScopeLine, DINode::DIFlags Flags, 756 bool isOptimized, DITemplateParameterArray TParams, DISubprogram *Decl, 757 DITypeArray ThrownTypes) { 758 auto *Node = getSubprogram( 759 /* IsDistinct = */ isDefinition, VMContext, 760 getNonCompileUnitScope(Context), Name, LinkageName, File, LineNo, Ty, 761 isLocalToUnit, isDefinition, ScopeLine, nullptr, 0, 0, 0, Flags, 762 isOptimized, 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, bool isLocalToUnit, 774 bool isDefinition, unsigned ScopeLine, DINode::DIFlags Flags, 775 bool isOptimized, DITemplateParameterArray TParams, DISubprogram *Decl, 776 DITypeArray ThrownTypes) { 777 return DISubprogram::getTemporary( 778 VMContext, getNonCompileUnitScope(Context), Name, LinkageName, 779 File, LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine, nullptr, 780 0, 0, 0, Flags, isOptimized, isDefinition ? CUNode : nullptr, 781 TParams, 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, bool isLocalToUnit, 788 bool isDefinition, unsigned VK, unsigned VIndex, int ThisAdjustment, 789 DIType *VTableHolder, DINode::DIFlags Flags, bool isOptimized, 790 DITemplateParameterArray TParams, 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 auto *SP = getSubprogram( 796 /* IsDistinct = */ isDefinition, VMContext, cast<DIScope>(Context), Name, 797 LinkageName, F, LineNo, Ty, isLocalToUnit, isDefinition, LineNo, 798 VTableHolder, VK, VIndex, ThisAdjustment, Flags, isOptimized, 799 isDefinition ? CUNode : nullptr, TParams, nullptr, nullptr, ThrownTypes); 800 801 if (isDefinition) 802 AllSubprograms.push_back(SP); 803 trackIfUnresolved(SP); 804 return SP; 805 } 806 807 DINamespace *DIBuilder::createNameSpace(DIScope *Scope, StringRef Name, 808 bool ExportSymbols) { 809 810 // It is okay to *not* make anonymous top-level namespaces distinct, because 811 // all nodes that have an anonymous namespace as their parent scope are 812 // guaranteed to be unique and/or are linked to their containing 813 // DICompileUnit. This decision is an explicit tradeoff of link time versus 814 // memory usage versus code simplicity and may get revisited in the future. 815 return DINamespace::get(VMContext, getNonCompileUnitScope(Scope), Name, 816 ExportSymbols); 817 } 818 819 DIModule *DIBuilder::createModule(DIScope *Scope, StringRef Name, 820 StringRef ConfigurationMacros, 821 StringRef IncludePath, 822 StringRef ISysRoot) { 823 return DIModule::get(VMContext, getNonCompileUnitScope(Scope), Name, 824 ConfigurationMacros, IncludePath, ISysRoot); 825 } 826 827 DILexicalBlockFile *DIBuilder::createLexicalBlockFile(DIScope *Scope, 828 DIFile *File, 829 unsigned Discriminator) { 830 return DILexicalBlockFile::get(VMContext, Scope, File, Discriminator); 831 } 832 833 DILexicalBlock *DIBuilder::createLexicalBlock(DIScope *Scope, DIFile *File, 834 unsigned Line, unsigned Col) { 835 // Make these distinct, to avoid merging two lexical blocks on the same 836 // file/line/column. 837 return DILexicalBlock::getDistinct(VMContext, getNonCompileUnitScope(Scope), 838 File, Line, Col); 839 } 840 841 Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo, 842 DIExpression *Expr, const DILocation *DL, 843 Instruction *InsertBefore) { 844 return insertDeclare(Storage, VarInfo, Expr, DL, InsertBefore->getParent(), 845 InsertBefore); 846 } 847 848 Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo, 849 DIExpression *Expr, const DILocation *DL, 850 BasicBlock *InsertAtEnd) { 851 // If this block already has a terminator then insert this intrinsic before 852 // the terminator. Otherwise, put it at the end of the block. 853 Instruction *InsertBefore = InsertAtEnd->getTerminator(); 854 return insertDeclare(Storage, VarInfo, Expr, DL, InsertAtEnd, InsertBefore); 855 } 856 857 Instruction *DIBuilder::insertLabel(DILabel *LabelInfo, const DILocation *DL, 858 Instruction *InsertBefore) { 859 return insertLabel( 860 LabelInfo, DL, InsertBefore ? InsertBefore->getParent() : nullptr, 861 InsertBefore); 862 } 863 864 Instruction *DIBuilder::insertLabel(DILabel *LabelInfo, const DILocation *DL, 865 BasicBlock *InsertAtEnd) { 866 return insertLabel(LabelInfo, DL, InsertAtEnd, nullptr); 867 } 868 869 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, 870 DILocalVariable *VarInfo, 871 DIExpression *Expr, 872 const DILocation *DL, 873 Instruction *InsertBefore) { 874 return insertDbgValueIntrinsic( 875 V, VarInfo, Expr, DL, InsertBefore ? InsertBefore->getParent() : nullptr, 876 InsertBefore); 877 } 878 879 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, 880 DILocalVariable *VarInfo, 881 DIExpression *Expr, 882 const DILocation *DL, 883 BasicBlock *InsertAtEnd) { 884 return insertDbgValueIntrinsic(V, VarInfo, Expr, DL, InsertAtEnd, nullptr); 885 } 886 887 /// Return an IRBuilder for inserting dbg.declare and dbg.value intrinsics. This 888 /// abstracts over the various ways to specify an insert position. 889 static IRBuilder<> getIRBForDbgInsertion(const DILocation *DL, 890 BasicBlock *InsertBB, 891 Instruction *InsertBefore) { 892 IRBuilder<> B(DL->getContext()); 893 if (InsertBefore) 894 B.SetInsertPoint(InsertBefore); 895 else if (InsertBB) 896 B.SetInsertPoint(InsertBB); 897 B.SetCurrentDebugLocation(DL); 898 return B; 899 } 900 901 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) { 902 assert(V && "no value passed to dbg intrinsic"); 903 return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V)); 904 } 905 906 static Function *getDeclareIntrin(Module &M) { 907 return Intrinsic::getDeclaration(&M, UseDbgAddr ? Intrinsic::dbg_addr 908 : Intrinsic::dbg_declare); 909 } 910 911 Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo, 912 DIExpression *Expr, const DILocation *DL, 913 BasicBlock *InsertBB, Instruction *InsertBefore) { 914 assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.declare"); 915 assert(DL && "Expected debug loc"); 916 assert(DL->getScope()->getSubprogram() == 917 VarInfo->getScope()->getSubprogram() && 918 "Expected matching subprograms"); 919 if (!DeclareFn) 920 DeclareFn = getDeclareIntrin(M); 921 922 trackIfUnresolved(VarInfo); 923 trackIfUnresolved(Expr); 924 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage), 925 MetadataAsValue::get(VMContext, VarInfo), 926 MetadataAsValue::get(VMContext, Expr)}; 927 928 IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore); 929 return B.CreateCall(DeclareFn, Args); 930 } 931 932 Instruction *DIBuilder::insertDbgValueIntrinsic( 933 Value *V, DILocalVariable *VarInfo, DIExpression *Expr, 934 const DILocation *DL, BasicBlock *InsertBB, Instruction *InsertBefore) { 935 assert(V && "no value passed to dbg.value"); 936 assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.value"); 937 assert(DL && "Expected debug loc"); 938 assert(DL->getScope()->getSubprogram() == 939 VarInfo->getScope()->getSubprogram() && 940 "Expected matching subprograms"); 941 if (!ValueFn) 942 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value); 943 944 trackIfUnresolved(VarInfo); 945 trackIfUnresolved(Expr); 946 Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V), 947 MetadataAsValue::get(VMContext, VarInfo), 948 MetadataAsValue::get(VMContext, Expr)}; 949 950 IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore); 951 return B.CreateCall(ValueFn, Args); 952 } 953 954 Instruction *DIBuilder::insertLabel( 955 DILabel *LabelInfo, const DILocation *DL, 956 BasicBlock *InsertBB, Instruction *InsertBefore) { 957 assert(LabelInfo && "empty or invalid DILabel* passed to dbg.label"); 958 assert(DL && "Expected debug loc"); 959 assert(DL->getScope()->getSubprogram() == 960 LabelInfo->getScope()->getSubprogram() && 961 "Expected matching subprograms"); 962 if (!LabelFn) 963 LabelFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_label); 964 965 trackIfUnresolved(LabelInfo); 966 Value *Args[] = {MetadataAsValue::get(VMContext, LabelInfo)}; 967 968 IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore); 969 return B.CreateCall(LabelFn, Args); 970 } 971 972 void DIBuilder::replaceVTableHolder(DICompositeType *&T, 973 DIType *VTableHolder) { 974 { 975 TypedTrackingMDRef<DICompositeType> N(T); 976 N->replaceVTableHolder(VTableHolder); 977 T = N.get(); 978 } 979 980 // If this didn't create a self-reference, just return. 981 if (T != VTableHolder) 982 return; 983 984 // Look for unresolved operands. T will drop RAUW support, orphaning any 985 // cycles underneath it. 986 if (T->isResolved()) 987 for (const MDOperand &O : T->operands()) 988 if (auto *N = dyn_cast_or_null<MDNode>(O)) 989 trackIfUnresolved(N); 990 } 991 992 void DIBuilder::replaceArrays(DICompositeType *&T, DINodeArray Elements, 993 DINodeArray TParams) { 994 { 995 TypedTrackingMDRef<DICompositeType> N(T); 996 if (Elements) 997 N->replaceElements(Elements); 998 if (TParams) 999 N->replaceTemplateParams(DITemplateParameterArray(TParams)); 1000 T = N.get(); 1001 } 1002 1003 // If T isn't resolved, there's no problem. 1004 if (!T->isResolved()) 1005 return; 1006 1007 // If T is resolved, it may be due to a self-reference cycle. Track the 1008 // arrays explicitly if they're unresolved, or else the cycles will be 1009 // orphaned. 1010 if (Elements) 1011 trackIfUnresolved(Elements.get()); 1012 if (TParams) 1013 trackIfUnresolved(TParams.get()); 1014 } 1015