1 //===- llvm/IR/DebugInfoMetadata.h - Debug info metadata --------*- C++ -*-===// 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 // Declarations for metadata specific to debug info. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_IR_DEBUGINFOMETADATA_H 15 #define LLVM_IR_DEBUGINFOMETADATA_H 16 17 #include "llvm/IR/Metadata.h" 18 #include "llvm/Support/Dwarf.h" 19 20 // Helper macros for defining get() overrides. 21 #define DEFINE_MDNODE_GET_UNPACK_IMPL(...) __VA_ARGS__ 22 #define DEFINE_MDNODE_GET_UNPACK(ARGS) DEFINE_MDNODE_GET_UNPACK_IMPL ARGS 23 #define DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS) \ 24 static CLASS *getDistinct(LLVMContext &Context, \ 25 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \ 26 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Distinct); \ 27 } \ 28 static Temp##CLASS getTemporary(LLVMContext &Context, \ 29 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \ 30 return Temp##CLASS( \ 31 getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Temporary)); \ 32 } 33 #define DEFINE_MDNODE_GET(CLASS, FORMAL, ARGS) \ 34 static CLASS *get(LLVMContext &Context, DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \ 35 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued); \ 36 } \ 37 static CLASS *getIfExists(LLVMContext &Context, \ 38 DEFINE_MDNODE_GET_UNPACK(FORMAL)) { \ 39 return getImpl(Context, DEFINE_MDNODE_GET_UNPACK(ARGS), Uniqued, \ 40 /* ShouldCreate */ false); \ 41 } \ 42 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(CLASS, FORMAL, ARGS) 43 44 namespace llvm { 45 46 /// \brief Pointer union between a subclass of DINode and MDString. 47 /// 48 /// \a DICompositeType can be referenced via an \a MDString unique identifier. 49 /// This class allows some type safety in the face of that, requiring either a 50 /// node of a particular type or an \a MDString. 51 template <class T> class TypedDINodeRef { 52 const Metadata *MD = nullptr; 53 54 public: 55 TypedDINodeRef() = default; 56 TypedDINodeRef(std::nullptr_t) {} 57 58 /// \brief Construct from a raw pointer. 59 explicit TypedDINodeRef(const Metadata *MD) : MD(MD) { 60 assert((!MD || isa<MDString>(MD) || isa<T>(MD)) && "Expected valid ref"); 61 } 62 63 template <class U> 64 TypedDINodeRef( 65 const TypedDINodeRef<U> &X, 66 typename std::enable_if<std::is_convertible<U *, T *>::value>::type * = 67 nullptr) 68 : MD(X) {} 69 70 operator Metadata *() const { return const_cast<Metadata *>(MD); } 71 72 bool operator==(const TypedDINodeRef<T> &X) const { return MD == X.MD; } 73 bool operator!=(const TypedDINodeRef<T> &X) const { return MD != X.MD; } 74 75 /// \brief Create a reference. 76 /// 77 /// Get a reference to \c N, using an \a MDString reference if available. 78 static TypedDINodeRef get(const T *N); 79 80 template <class MapTy> T *resolve(const MapTy &Map) const { 81 if (!MD) 82 return nullptr; 83 84 if (auto *Typed = dyn_cast<T>(MD)) 85 return const_cast<T *>(Typed); 86 87 auto *S = cast<MDString>(MD); 88 auto I = Map.find(S); 89 assert(I != Map.end() && "Missing identifier in type map"); 90 return cast<T>(I->second); 91 } 92 }; 93 94 typedef TypedDINodeRef<DINode> DINodeRef; 95 typedef TypedDINodeRef<DIScope> DIScopeRef; 96 typedef TypedDINodeRef<DIType> DITypeRef; 97 98 class DITypeRefArray { 99 const MDTuple *N = nullptr; 100 101 public: 102 DITypeRefArray() = default; 103 DITypeRefArray(const MDTuple *N) : N(N) {} 104 105 explicit operator bool() const { return get(); } 106 explicit operator MDTuple *() const { return get(); } 107 108 MDTuple *get() const { return const_cast<MDTuple *>(N); } 109 MDTuple *operator->() const { return get(); } 110 MDTuple &operator*() const { return *get(); } 111 112 // FIXME: Fix callers and remove condition on N. 113 unsigned size() const { return N ? N->getNumOperands() : 0u; } 114 DITypeRef operator[](unsigned I) const { return DITypeRef(N->getOperand(I)); } 115 116 class iterator : std::iterator<std::input_iterator_tag, DITypeRef, 117 std::ptrdiff_t, void, DITypeRef> { 118 MDNode::op_iterator I = nullptr; 119 120 public: 121 iterator() = default; 122 explicit iterator(MDNode::op_iterator I) : I(I) {} 123 DITypeRef operator*() const { return DITypeRef(*I); } 124 iterator &operator++() { 125 ++I; 126 return *this; 127 } 128 iterator operator++(int) { 129 iterator Temp(*this); 130 ++I; 131 return Temp; 132 } 133 bool operator==(const iterator &X) const { return I == X.I; } 134 bool operator!=(const iterator &X) const { return I != X.I; } 135 }; 136 137 // FIXME: Fix callers and remove condition on N. 138 iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); } 139 iterator end() const { return N ? iterator(N->op_end()) : iterator(); } 140 }; 141 142 /// \brief Tagged DWARF-like metadata node. 143 /// 144 /// A metadata node with a DWARF tag (i.e., a constant named \c DW_TAG_*, 145 /// defined in llvm/Support/Dwarf.h). Called \a DINode because it's 146 /// potentially used for non-DWARF output. 147 class DINode : public MDNode { 148 friend class LLVMContextImpl; 149 friend class MDNode; 150 151 protected: 152 DINode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag, 153 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None) 154 : MDNode(C, ID, Storage, Ops1, Ops2) { 155 assert(Tag < 1u << 16); 156 SubclassData16 = Tag; 157 } 158 ~DINode() = default; 159 160 template <class Ty> Ty *getOperandAs(unsigned I) const { 161 return cast_or_null<Ty>(getOperand(I)); 162 } 163 164 StringRef getStringOperand(unsigned I) const { 165 if (auto *S = getOperandAs<MDString>(I)) 166 return S->getString(); 167 return StringRef(); 168 } 169 170 static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) { 171 if (S.empty()) 172 return nullptr; 173 return MDString::get(Context, S); 174 } 175 176 public: 177 unsigned getTag() const { return SubclassData16; } 178 179 /// \brief Debug info flags. 180 /// 181 /// The three accessibility flags are mutually exclusive and rolled together 182 /// in the first two bits. 183 enum DIFlags { 184 #define HANDLE_DI_FLAG(ID, NAME) Flag##NAME = ID, 185 #include "llvm/IR/DebugInfoFlags.def" 186 FlagAccessibility = FlagPrivate | FlagProtected | FlagPublic 187 }; 188 189 static unsigned getFlag(StringRef Flag); 190 static const char *getFlagString(unsigned Flag); 191 192 /// \brief Split up a flags bitfield. 193 /// 194 /// Split \c Flags into \c SplitFlags, a vector of its components. Returns 195 /// any remaining (unrecognized) bits. 196 static unsigned splitFlags(unsigned Flags, 197 SmallVectorImpl<unsigned> &SplitFlags); 198 199 DINodeRef getRef() const { return DINodeRef::get(this); } 200 201 static bool classof(const Metadata *MD) { 202 switch (MD->getMetadataID()) { 203 default: 204 return false; 205 case GenericDINodeKind: 206 case DISubrangeKind: 207 case DIEnumeratorKind: 208 case DIBasicTypeKind: 209 case DIDerivedTypeKind: 210 case DICompositeTypeKind: 211 case DISubroutineTypeKind: 212 case DIFileKind: 213 case DICompileUnitKind: 214 case DISubprogramKind: 215 case DILexicalBlockKind: 216 case DILexicalBlockFileKind: 217 case DINamespaceKind: 218 case DITemplateTypeParameterKind: 219 case DITemplateValueParameterKind: 220 case DIGlobalVariableKind: 221 case DILocalVariableKind: 222 case DIObjCPropertyKind: 223 case DIImportedEntityKind: 224 case DIModuleKind: 225 return true; 226 } 227 } 228 }; 229 230 template <class T> struct simplify_type<const TypedDINodeRef<T>> { 231 typedef Metadata *SimpleType; 232 static SimpleType getSimplifiedValue(const TypedDINodeRef<T> &MD) { 233 return MD; 234 } 235 }; 236 237 template <class T> 238 struct simplify_type<TypedDINodeRef<T>> 239 : simplify_type<const TypedDINodeRef<T>> {}; 240 241 /// \brief Generic tagged DWARF-like metadata node. 242 /// 243 /// An un-specialized DWARF-like metadata node. The first operand is a 244 /// (possibly empty) null-separated \a MDString header that contains arbitrary 245 /// fields. The remaining operands are \a dwarf_operands(), and are pointers 246 /// to other metadata. 247 class GenericDINode : public DINode { 248 friend class LLVMContextImpl; 249 friend class MDNode; 250 251 GenericDINode(LLVMContext &C, StorageType Storage, unsigned Hash, 252 unsigned Tag, ArrayRef<Metadata *> Ops1, 253 ArrayRef<Metadata *> Ops2) 254 : DINode(C, GenericDINodeKind, Storage, Tag, Ops1, Ops2) { 255 setHash(Hash); 256 } 257 ~GenericDINode() { dropAllReferences(); } 258 259 void setHash(unsigned Hash) { SubclassData32 = Hash; } 260 void recalculateHash(); 261 262 static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag, 263 StringRef Header, ArrayRef<Metadata *> DwarfOps, 264 StorageType Storage, bool ShouldCreate = true) { 265 return getImpl(Context, Tag, getCanonicalMDString(Context, Header), 266 DwarfOps, Storage, ShouldCreate); 267 } 268 269 static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag, 270 MDString *Header, ArrayRef<Metadata *> DwarfOps, 271 StorageType Storage, bool ShouldCreate = true); 272 273 TempGenericDINode cloneImpl() const { 274 return getTemporary( 275 getContext(), getTag(), getHeader(), 276 SmallVector<Metadata *, 4>(dwarf_op_begin(), dwarf_op_end())); 277 } 278 279 public: 280 unsigned getHash() const { return SubclassData32; } 281 282 DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, StringRef Header, 283 ArrayRef<Metadata *> DwarfOps), 284 (Tag, Header, DwarfOps)) 285 DEFINE_MDNODE_GET(GenericDINode, (unsigned Tag, MDString *Header, 286 ArrayRef<Metadata *> DwarfOps), 287 (Tag, Header, DwarfOps)) 288 289 /// \brief Return a (temporary) clone of this. 290 TempGenericDINode clone() const { return cloneImpl(); } 291 292 unsigned getTag() const { return SubclassData16; } 293 StringRef getHeader() const { return getStringOperand(0); } 294 295 op_iterator dwarf_op_begin() const { return op_begin() + 1; } 296 op_iterator dwarf_op_end() const { return op_end(); } 297 op_range dwarf_operands() const { 298 return op_range(dwarf_op_begin(), dwarf_op_end()); 299 } 300 301 unsigned getNumDwarfOperands() const { return getNumOperands() - 1; } 302 const MDOperand &getDwarfOperand(unsigned I) const { 303 return getOperand(I + 1); 304 } 305 void replaceDwarfOperandWith(unsigned I, Metadata *New) { 306 replaceOperandWith(I + 1, New); 307 } 308 309 static bool classof(const Metadata *MD) { 310 return MD->getMetadataID() == GenericDINodeKind; 311 } 312 }; 313 314 /// \brief Array subrange. 315 /// 316 /// TODO: Merge into node for DW_TAG_array_type, which should have a custom 317 /// type. 318 class DISubrange : public DINode { 319 friend class LLVMContextImpl; 320 friend class MDNode; 321 322 int64_t Count; 323 int64_t LowerBound; 324 325 DISubrange(LLVMContext &C, StorageType Storage, int64_t Count, 326 int64_t LowerBound) 327 : DINode(C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, None), 328 Count(Count), LowerBound(LowerBound) {} 329 ~DISubrange() = default; 330 331 static DISubrange *getImpl(LLVMContext &Context, int64_t Count, 332 int64_t LowerBound, StorageType Storage, 333 bool ShouldCreate = true); 334 335 TempDISubrange cloneImpl() const { 336 return getTemporary(getContext(), getCount(), getLowerBound()); 337 } 338 339 public: 340 DEFINE_MDNODE_GET(DISubrange, (int64_t Count, int64_t LowerBound = 0), 341 (Count, LowerBound)) 342 343 TempDISubrange clone() const { return cloneImpl(); } 344 345 int64_t getLowerBound() const { return LowerBound; } 346 int64_t getCount() const { return Count; } 347 348 static bool classof(const Metadata *MD) { 349 return MD->getMetadataID() == DISubrangeKind; 350 } 351 }; 352 353 /// \brief Enumeration value. 354 /// 355 /// TODO: Add a pointer to the context (DW_TAG_enumeration_type) once that no 356 /// longer creates a type cycle. 357 class DIEnumerator : public DINode { 358 friend class LLVMContextImpl; 359 friend class MDNode; 360 361 int64_t Value; 362 363 DIEnumerator(LLVMContext &C, StorageType Storage, int64_t Value, 364 ArrayRef<Metadata *> Ops) 365 : DINode(C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops), 366 Value(Value) {} 367 ~DIEnumerator() = default; 368 369 static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value, 370 StringRef Name, StorageType Storage, 371 bool ShouldCreate = true) { 372 return getImpl(Context, Value, getCanonicalMDString(Context, Name), Storage, 373 ShouldCreate); 374 } 375 static DIEnumerator *getImpl(LLVMContext &Context, int64_t Value, 376 MDString *Name, StorageType Storage, 377 bool ShouldCreate = true); 378 379 TempDIEnumerator cloneImpl() const { 380 return getTemporary(getContext(), getValue(), getName()); 381 } 382 383 public: 384 DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, StringRef Name), 385 (Value, Name)) 386 DEFINE_MDNODE_GET(DIEnumerator, (int64_t Value, MDString *Name), 387 (Value, Name)) 388 389 TempDIEnumerator clone() const { return cloneImpl(); } 390 391 int64_t getValue() const { return Value; } 392 StringRef getName() const { return getStringOperand(0); } 393 394 MDString *getRawName() const { return getOperandAs<MDString>(0); } 395 396 static bool classof(const Metadata *MD) { 397 return MD->getMetadataID() == DIEnumeratorKind; 398 } 399 }; 400 401 /// \brief Base class for scope-like contexts. 402 /// 403 /// Base class for lexical scopes and types (which are also declaration 404 /// contexts). 405 /// 406 /// TODO: Separate the concepts of declaration contexts and lexical scopes. 407 class DIScope : public DINode { 408 protected: 409 DIScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag, 410 ArrayRef<Metadata *> Ops) 411 : DINode(C, ID, Storage, Tag, Ops) {} 412 ~DIScope() = default; 413 414 public: 415 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); } 416 417 inline StringRef getFilename() const; 418 inline StringRef getDirectory() const; 419 420 StringRef getName() const; 421 DIScopeRef getScope() const; 422 423 /// \brief Return the raw underlying file. 424 /// 425 /// An \a DIFile is an \a DIScope, but it doesn't point at a separate file 426 /// (it\em is the file). If \c this is an \a DIFile, we need to return \c 427 /// this. Otherwise, return the first operand, which is where all other 428 /// subclasses store their file pointer. 429 Metadata *getRawFile() const { 430 return isa<DIFile>(this) ? const_cast<DIScope *>(this) 431 : static_cast<Metadata *>(getOperand(0)); 432 } 433 434 DIScopeRef getRef() const { return DIScopeRef::get(this); } 435 436 static bool classof(const Metadata *MD) { 437 switch (MD->getMetadataID()) { 438 default: 439 return false; 440 case DIBasicTypeKind: 441 case DIDerivedTypeKind: 442 case DICompositeTypeKind: 443 case DISubroutineTypeKind: 444 case DIFileKind: 445 case DICompileUnitKind: 446 case DISubprogramKind: 447 case DILexicalBlockKind: 448 case DILexicalBlockFileKind: 449 case DINamespaceKind: 450 case DIModuleKind: 451 return true; 452 } 453 } 454 }; 455 456 /// \brief File. 457 /// 458 /// TODO: Merge with directory/file node (including users). 459 /// TODO: Canonicalize paths on creation. 460 class DIFile : public DIScope { 461 friend class LLVMContextImpl; 462 friend class MDNode; 463 464 DIFile(LLVMContext &C, StorageType Storage, ArrayRef<Metadata *> Ops) 465 : DIScope(C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops) {} 466 ~DIFile() = default; 467 468 static DIFile *getImpl(LLVMContext &Context, StringRef Filename, 469 StringRef Directory, StorageType Storage, 470 bool ShouldCreate = true) { 471 return getImpl(Context, getCanonicalMDString(Context, Filename), 472 getCanonicalMDString(Context, Directory), Storage, 473 ShouldCreate); 474 } 475 static DIFile *getImpl(LLVMContext &Context, MDString *Filename, 476 MDString *Directory, StorageType Storage, 477 bool ShouldCreate = true); 478 479 TempDIFile cloneImpl() const { 480 return getTemporary(getContext(), getFilename(), getDirectory()); 481 } 482 483 public: 484 DEFINE_MDNODE_GET(DIFile, (StringRef Filename, StringRef Directory), 485 (Filename, Directory)) 486 DEFINE_MDNODE_GET(DIFile, (MDString * Filename, MDString *Directory), 487 (Filename, Directory)) 488 489 TempDIFile clone() const { return cloneImpl(); } 490 491 StringRef getFilename() const { return getStringOperand(0); } 492 StringRef getDirectory() const { return getStringOperand(1); } 493 494 MDString *getRawFilename() const { return getOperandAs<MDString>(0); } 495 MDString *getRawDirectory() const { return getOperandAs<MDString>(1); } 496 497 static bool classof(const Metadata *MD) { 498 return MD->getMetadataID() == DIFileKind; 499 } 500 }; 501 502 StringRef DIScope::getFilename() const { 503 if (auto *F = getFile()) 504 return F->getFilename(); 505 return ""; 506 } 507 508 StringRef DIScope::getDirectory() const { 509 if (auto *F = getFile()) 510 return F->getDirectory(); 511 return ""; 512 } 513 514 /// \brief Base class for types. 515 /// 516 /// TODO: Remove the hardcoded name and context, since many types don't use 517 /// them. 518 /// TODO: Split up flags. 519 class DIType : public DIScope { 520 unsigned Line; 521 unsigned Flags; 522 uint64_t SizeInBits; 523 uint64_t AlignInBits; 524 uint64_t OffsetInBits; 525 526 protected: 527 DIType(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag, 528 unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits, 529 uint64_t OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops) 530 : DIScope(C, ID, Storage, Tag, Ops), Line(Line), Flags(Flags), 531 SizeInBits(SizeInBits), AlignInBits(AlignInBits), 532 OffsetInBits(OffsetInBits) {} 533 ~DIType() = default; 534 535 public: 536 TempDIType clone() const { 537 return TempDIType(cast<DIType>(MDNode::clone().release())); 538 } 539 540 unsigned getLine() const { return Line; } 541 uint64_t getSizeInBits() const { return SizeInBits; } 542 uint64_t getAlignInBits() const { return AlignInBits; } 543 uint64_t getOffsetInBits() const { return OffsetInBits; } 544 unsigned getFlags() const { return Flags; } 545 546 DIScopeRef getScope() const { return DIScopeRef(getRawScope()); } 547 StringRef getName() const { return getStringOperand(2); } 548 549 550 Metadata *getRawScope() const { return getOperand(1); } 551 MDString *getRawName() const { return getOperandAs<MDString>(2); } 552 553 void setFlags(unsigned NewFlags) { 554 assert(!isUniqued() && "Cannot set flags on uniqued nodes"); 555 Flags = NewFlags; 556 } 557 558 bool isPrivate() const { 559 return (getFlags() & FlagAccessibility) == FlagPrivate; 560 } 561 bool isProtected() const { 562 return (getFlags() & FlagAccessibility) == FlagProtected; 563 } 564 bool isPublic() const { 565 return (getFlags() & FlagAccessibility) == FlagPublic; 566 } 567 bool isForwardDecl() const { return getFlags() & FlagFwdDecl; } 568 bool isAppleBlockExtension() const { return getFlags() & FlagAppleBlock; } 569 bool isBlockByrefStruct() const { return getFlags() & FlagBlockByrefStruct; } 570 bool isVirtual() const { return getFlags() & FlagVirtual; } 571 bool isArtificial() const { return getFlags() & FlagArtificial; } 572 bool isObjectPointer() const { return getFlags() & FlagObjectPointer; } 573 bool isObjcClassComplete() const { 574 return getFlags() & FlagObjcClassComplete; 575 } 576 bool isVector() const { return getFlags() & FlagVector; } 577 bool isStaticMember() const { return getFlags() & FlagStaticMember; } 578 bool isLValueReference() const { return getFlags() & FlagLValueReference; } 579 bool isRValueReference() const { return getFlags() & FlagRValueReference; } 580 bool isExternalTypeRef() const { return getFlags() & FlagExternalTypeRef; } 581 582 DITypeRef getRef() const { return DITypeRef::get(this); } 583 584 static bool classof(const Metadata *MD) { 585 switch (MD->getMetadataID()) { 586 default: 587 return false; 588 case DIBasicTypeKind: 589 case DIDerivedTypeKind: 590 case DICompositeTypeKind: 591 case DISubroutineTypeKind: 592 return true; 593 } 594 } 595 }; 596 597 /// \brief Basic type, like 'int' or 'float'. 598 /// 599 /// TODO: Split out DW_TAG_unspecified_type. 600 /// TODO: Drop unused accessors. 601 class DIBasicType : public DIType { 602 friend class LLVMContextImpl; 603 friend class MDNode; 604 605 unsigned Encoding; 606 607 DIBasicType(LLVMContext &C, StorageType Storage, unsigned Tag, 608 uint64_t SizeInBits, uint64_t AlignInBits, unsigned Encoding, 609 ArrayRef<Metadata *> Ops) 610 : DIType(C, DIBasicTypeKind, Storage, Tag, 0, SizeInBits, AlignInBits, 0, 611 0, Ops), 612 Encoding(Encoding) {} 613 ~DIBasicType() = default; 614 615 static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag, 616 StringRef Name, uint64_t SizeInBits, 617 uint64_t AlignInBits, unsigned Encoding, 618 StorageType Storage, bool ShouldCreate = true) { 619 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), 620 SizeInBits, AlignInBits, Encoding, Storage, ShouldCreate); 621 } 622 static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag, 623 MDString *Name, uint64_t SizeInBits, 624 uint64_t AlignInBits, unsigned Encoding, 625 StorageType Storage, bool ShouldCreate = true); 626 627 TempDIBasicType cloneImpl() const { 628 return getTemporary(getContext(), getTag(), getName(), getSizeInBits(), 629 getAlignInBits(), getEncoding()); 630 } 631 632 public: 633 DEFINE_MDNODE_GET(DIBasicType, (unsigned Tag, StringRef Name), 634 (Tag, Name, 0, 0, 0)) 635 DEFINE_MDNODE_GET(DIBasicType, 636 (unsigned Tag, StringRef Name, uint64_t SizeInBits, 637 uint64_t AlignInBits, unsigned Encoding), 638 (Tag, Name, SizeInBits, AlignInBits, Encoding)) 639 DEFINE_MDNODE_GET(DIBasicType, 640 (unsigned Tag, MDString *Name, uint64_t SizeInBits, 641 uint64_t AlignInBits, unsigned Encoding), 642 (Tag, Name, SizeInBits, AlignInBits, Encoding)) 643 644 TempDIBasicType clone() const { return cloneImpl(); } 645 646 unsigned getEncoding() const { return Encoding; } 647 648 static bool classof(const Metadata *MD) { 649 return MD->getMetadataID() == DIBasicTypeKind; 650 } 651 }; 652 653 /// \brief Derived types. 654 /// 655 /// This includes qualified types, pointers, references, friends, typedefs, and 656 /// class members. 657 /// 658 /// TODO: Split out members (inheritance, fields, methods, etc.). 659 class DIDerivedType : public DIType { 660 friend class LLVMContextImpl; 661 friend class MDNode; 662 663 DIDerivedType(LLVMContext &C, StorageType Storage, unsigned Tag, 664 unsigned Line, uint64_t SizeInBits, uint64_t AlignInBits, 665 uint64_t OffsetInBits, unsigned Flags, ArrayRef<Metadata *> Ops) 666 : DIType(C, DIDerivedTypeKind, Storage, Tag, Line, SizeInBits, 667 AlignInBits, OffsetInBits, Flags, Ops) {} 668 ~DIDerivedType() = default; 669 670 static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag, 671 StringRef Name, DIFile *File, unsigned Line, 672 DIScopeRef Scope, DITypeRef BaseType, 673 uint64_t SizeInBits, uint64_t AlignInBits, 674 uint64_t OffsetInBits, unsigned Flags, 675 Metadata *ExtraData, StorageType Storage, 676 bool ShouldCreate = true) { 677 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), File, 678 Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits, 679 Flags, ExtraData, Storage, ShouldCreate); 680 } 681 static DIDerivedType *getImpl(LLVMContext &Context, unsigned Tag, 682 MDString *Name, Metadata *File, unsigned Line, 683 Metadata *Scope, Metadata *BaseType, 684 uint64_t SizeInBits, uint64_t AlignInBits, 685 uint64_t OffsetInBits, unsigned Flags, 686 Metadata *ExtraData, StorageType Storage, 687 bool ShouldCreate = true); 688 689 TempDIDerivedType cloneImpl() const { 690 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(), 691 getScope(), getBaseType(), getSizeInBits(), 692 getAlignInBits(), getOffsetInBits(), getFlags(), 693 getExtraData()); 694 } 695 696 public: 697 DEFINE_MDNODE_GET(DIDerivedType, 698 (unsigned Tag, MDString *Name, Metadata *File, 699 unsigned Line, Metadata *Scope, Metadata *BaseType, 700 uint64_t SizeInBits, uint64_t AlignInBits, 701 uint64_t OffsetInBits, unsigned Flags, 702 Metadata *ExtraData = nullptr), 703 (Tag, Name, File, Line, Scope, BaseType, SizeInBits, 704 AlignInBits, OffsetInBits, Flags, ExtraData)) 705 DEFINE_MDNODE_GET(DIDerivedType, 706 (unsigned Tag, StringRef Name, DIFile *File, unsigned Line, 707 DIScopeRef Scope, DITypeRef BaseType, uint64_t SizeInBits, 708 uint64_t AlignInBits, uint64_t OffsetInBits, 709 unsigned Flags, Metadata *ExtraData = nullptr), 710 (Tag, Name, File, Line, Scope, BaseType, SizeInBits, 711 AlignInBits, OffsetInBits, Flags, ExtraData)) 712 713 TempDIDerivedType clone() const { return cloneImpl(); } 714 715 //// Get the base type this is derived from. 716 DITypeRef getBaseType() const { return DITypeRef(getRawBaseType()); } 717 Metadata *getRawBaseType() const { return getOperand(3); } 718 719 /// \brief Get extra data associated with this derived type. 720 /// 721 /// Class type for pointer-to-members, objective-c property node for ivars, 722 /// or global constant wrapper for static members. 723 /// 724 /// TODO: Separate out types that need this extra operand: pointer-to-member 725 /// types and member fields (static members and ivars). 726 Metadata *getExtraData() const { return getRawExtraData(); } 727 Metadata *getRawExtraData() const { return getOperand(4); } 728 729 /// \brief Get casted version of extra data. 730 /// @{ 731 DITypeRef getClassType() const { 732 assert(getTag() == dwarf::DW_TAG_ptr_to_member_type); 733 return DITypeRef(getExtraData()); 734 } 735 DIObjCProperty *getObjCProperty() const { 736 return dyn_cast_or_null<DIObjCProperty>(getExtraData()); 737 } 738 Constant *getConstant() const { 739 assert(getTag() == dwarf::DW_TAG_member && isStaticMember()); 740 if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData())) 741 return C->getValue(); 742 return nullptr; 743 } 744 /// @} 745 746 static bool classof(const Metadata *MD) { 747 return MD->getMetadataID() == DIDerivedTypeKind; 748 } 749 }; 750 751 /// \brief Composite types. 752 /// 753 /// TODO: Detach from DerivedTypeBase (split out MDEnumType?). 754 /// TODO: Create a custom, unrelated node for DW_TAG_array_type. 755 class DICompositeType : public DIType { 756 friend class LLVMContextImpl; 757 friend class MDNode; 758 759 unsigned RuntimeLang; 760 761 DICompositeType(LLVMContext &C, StorageType Storage, unsigned Tag, 762 unsigned Line, unsigned RuntimeLang, uint64_t SizeInBits, 763 uint64_t AlignInBits, uint64_t OffsetInBits, unsigned Flags, 764 ArrayRef<Metadata *> Ops) 765 : DIType(C, DICompositeTypeKind, Storage, Tag, Line, SizeInBits, 766 AlignInBits, OffsetInBits, Flags, Ops), 767 RuntimeLang(RuntimeLang) {} 768 ~DICompositeType() = default; 769 770 static DICompositeType * 771 getImpl(LLVMContext &Context, unsigned Tag, StringRef Name, Metadata *File, 772 unsigned Line, DIScopeRef Scope, DITypeRef BaseType, 773 uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits, 774 uint64_t Flags, DINodeArray Elements, unsigned RuntimeLang, 775 DITypeRef VTableHolder, DITemplateParameterArray TemplateParams, 776 StringRef Identifier, StorageType Storage, bool ShouldCreate = true) { 777 return getImpl( 778 Context, Tag, getCanonicalMDString(Context, Name), File, Line, Scope, 779 BaseType, SizeInBits, AlignInBits, OffsetInBits, Flags, Elements.get(), 780 RuntimeLang, VTableHolder, TemplateParams.get(), 781 getCanonicalMDString(Context, Identifier), Storage, ShouldCreate); 782 } 783 static DICompositeType * 784 getImpl(LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File, 785 unsigned Line, Metadata *Scope, Metadata *BaseType, 786 uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits, 787 unsigned Flags, Metadata *Elements, unsigned RuntimeLang, 788 Metadata *VTableHolder, Metadata *TemplateParams, 789 MDString *Identifier, StorageType Storage, bool ShouldCreate = true); 790 791 TempDICompositeType cloneImpl() const { 792 return getTemporary(getContext(), getTag(), getName(), getFile(), getLine(), 793 getScope(), getBaseType(), getSizeInBits(), 794 getAlignInBits(), getOffsetInBits(), getFlags(), 795 getElements(), getRuntimeLang(), getVTableHolder(), 796 getTemplateParams(), getIdentifier()); 797 } 798 799 public: 800 DEFINE_MDNODE_GET(DICompositeType, 801 (unsigned Tag, StringRef Name, DIFile *File, unsigned Line, 802 DIScopeRef Scope, DITypeRef BaseType, uint64_t SizeInBits, 803 uint64_t AlignInBits, uint64_t OffsetInBits, 804 unsigned Flags, DINodeArray Elements, unsigned RuntimeLang, 805 DITypeRef VTableHolder, 806 DITemplateParameterArray TemplateParams = nullptr, 807 StringRef Identifier = ""), 808 (Tag, Name, File, Line, Scope, BaseType, SizeInBits, 809 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, 810 VTableHolder, TemplateParams, Identifier)) 811 DEFINE_MDNODE_GET(DICompositeType, 812 (unsigned Tag, MDString *Name, Metadata *File, 813 unsigned Line, Metadata *Scope, Metadata *BaseType, 814 uint64_t SizeInBits, uint64_t AlignInBits, 815 uint64_t OffsetInBits, unsigned Flags, Metadata *Elements, 816 unsigned RuntimeLang, Metadata *VTableHolder, 817 Metadata *TemplateParams = nullptr, 818 MDString *Identifier = nullptr), 819 (Tag, Name, File, Line, Scope, BaseType, SizeInBits, 820 AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, 821 VTableHolder, TemplateParams, Identifier)) 822 823 TempDICompositeType clone() const { return cloneImpl(); } 824 825 DITypeRef getBaseType() const { return DITypeRef(getRawBaseType()); } 826 DINodeArray getElements() const { 827 return cast_or_null<MDTuple>(getRawElements()); 828 } 829 DITypeRef getVTableHolder() const { return DITypeRef(getRawVTableHolder()); } 830 DITemplateParameterArray getTemplateParams() const { 831 return cast_or_null<MDTuple>(getRawTemplateParams()); 832 } 833 StringRef getIdentifier() const { return getStringOperand(7); } 834 unsigned getRuntimeLang() const { return RuntimeLang; } 835 836 Metadata *getRawBaseType() const { return getOperand(3); } 837 Metadata *getRawElements() const { return getOperand(4); } 838 Metadata *getRawVTableHolder() const { return getOperand(5); } 839 Metadata *getRawTemplateParams() const { return getOperand(6); } 840 MDString *getRawIdentifier() const { return getOperandAs<MDString>(7); } 841 842 /// \brief Replace operands. 843 /// 844 /// If this \a isUniqued() and not \a isResolved(), on a uniquing collision 845 /// this will be RAUW'ed and deleted. Use a \a TrackingMDRef to keep track 846 /// of its movement if necessary. 847 /// @{ 848 void replaceElements(DINodeArray Elements) { 849 #ifndef NDEBUG 850 for (DINode *Op : getElements()) 851 assert(std::find(Elements->op_begin(), Elements->op_end(), Op) && 852 "Lost a member during member list replacement"); 853 #endif 854 replaceOperandWith(4, Elements.get()); 855 } 856 void replaceVTableHolder(DITypeRef VTableHolder) { 857 replaceOperandWith(5, VTableHolder); 858 } 859 void replaceTemplateParams(DITemplateParameterArray TemplateParams) { 860 replaceOperandWith(6, TemplateParams.get()); 861 } 862 /// @} 863 864 static bool classof(const Metadata *MD) { 865 return MD->getMetadataID() == DICompositeTypeKind; 866 } 867 }; 868 869 template <class T> TypedDINodeRef<T> TypedDINodeRef<T>::get(const T *N) { 870 if (N) 871 if (auto *Composite = dyn_cast<DICompositeType>(N)) 872 if (auto *S = Composite->getRawIdentifier()) 873 return TypedDINodeRef<T>(S); 874 return TypedDINodeRef<T>(N); 875 } 876 877 /// \brief Type array for a subprogram. 878 /// 879 /// TODO: Fold the array of types in directly as operands. 880 class DISubroutineType : public DIType { 881 friend class LLVMContextImpl; 882 friend class MDNode; 883 884 DISubroutineType(LLVMContext &C, StorageType Storage, unsigned Flags, 885 ArrayRef<Metadata *> Ops) 886 : DIType(C, DISubroutineTypeKind, Storage, dwarf::DW_TAG_subroutine_type, 887 0, 0, 0, 0, Flags, Ops) {} 888 ~DISubroutineType() = default; 889 890 static DISubroutineType *getImpl(LLVMContext &Context, unsigned Flags, 891 DITypeRefArray TypeArray, 892 StorageType Storage, 893 bool ShouldCreate = true) { 894 return getImpl(Context, Flags, TypeArray.get(), Storage, ShouldCreate); 895 } 896 static DISubroutineType *getImpl(LLVMContext &Context, unsigned Flags, 897 Metadata *TypeArray, StorageType Storage, 898 bool ShouldCreate = true); 899 900 TempDISubroutineType cloneImpl() const { 901 return getTemporary(getContext(), getFlags(), getTypeArray()); 902 } 903 904 public: 905 DEFINE_MDNODE_GET(DISubroutineType, 906 (unsigned Flags, DITypeRefArray TypeArray), 907 (Flags, TypeArray)) 908 DEFINE_MDNODE_GET(DISubroutineType, (unsigned Flags, Metadata *TypeArray), 909 (Flags, TypeArray)) 910 911 TempDISubroutineType clone() const { return cloneImpl(); } 912 913 DITypeRefArray getTypeArray() const { 914 return cast_or_null<MDTuple>(getRawTypeArray()); 915 } 916 Metadata *getRawTypeArray() const { return getOperand(3); } 917 918 static bool classof(const Metadata *MD) { 919 return MD->getMetadataID() == DISubroutineTypeKind; 920 } 921 }; 922 923 /// \brief Compile unit. 924 class DICompileUnit : public DIScope { 925 friend class LLVMContextImpl; 926 friend class MDNode; 927 928 unsigned SourceLanguage; 929 bool IsOptimized; 930 unsigned RuntimeVersion; 931 unsigned EmissionKind; 932 uint64_t DWOId; 933 934 DICompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage, 935 bool IsOptimized, unsigned RuntimeVersion, 936 unsigned EmissionKind, uint64_t DWOId, ArrayRef<Metadata *> Ops) 937 : DIScope(C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops), 938 SourceLanguage(SourceLanguage), IsOptimized(IsOptimized), 939 RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind), 940 DWOId(DWOId) { 941 assert(Storage != Uniqued); 942 } 943 ~DICompileUnit() = default; 944 945 static DICompileUnit * 946 getImpl(LLVMContext &Context, unsigned SourceLanguage, DIFile *File, 947 StringRef Producer, bool IsOptimized, StringRef Flags, 948 unsigned RuntimeVersion, StringRef SplitDebugFilename, 949 unsigned EmissionKind, DICompositeTypeArray EnumTypes, 950 DITypeArray RetainedTypes, DISubprogramArray Subprograms, 951 DIGlobalVariableArray GlobalVariables, 952 DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros, 953 uint64_t DWOId, StorageType Storage, bool ShouldCreate = true) { 954 return getImpl(Context, SourceLanguage, File, 955 getCanonicalMDString(Context, Producer), IsOptimized, 956 getCanonicalMDString(Context, Flags), RuntimeVersion, 957 getCanonicalMDString(Context, SplitDebugFilename), 958 EmissionKind, EnumTypes.get(), RetainedTypes.get(), 959 Subprograms.get(), GlobalVariables.get(), 960 ImportedEntities.get(), Macros.get(), DWOId, Storage, 961 ShouldCreate); 962 } 963 static DICompileUnit * 964 getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File, 965 MDString *Producer, bool IsOptimized, MDString *Flags, 966 unsigned RuntimeVersion, MDString *SplitDebugFilename, 967 unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes, 968 Metadata *Subprograms, Metadata *GlobalVariables, 969 Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId, 970 StorageType Storage, bool ShouldCreate = true); 971 972 TempDICompileUnit cloneImpl() const { 973 return getTemporary( 974 getContext(), getSourceLanguage(), getFile(), getProducer(), 975 isOptimized(), getFlags(), getRuntimeVersion(), getSplitDebugFilename(), 976 getEmissionKind(), getEnumTypes(), getRetainedTypes(), getSubprograms(), 977 getGlobalVariables(), getImportedEntities(), getMacros(), DWOId); 978 } 979 980 static void get() = delete; 981 static void getIfExists() = delete; 982 983 public: 984 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY( 985 DICompileUnit, 986 (unsigned SourceLanguage, DIFile *File, StringRef Producer, 987 bool IsOptimized, StringRef Flags, unsigned RuntimeVersion, 988 StringRef SplitDebugFilename, unsigned EmissionKind, 989 DICompositeTypeArray EnumTypes, DITypeArray RetainedTypes, 990 DISubprogramArray Subprograms, DIGlobalVariableArray GlobalVariables, 991 DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros, 992 uint64_t DWOId), 993 (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion, 994 SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes, Subprograms, 995 GlobalVariables, ImportedEntities, Macros, DWOId)) 996 DEFINE_MDNODE_GET_DISTINCT_TEMPORARY( 997 DICompileUnit, 998 (unsigned SourceLanguage, Metadata *File, MDString *Producer, 999 bool IsOptimized, MDString *Flags, unsigned RuntimeVersion, 1000 MDString *SplitDebugFilename, unsigned EmissionKind, Metadata *EnumTypes, 1001 Metadata *RetainedTypes, Metadata *Subprograms, 1002 Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros, 1003 uint64_t DWOId), 1004 (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion, 1005 SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes, Subprograms, 1006 GlobalVariables, ImportedEntities, Macros, DWOId)) 1007 1008 TempDICompileUnit clone() const { return cloneImpl(); } 1009 1010 unsigned getSourceLanguage() const { return SourceLanguage; } 1011 bool isOptimized() const { return IsOptimized; } 1012 unsigned getRuntimeVersion() const { return RuntimeVersion; } 1013 unsigned getEmissionKind() const { return EmissionKind; } 1014 StringRef getProducer() const { return getStringOperand(1); } 1015 StringRef getFlags() const { return getStringOperand(2); } 1016 StringRef getSplitDebugFilename() const { return getStringOperand(3); } 1017 DICompositeTypeArray getEnumTypes() const { 1018 return cast_or_null<MDTuple>(getRawEnumTypes()); 1019 } 1020 DITypeArray getRetainedTypes() const { 1021 return cast_or_null<MDTuple>(getRawRetainedTypes()); 1022 } 1023 DISubprogramArray getSubprograms() const { 1024 return cast_or_null<MDTuple>(getRawSubprograms()); 1025 } 1026 DIGlobalVariableArray getGlobalVariables() const { 1027 return cast_or_null<MDTuple>(getRawGlobalVariables()); 1028 } 1029 DIImportedEntityArray getImportedEntities() const { 1030 return cast_or_null<MDTuple>(getRawImportedEntities()); 1031 } 1032 DIMacroNodeArray getMacros() const { 1033 return cast_or_null<MDTuple>(getRawMacros()); 1034 } 1035 uint64_t getDWOId() const { return DWOId; } 1036 void setDWOId(uint64_t DwoId) { DWOId = DwoId; } 1037 1038 MDString *getRawProducer() const { return getOperandAs<MDString>(1); } 1039 MDString *getRawFlags() const { return getOperandAs<MDString>(2); } 1040 MDString *getRawSplitDebugFilename() const { 1041 return getOperandAs<MDString>(3); 1042 } 1043 Metadata *getRawEnumTypes() const { return getOperand(4); } 1044 Metadata *getRawRetainedTypes() const { return getOperand(5); } 1045 Metadata *getRawSubprograms() const { return getOperand(6); } 1046 Metadata *getRawGlobalVariables() const { return getOperand(7); } 1047 Metadata *getRawImportedEntities() const { return getOperand(8); } 1048 Metadata *getRawMacros() const { return getOperand(9); } 1049 1050 /// \brief Replace arrays. 1051 /// 1052 /// If this \a isUniqued() and not \a isResolved(), it will be RAUW'ed and 1053 /// deleted on a uniquing collision. In practice, uniquing collisions on \a 1054 /// DICompileUnit should be fairly rare. 1055 /// @{ 1056 void replaceEnumTypes(DICompositeTypeArray N) { 1057 replaceOperandWith(4, N.get()); 1058 } 1059 void replaceRetainedTypes(DITypeArray N) { 1060 replaceOperandWith(5, N.get()); 1061 } 1062 void replaceSubprograms(DISubprogramArray N) { 1063 replaceOperandWith(6, N.get()); 1064 } 1065 void replaceGlobalVariables(DIGlobalVariableArray N) { 1066 replaceOperandWith(7, N.get()); 1067 } 1068 void replaceImportedEntities(DIImportedEntityArray N) { 1069 replaceOperandWith(8, N.get()); 1070 } 1071 void replaceMacros(DIMacroNodeArray N) { replaceOperandWith(9, N.get()); } 1072 /// @} 1073 1074 static bool classof(const Metadata *MD) { 1075 return MD->getMetadataID() == DICompileUnitKind; 1076 } 1077 }; 1078 1079 /// \brief A scope for locals. 1080 /// 1081 /// A legal scope for lexical blocks, local variables, and debug info 1082 /// locations. Subclasses are \a DISubprogram, \a DILexicalBlock, and \a 1083 /// DILexicalBlockFile. 1084 class DILocalScope : public DIScope { 1085 protected: 1086 DILocalScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag, 1087 ArrayRef<Metadata *> Ops) 1088 : DIScope(C, ID, Storage, Tag, Ops) {} 1089 ~DILocalScope() = default; 1090 1091 public: 1092 /// \brief Get the subprogram for this scope. 1093 /// 1094 /// Return this if it's an \a DISubprogram; otherwise, look up the scope 1095 /// chain. 1096 DISubprogram *getSubprogram() const; 1097 1098 static bool classof(const Metadata *MD) { 1099 return MD->getMetadataID() == DISubprogramKind || 1100 MD->getMetadataID() == DILexicalBlockKind || 1101 MD->getMetadataID() == DILexicalBlockFileKind; 1102 } 1103 }; 1104 1105 /// \brief Debug location. 1106 /// 1107 /// A debug location in source code, used for debug info and otherwise. 1108 class DILocation : public MDNode { 1109 friend class LLVMContextImpl; 1110 friend class MDNode; 1111 1112 DILocation(LLVMContext &C, StorageType Storage, unsigned Line, 1113 unsigned Column, ArrayRef<Metadata *> MDs); 1114 ~DILocation() { dropAllReferences(); } 1115 1116 static DILocation *getImpl(LLVMContext &Context, unsigned Line, 1117 unsigned Column, Metadata *Scope, 1118 Metadata *InlinedAt, StorageType Storage, 1119 bool ShouldCreate = true); 1120 static DILocation *getImpl(LLVMContext &Context, unsigned Line, 1121 unsigned Column, DILocalScope *Scope, 1122 DILocation *InlinedAt, StorageType Storage, 1123 bool ShouldCreate = true) { 1124 return getImpl(Context, Line, Column, static_cast<Metadata *>(Scope), 1125 static_cast<Metadata *>(InlinedAt), Storage, ShouldCreate); 1126 } 1127 1128 TempDILocation cloneImpl() const { 1129 // Get the raw scope/inlinedAt since it is possible to invoke this on 1130 // a DILocation containing temporary metadata. 1131 return getTemporary(getContext(), getLine(), getColumn(), getRawScope(), 1132 getRawInlinedAt()); 1133 } 1134 1135 // Disallow replacing operands. 1136 void replaceOperandWith(unsigned I, Metadata *New) = delete; 1137 1138 public: 1139 DEFINE_MDNODE_GET(DILocation, 1140 (unsigned Line, unsigned Column, Metadata *Scope, 1141 Metadata *InlinedAt = nullptr), 1142 (Line, Column, Scope, InlinedAt)) 1143 DEFINE_MDNODE_GET(DILocation, 1144 (unsigned Line, unsigned Column, DILocalScope *Scope, 1145 DILocation *InlinedAt = nullptr), 1146 (Line, Column, Scope, InlinedAt)) 1147 1148 /// \brief Return a (temporary) clone of this. 1149 TempDILocation clone() const { return cloneImpl(); } 1150 1151 unsigned getLine() const { return SubclassData32; } 1152 unsigned getColumn() const { return SubclassData16; } 1153 DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); } 1154 DILocation *getInlinedAt() const { 1155 return cast_or_null<DILocation>(getRawInlinedAt()); 1156 } 1157 1158 DIFile *getFile() const { return getScope()->getFile(); } 1159 StringRef getFilename() const { return getScope()->getFilename(); } 1160 StringRef getDirectory() const { return getScope()->getDirectory(); } 1161 1162 /// \brief Get the scope where this is inlined. 1163 /// 1164 /// Walk through \a getInlinedAt() and return \a getScope() from the deepest 1165 /// location. 1166 DILocalScope *getInlinedAtScope() const { 1167 if (auto *IA = getInlinedAt()) 1168 return IA->getInlinedAtScope(); 1169 return getScope(); 1170 } 1171 1172 /// \brief Check whether this can be discriminated from another location. 1173 /// 1174 /// Check \c this can be discriminated from \c RHS in a linetable entry. 1175 /// Scope and inlined-at chains are not recorded in the linetable, so they 1176 /// cannot be used to distinguish basic blocks. 1177 /// 1178 /// The current implementation is weaker than it should be, since it just 1179 /// checks filename and line. 1180 /// 1181 /// FIXME: Add a check for getDiscriminator(). 1182 /// FIXME: Add a check for getColumn(). 1183 /// FIXME: Change the getFilename() check to getFile() (or add one for 1184 /// getDirectory()). 1185 bool canDiscriminate(const DILocation &RHS) const { 1186 return getFilename() != RHS.getFilename() || getLine() != RHS.getLine(); 1187 } 1188 1189 /// \brief Get the DWARF discriminator. 1190 /// 1191 /// DWARF discriminators distinguish identical file locations between 1192 /// instructions that are on different basic blocks. 1193 inline unsigned getDiscriminator() const; 1194 1195 /// \brief Compute new discriminator in the given context. 1196 /// 1197 /// This modifies the \a LLVMContext that \c this is in to increment the next 1198 /// discriminator for \c this's line/filename combination. 1199 /// 1200 /// FIXME: Delete this. See comments in implementation and at the only call 1201 /// site in \a AddDiscriminators::runOnFunction(). 1202 unsigned computeNewDiscriminator() const; 1203 1204 Metadata *getRawScope() const { return getOperand(0); } 1205 Metadata *getRawInlinedAt() const { 1206 if (getNumOperands() == 2) 1207 return getOperand(1); 1208 return nullptr; 1209 } 1210 1211 static bool classof(const Metadata *MD) { 1212 return MD->getMetadataID() == DILocationKind; 1213 } 1214 }; 1215 1216 /// \brief Subprogram description. 1217 /// 1218 /// TODO: Remove DisplayName. It's always equal to Name. 1219 /// TODO: Split up flags. 1220 class DISubprogram : public DILocalScope { 1221 friend class LLVMContextImpl; 1222 friend class MDNode; 1223 1224 unsigned Line; 1225 unsigned ScopeLine; 1226 unsigned Virtuality; 1227 unsigned VirtualIndex; 1228 unsigned Flags; 1229 bool IsLocalToUnit; 1230 bool IsDefinition; 1231 bool IsOptimized; 1232 1233 DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line, 1234 unsigned ScopeLine, unsigned Virtuality, unsigned VirtualIndex, 1235 unsigned Flags, bool IsLocalToUnit, bool IsDefinition, 1236 bool IsOptimized, ArrayRef<Metadata *> Ops) 1237 : DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram, 1238 Ops), 1239 Line(Line), ScopeLine(ScopeLine), Virtuality(Virtuality), 1240 VirtualIndex(VirtualIndex), Flags(Flags), IsLocalToUnit(IsLocalToUnit), 1241 IsDefinition(IsDefinition), IsOptimized(IsOptimized) {} 1242 ~DISubprogram() = default; 1243 1244 static DISubprogram * 1245 getImpl(LLVMContext &Context, DIScopeRef Scope, StringRef Name, 1246 StringRef LinkageName, DIFile *File, unsigned Line, 1247 DISubroutineType *Type, bool IsLocalToUnit, bool IsDefinition, 1248 unsigned ScopeLine, DITypeRef ContainingType, unsigned Virtuality, 1249 unsigned VirtualIndex, unsigned Flags, bool IsOptimized, 1250 DITemplateParameterArray TemplateParams, DISubprogram *Declaration, 1251 DILocalVariableArray Variables, StorageType Storage, 1252 bool ShouldCreate = true) { 1253 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), 1254 getCanonicalMDString(Context, LinkageName), File, Line, Type, 1255 IsLocalToUnit, IsDefinition, ScopeLine, ContainingType, 1256 Virtuality, VirtualIndex, Flags, IsOptimized, 1257 TemplateParams.get(), Declaration, Variables.get(), Storage, 1258 ShouldCreate); 1259 } 1260 static DISubprogram * 1261 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name, 1262 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, 1263 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine, 1264 Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex, 1265 unsigned Flags, bool IsOptimized, Metadata *TemplateParams, 1266 Metadata *Declaration, Metadata *Variables, StorageType Storage, 1267 bool ShouldCreate = true); 1268 1269 TempDISubprogram cloneImpl() const { 1270 return getTemporary( 1271 getContext(), getScope(), getName(), getLinkageName(), getFile(), 1272 getLine(), getType(), isLocalToUnit(), isDefinition(), getScopeLine(), 1273 getContainingType(), getVirtuality(), getVirtualIndex(), getFlags(), 1274 isOptimized(), getTemplateParams(), getDeclaration(), getVariables()); 1275 } 1276 1277 public: 1278 DEFINE_MDNODE_GET(DISubprogram, 1279 (DIScopeRef Scope, StringRef Name, StringRef LinkageName, 1280 DIFile *File, unsigned Line, DISubroutineType *Type, 1281 bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine, 1282 DITypeRef ContainingType, unsigned Virtuality, 1283 unsigned VirtualIndex, unsigned Flags, bool IsOptimized, 1284 DITemplateParameterArray TemplateParams = nullptr, 1285 DISubprogram *Declaration = nullptr, 1286 DILocalVariableArray Variables = nullptr), 1287 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, 1288 IsDefinition, ScopeLine, ContainingType, Virtuality, 1289 VirtualIndex, Flags, IsOptimized, TemplateParams, 1290 Declaration, Variables)) 1291 DEFINE_MDNODE_GET( 1292 DISubprogram, 1293 (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File, 1294 unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition, 1295 unsigned ScopeLine, Metadata *ContainingType, unsigned Virtuality, 1296 unsigned VirtualIndex, unsigned Flags, bool IsOptimized, 1297 Metadata *TemplateParams = nullptr, Metadata *Declaration = nullptr, 1298 Metadata *Variables = nullptr), 1299 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, 1300 ScopeLine, ContainingType, Virtuality, VirtualIndex, Flags, IsOptimized, 1301 TemplateParams, Declaration, Variables)) 1302 1303 TempDISubprogram clone() const { return cloneImpl(); } 1304 1305 public: 1306 unsigned getLine() const { return Line; } 1307 unsigned getVirtuality() const { return Virtuality; } 1308 unsigned getVirtualIndex() const { return VirtualIndex; } 1309 unsigned getScopeLine() const { return ScopeLine; } 1310 unsigned getFlags() const { return Flags; } 1311 bool isLocalToUnit() const { return IsLocalToUnit; } 1312 bool isDefinition() const { return IsDefinition; } 1313 bool isOptimized() const { return IsOptimized; } 1314 1315 unsigned isArtificial() const { return getFlags() & FlagArtificial; } 1316 bool isPrivate() const { 1317 return (getFlags() & FlagAccessibility) == FlagPrivate; 1318 } 1319 bool isProtected() const { 1320 return (getFlags() & FlagAccessibility) == FlagProtected; 1321 } 1322 bool isPublic() const { 1323 return (getFlags() & FlagAccessibility) == FlagPublic; 1324 } 1325 bool isExplicit() const { return getFlags() & FlagExplicit; } 1326 bool isPrototyped() const { return getFlags() & FlagPrototyped; } 1327 1328 /// \brief Check if this is reference-qualified. 1329 /// 1330 /// Return true if this subprogram is a C++11 reference-qualified non-static 1331 /// member function (void foo() &). 1332 unsigned isLValueReference() const { 1333 return getFlags() & FlagLValueReference; 1334 } 1335 1336 /// \brief Check if this is rvalue-reference-qualified. 1337 /// 1338 /// Return true if this subprogram is a C++11 rvalue-reference-qualified 1339 /// non-static member function (void foo() &&). 1340 unsigned isRValueReference() const { 1341 return getFlags() & FlagRValueReference; 1342 } 1343 1344 DIScopeRef getScope() const { return DIScopeRef(getRawScope()); } 1345 1346 StringRef getName() const { return getStringOperand(2); } 1347 StringRef getDisplayName() const { return getStringOperand(3); } 1348 StringRef getLinkageName() const { return getStringOperand(4); } 1349 1350 MDString *getRawName() const { return getOperandAs<MDString>(2); } 1351 MDString *getRawLinkageName() const { return getOperandAs<MDString>(4); } 1352 1353 DISubroutineType *getType() const { 1354 return cast_or_null<DISubroutineType>(getRawType()); 1355 } 1356 DITypeRef getContainingType() const { 1357 return DITypeRef(getRawContainingType()); 1358 } 1359 1360 DITemplateParameterArray getTemplateParams() const { 1361 return cast_or_null<MDTuple>(getRawTemplateParams()); 1362 } 1363 DISubprogram *getDeclaration() const { 1364 return cast_or_null<DISubprogram>(getRawDeclaration()); 1365 } 1366 DILocalVariableArray getVariables() const { 1367 return cast_or_null<MDTuple>(getRawVariables()); 1368 } 1369 1370 Metadata *getRawScope() const { return getOperand(1); } 1371 Metadata *getRawType() const { return getOperand(5); } 1372 Metadata *getRawContainingType() const { return getOperand(6); } 1373 Metadata *getRawTemplateParams() const { return getOperand(7); } 1374 Metadata *getRawDeclaration() const { return getOperand(8); } 1375 Metadata *getRawVariables() const { return getOperand(9); } 1376 1377 /// \brief Check if this subprogram describes the given function. 1378 /// 1379 /// FIXME: Should this be looking through bitcasts? 1380 bool describes(const Function *F) const; 1381 1382 static bool classof(const Metadata *MD) { 1383 return MD->getMetadataID() == DISubprogramKind; 1384 } 1385 }; 1386 1387 class DILexicalBlockBase : public DILocalScope { 1388 protected: 1389 DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage, 1390 ArrayRef<Metadata *> Ops) 1391 : DILocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {} 1392 ~DILexicalBlockBase() = default; 1393 1394 public: 1395 DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); } 1396 1397 Metadata *getRawScope() const { return getOperand(1); } 1398 1399 static bool classof(const Metadata *MD) { 1400 return MD->getMetadataID() == DILexicalBlockKind || 1401 MD->getMetadataID() == DILexicalBlockFileKind; 1402 } 1403 }; 1404 1405 class DILexicalBlock : public DILexicalBlockBase { 1406 friend class LLVMContextImpl; 1407 friend class MDNode; 1408 1409 unsigned Line; 1410 uint16_t Column; 1411 1412 DILexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line, 1413 unsigned Column, ArrayRef<Metadata *> Ops) 1414 : DILexicalBlockBase(C, DILexicalBlockKind, Storage, Ops), Line(Line), 1415 Column(Column) { 1416 assert(Column < (1u << 16) && "Expected 16-bit column"); 1417 } 1418 ~DILexicalBlock() = default; 1419 1420 static DILexicalBlock *getImpl(LLVMContext &Context, DILocalScope *Scope, 1421 DIFile *File, unsigned Line, unsigned Column, 1422 StorageType Storage, 1423 bool ShouldCreate = true) { 1424 return getImpl(Context, static_cast<Metadata *>(Scope), 1425 static_cast<Metadata *>(File), Line, Column, Storage, 1426 ShouldCreate); 1427 } 1428 1429 static DILexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope, 1430 Metadata *File, unsigned Line, unsigned Column, 1431 StorageType Storage, bool ShouldCreate = true); 1432 1433 TempDILexicalBlock cloneImpl() const { 1434 return getTemporary(getContext(), getScope(), getFile(), getLine(), 1435 getColumn()); 1436 } 1437 1438 public: 1439 DEFINE_MDNODE_GET(DILexicalBlock, (DILocalScope * Scope, DIFile *File, 1440 unsigned Line, unsigned Column), 1441 (Scope, File, Line, Column)) 1442 DEFINE_MDNODE_GET(DILexicalBlock, (Metadata * Scope, Metadata *File, 1443 unsigned Line, unsigned Column), 1444 (Scope, File, Line, Column)) 1445 1446 TempDILexicalBlock clone() const { return cloneImpl(); } 1447 1448 unsigned getLine() const { return Line; } 1449 unsigned getColumn() const { return Column; } 1450 1451 static bool classof(const Metadata *MD) { 1452 return MD->getMetadataID() == DILexicalBlockKind; 1453 } 1454 }; 1455 1456 class DILexicalBlockFile : public DILexicalBlockBase { 1457 friend class LLVMContextImpl; 1458 friend class MDNode; 1459 1460 unsigned Discriminator; 1461 1462 DILexicalBlockFile(LLVMContext &C, StorageType Storage, 1463 unsigned Discriminator, ArrayRef<Metadata *> Ops) 1464 : DILexicalBlockBase(C, DILexicalBlockFileKind, Storage, Ops), 1465 Discriminator(Discriminator) {} 1466 ~DILexicalBlockFile() = default; 1467 1468 static DILexicalBlockFile *getImpl(LLVMContext &Context, DILocalScope *Scope, 1469 DIFile *File, unsigned Discriminator, 1470 StorageType Storage, 1471 bool ShouldCreate = true) { 1472 return getImpl(Context, static_cast<Metadata *>(Scope), 1473 static_cast<Metadata *>(File), Discriminator, Storage, 1474 ShouldCreate); 1475 } 1476 1477 static DILexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope, 1478 Metadata *File, unsigned Discriminator, 1479 StorageType Storage, 1480 bool ShouldCreate = true); 1481 1482 TempDILexicalBlockFile cloneImpl() const { 1483 return getTemporary(getContext(), getScope(), getFile(), 1484 getDiscriminator()); 1485 } 1486 1487 public: 1488 DEFINE_MDNODE_GET(DILexicalBlockFile, (DILocalScope * Scope, DIFile *File, 1489 unsigned Discriminator), 1490 (Scope, File, Discriminator)) 1491 DEFINE_MDNODE_GET(DILexicalBlockFile, 1492 (Metadata * Scope, Metadata *File, unsigned Discriminator), 1493 (Scope, File, Discriminator)) 1494 1495 TempDILexicalBlockFile clone() const { return cloneImpl(); } 1496 1497 // TODO: Remove these once they're gone from DILexicalBlockBase. 1498 unsigned getLine() const = delete; 1499 unsigned getColumn() const = delete; 1500 1501 unsigned getDiscriminator() const { return Discriminator; } 1502 1503 static bool classof(const Metadata *MD) { 1504 return MD->getMetadataID() == DILexicalBlockFileKind; 1505 } 1506 }; 1507 1508 unsigned DILocation::getDiscriminator() const { 1509 if (auto *F = dyn_cast<DILexicalBlockFile>(getScope())) 1510 return F->getDiscriminator(); 1511 return 0; 1512 } 1513 1514 class DINamespace : public DIScope { 1515 friend class LLVMContextImpl; 1516 friend class MDNode; 1517 1518 unsigned Line; 1519 1520 DINamespace(LLVMContext &Context, StorageType Storage, unsigned Line, 1521 ArrayRef<Metadata *> Ops) 1522 : DIScope(Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace, 1523 Ops), 1524 Line(Line) {} 1525 ~DINamespace() = default; 1526 1527 static DINamespace *getImpl(LLVMContext &Context, DIScope *Scope, 1528 DIFile *File, StringRef Name, unsigned Line, 1529 StorageType Storage, bool ShouldCreate = true) { 1530 return getImpl(Context, Scope, File, getCanonicalMDString(Context, Name), 1531 Line, Storage, ShouldCreate); 1532 } 1533 static DINamespace *getImpl(LLVMContext &Context, Metadata *Scope, 1534 Metadata *File, MDString *Name, unsigned Line, 1535 StorageType Storage, bool ShouldCreate = true); 1536 1537 TempDINamespace cloneImpl() const { 1538 return getTemporary(getContext(), getScope(), getFile(), getName(), 1539 getLine()); 1540 } 1541 1542 public: 1543 DEFINE_MDNODE_GET(DINamespace, (DIScope * Scope, DIFile *File, StringRef Name, 1544 unsigned Line), 1545 (Scope, File, Name, Line)) 1546 DEFINE_MDNODE_GET(DINamespace, (Metadata * Scope, Metadata *File, 1547 MDString *Name, unsigned Line), 1548 (Scope, File, Name, Line)) 1549 1550 TempDINamespace clone() const { return cloneImpl(); } 1551 1552 unsigned getLine() const { return Line; } 1553 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); } 1554 StringRef getName() const { return getStringOperand(2); } 1555 1556 Metadata *getRawScope() const { return getOperand(1); } 1557 MDString *getRawName() const { return getOperandAs<MDString>(2); } 1558 1559 static bool classof(const Metadata *MD) { 1560 return MD->getMetadataID() == DINamespaceKind; 1561 } 1562 }; 1563 1564 /// \brief A (clang) module that has been imported by the compile unit. 1565 /// 1566 class DIModule : public DIScope { 1567 friend class LLVMContextImpl; 1568 friend class MDNode; 1569 1570 DIModule(LLVMContext &Context, StorageType Storage, ArrayRef<Metadata *> Ops) 1571 : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) {} 1572 ~DIModule() {} 1573 1574 static DIModule *getImpl(LLVMContext &Context, DIScope *Scope, 1575 StringRef Name, StringRef ConfigurationMacros, 1576 StringRef IncludePath, StringRef ISysRoot, 1577 StorageType Storage, bool ShouldCreate = true) { 1578 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), 1579 getCanonicalMDString(Context, ConfigurationMacros), 1580 getCanonicalMDString(Context, IncludePath), 1581 getCanonicalMDString(Context, ISysRoot), 1582 Storage, ShouldCreate); 1583 } 1584 static DIModule *getImpl(LLVMContext &Context, Metadata *Scope, 1585 MDString *Name, MDString *ConfigurationMacros, 1586 MDString *IncludePath, MDString *ISysRoot, 1587 StorageType Storage, bool ShouldCreate = true); 1588 1589 TempDIModule cloneImpl() const { 1590 return getTemporary(getContext(), getScope(), getName(), 1591 getConfigurationMacros(), getIncludePath(), 1592 getISysRoot()); 1593 } 1594 1595 public: 1596 DEFINE_MDNODE_GET(DIModule, (DIScope *Scope, StringRef Name, 1597 StringRef ConfigurationMacros, StringRef IncludePath, 1598 StringRef ISysRoot), 1599 (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot)) 1600 DEFINE_MDNODE_GET(DIModule, 1601 (Metadata *Scope, MDString *Name, MDString *ConfigurationMacros, 1602 MDString *IncludePath, MDString *ISysRoot), 1603 (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot)) 1604 1605 TempDIModule clone() const { return cloneImpl(); } 1606 1607 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); } 1608 StringRef getName() const { return getStringOperand(1); } 1609 StringRef getConfigurationMacros() const { return getStringOperand(2); } 1610 StringRef getIncludePath() const { return getStringOperand(3); } 1611 StringRef getISysRoot() const { return getStringOperand(4); } 1612 1613 Metadata *getRawScope() const { return getOperand(0); } 1614 MDString *getRawName() const { return getOperandAs<MDString>(1); } 1615 MDString *getRawConfigurationMacros() const { return getOperandAs<MDString>(2); } 1616 MDString *getRawIncludePath() const { return getOperandAs<MDString>(3); } 1617 MDString *getRawISysRoot() const { return getOperandAs<MDString>(4); } 1618 1619 static bool classof(const Metadata *MD) { 1620 return MD->getMetadataID() == DIModuleKind; 1621 } 1622 }; 1623 1624 /// \brief Base class for template parameters. 1625 class DITemplateParameter : public DINode { 1626 protected: 1627 DITemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage, 1628 unsigned Tag, ArrayRef<Metadata *> Ops) 1629 : DINode(Context, ID, Storage, Tag, Ops) {} 1630 ~DITemplateParameter() = default; 1631 1632 public: 1633 StringRef getName() const { return getStringOperand(0); } 1634 DITypeRef getType() const { return DITypeRef(getRawType()); } 1635 1636 MDString *getRawName() const { return getOperandAs<MDString>(0); } 1637 Metadata *getRawType() const { return getOperand(1); } 1638 1639 static bool classof(const Metadata *MD) { 1640 return MD->getMetadataID() == DITemplateTypeParameterKind || 1641 MD->getMetadataID() == DITemplateValueParameterKind; 1642 } 1643 }; 1644 1645 class DITemplateTypeParameter : public DITemplateParameter { 1646 friend class LLVMContextImpl; 1647 friend class MDNode; 1648 1649 DITemplateTypeParameter(LLVMContext &Context, StorageType Storage, 1650 ArrayRef<Metadata *> Ops) 1651 : DITemplateParameter(Context, DITemplateTypeParameterKind, Storage, 1652 dwarf::DW_TAG_template_type_parameter, Ops) {} 1653 ~DITemplateTypeParameter() = default; 1654 1655 static DITemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name, 1656 DITypeRef Type, StorageType Storage, 1657 bool ShouldCreate = true) { 1658 return getImpl(Context, getCanonicalMDString(Context, Name), Type, Storage, 1659 ShouldCreate); 1660 } 1661 static DITemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name, 1662 Metadata *Type, StorageType Storage, 1663 bool ShouldCreate = true); 1664 1665 TempDITemplateTypeParameter cloneImpl() const { 1666 return getTemporary(getContext(), getName(), getType()); 1667 } 1668 1669 public: 1670 DEFINE_MDNODE_GET(DITemplateTypeParameter, (StringRef Name, DITypeRef Type), 1671 (Name, Type)) 1672 DEFINE_MDNODE_GET(DITemplateTypeParameter, (MDString * Name, Metadata *Type), 1673 (Name, Type)) 1674 1675 TempDITemplateTypeParameter clone() const { return cloneImpl(); } 1676 1677 static bool classof(const Metadata *MD) { 1678 return MD->getMetadataID() == DITemplateTypeParameterKind; 1679 } 1680 }; 1681 1682 class DITemplateValueParameter : public DITemplateParameter { 1683 friend class LLVMContextImpl; 1684 friend class MDNode; 1685 1686 DITemplateValueParameter(LLVMContext &Context, StorageType Storage, 1687 unsigned Tag, ArrayRef<Metadata *> Ops) 1688 : DITemplateParameter(Context, DITemplateValueParameterKind, Storage, Tag, 1689 Ops) {} 1690 ~DITemplateValueParameter() = default; 1691 1692 static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag, 1693 StringRef Name, DITypeRef Type, 1694 Metadata *Value, StorageType Storage, 1695 bool ShouldCreate = true) { 1696 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), Type, 1697 Value, Storage, ShouldCreate); 1698 } 1699 static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag, 1700 MDString *Name, Metadata *Type, 1701 Metadata *Value, StorageType Storage, 1702 bool ShouldCreate = true); 1703 1704 TempDITemplateValueParameter cloneImpl() const { 1705 return getTemporary(getContext(), getTag(), getName(), getType(), 1706 getValue()); 1707 } 1708 1709 public: 1710 DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, StringRef Name, 1711 DITypeRef Type, Metadata *Value), 1712 (Tag, Name, Type, Value)) 1713 DEFINE_MDNODE_GET(DITemplateValueParameter, (unsigned Tag, MDString *Name, 1714 Metadata *Type, Metadata *Value), 1715 (Tag, Name, Type, Value)) 1716 1717 TempDITemplateValueParameter clone() const { return cloneImpl(); } 1718 1719 Metadata *getValue() const { return getOperand(2); } 1720 1721 static bool classof(const Metadata *MD) { 1722 return MD->getMetadataID() == DITemplateValueParameterKind; 1723 } 1724 }; 1725 1726 /// \brief Base class for variables. 1727 class DIVariable : public DINode { 1728 unsigned Line; 1729 1730 protected: 1731 DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Line, 1732 ArrayRef<Metadata *> Ops) 1733 : DINode(C, ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line) {} 1734 ~DIVariable() = default; 1735 1736 public: 1737 unsigned getLine() const { return Line; } 1738 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); } 1739 StringRef getName() const { return getStringOperand(1); } 1740 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); } 1741 DITypeRef getType() const { return DITypeRef(getRawType()); } 1742 1743 StringRef getFilename() const { 1744 if (auto *F = getFile()) 1745 return F->getFilename(); 1746 return ""; 1747 } 1748 StringRef getDirectory() const { 1749 if (auto *F = getFile()) 1750 return F->getDirectory(); 1751 return ""; 1752 } 1753 1754 Metadata *getRawScope() const { return getOperand(0); } 1755 MDString *getRawName() const { return getOperandAs<MDString>(1); } 1756 Metadata *getRawFile() const { return getOperand(2); } 1757 Metadata *getRawType() const { return getOperand(3); } 1758 1759 static bool classof(const Metadata *MD) { 1760 return MD->getMetadataID() == DILocalVariableKind || 1761 MD->getMetadataID() == DIGlobalVariableKind; 1762 } 1763 }; 1764 1765 /// \brief Global variables. 1766 /// 1767 /// TODO: Remove DisplayName. It's always equal to Name. 1768 class DIGlobalVariable : public DIVariable { 1769 friend class LLVMContextImpl; 1770 friend class MDNode; 1771 1772 bool IsLocalToUnit; 1773 bool IsDefinition; 1774 1775 DIGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line, 1776 bool IsLocalToUnit, bool IsDefinition, 1777 ArrayRef<Metadata *> Ops) 1778 : DIVariable(C, DIGlobalVariableKind, Storage, Line, Ops), 1779 IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {} 1780 ~DIGlobalVariable() = default; 1781 1782 static DIGlobalVariable * 1783 getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name, 1784 StringRef LinkageName, DIFile *File, unsigned Line, DITypeRef Type, 1785 bool IsLocalToUnit, bool IsDefinition, Constant *Variable, 1786 DIDerivedType *StaticDataMemberDeclaration, StorageType Storage, 1787 bool ShouldCreate = true) { 1788 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), 1789 getCanonicalMDString(Context, LinkageName), File, Line, Type, 1790 IsLocalToUnit, IsDefinition, 1791 Variable ? ConstantAsMetadata::get(Variable) : nullptr, 1792 StaticDataMemberDeclaration, Storage, ShouldCreate); 1793 } 1794 static DIGlobalVariable * 1795 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name, 1796 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, 1797 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable, 1798 Metadata *StaticDataMemberDeclaration, StorageType Storage, 1799 bool ShouldCreate = true); 1800 1801 TempDIGlobalVariable cloneImpl() const { 1802 return getTemporary(getContext(), getScope(), getName(), getLinkageName(), 1803 getFile(), getLine(), getType(), isLocalToUnit(), 1804 isDefinition(), getVariable(), 1805 getStaticDataMemberDeclaration()); 1806 } 1807 1808 public: 1809 DEFINE_MDNODE_GET(DIGlobalVariable, 1810 (DIScope * Scope, StringRef Name, StringRef LinkageName, 1811 DIFile *File, unsigned Line, DITypeRef Type, 1812 bool IsLocalToUnit, bool IsDefinition, Constant *Variable, 1813 DIDerivedType *StaticDataMemberDeclaration), 1814 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, 1815 IsDefinition, Variable, StaticDataMemberDeclaration)) 1816 DEFINE_MDNODE_GET(DIGlobalVariable, 1817 (Metadata * Scope, MDString *Name, MDString *LinkageName, 1818 Metadata *File, unsigned Line, Metadata *Type, 1819 bool IsLocalToUnit, bool IsDefinition, Metadata *Variable, 1820 Metadata *StaticDataMemberDeclaration), 1821 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, 1822 IsDefinition, Variable, StaticDataMemberDeclaration)) 1823 1824 TempDIGlobalVariable clone() const { return cloneImpl(); } 1825 1826 bool isLocalToUnit() const { return IsLocalToUnit; } 1827 bool isDefinition() const { return IsDefinition; } 1828 StringRef getDisplayName() const { return getStringOperand(4); } 1829 StringRef getLinkageName() const { return getStringOperand(5); } 1830 Constant *getVariable() const { 1831 if (auto *C = cast_or_null<ConstantAsMetadata>(getRawVariable())) 1832 return dyn_cast<Constant>(C->getValue()); 1833 return nullptr; 1834 } 1835 DIDerivedType *getStaticDataMemberDeclaration() const { 1836 return cast_or_null<DIDerivedType>(getRawStaticDataMemberDeclaration()); 1837 } 1838 1839 MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); } 1840 Metadata *getRawVariable() const { return getOperand(6); } 1841 Metadata *getRawStaticDataMemberDeclaration() const { return getOperand(7); } 1842 1843 static bool classof(const Metadata *MD) { 1844 return MD->getMetadataID() == DIGlobalVariableKind; 1845 } 1846 }; 1847 1848 /// \brief Local variable. 1849 /// 1850 /// TODO: Split up flags. 1851 class DILocalVariable : public DIVariable { 1852 friend class LLVMContextImpl; 1853 friend class MDNode; 1854 1855 unsigned Arg; 1856 unsigned Flags; 1857 1858 DILocalVariable(LLVMContext &C, StorageType Storage, unsigned Line, 1859 unsigned Arg, unsigned Flags, ArrayRef<Metadata *> Ops) 1860 : DIVariable(C, DILocalVariableKind, Storage, Line, Ops), Arg(Arg), 1861 Flags(Flags) {} 1862 ~DILocalVariable() = default; 1863 1864 static DILocalVariable *getImpl(LLVMContext &Context, DIScope *Scope, 1865 StringRef Name, DIFile *File, unsigned Line, 1866 DITypeRef Type, unsigned Arg, unsigned Flags, 1867 StorageType Storage, 1868 bool ShouldCreate = true) { 1869 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File, 1870 Line, Type, Arg, Flags, Storage, ShouldCreate); 1871 } 1872 static DILocalVariable *getImpl(LLVMContext &Context, Metadata *Scope, 1873 MDString *Name, Metadata *File, unsigned Line, 1874 Metadata *Type, unsigned Arg, unsigned Flags, 1875 StorageType Storage, 1876 bool ShouldCreate = true); 1877 1878 TempDILocalVariable cloneImpl() const { 1879 return getTemporary(getContext(), getScope(), getName(), getFile(), 1880 getLine(), getType(), getArg(), getFlags()); 1881 } 1882 1883 public: 1884 DEFINE_MDNODE_GET(DILocalVariable, 1885 (DILocalScope * Scope, StringRef Name, DIFile *File, 1886 unsigned Line, DITypeRef Type, unsigned Arg, 1887 unsigned Flags), 1888 (Scope, Name, File, Line, Type, Arg, Flags)) 1889 DEFINE_MDNODE_GET(DILocalVariable, 1890 (Metadata * Scope, MDString *Name, Metadata *File, 1891 unsigned Line, Metadata *Type, unsigned Arg, 1892 unsigned Flags), 1893 (Scope, Name, File, Line, Type, Arg, Flags)) 1894 1895 TempDILocalVariable clone() const { return cloneImpl(); } 1896 1897 /// \brief Get the local scope for this variable. 1898 /// 1899 /// Variables must be defined in a local scope. 1900 DILocalScope *getScope() const { 1901 return cast<DILocalScope>(DIVariable::getScope()); 1902 } 1903 1904 bool isParameter() const { return Arg; } 1905 unsigned getArg() const { return Arg; } 1906 unsigned getFlags() const { return Flags; } 1907 1908 bool isArtificial() const { return getFlags() & FlagArtificial; } 1909 bool isObjectPointer() const { return getFlags() & FlagObjectPointer; } 1910 1911 /// \brief Check that a location is valid for this variable. 1912 /// 1913 /// Check that \c DL exists, is in the same subprogram, and has the same 1914 /// inlined-at location as \c this. (Otherwise, it's not a valid attachment 1915 /// to a \a DbgInfoIntrinsic.) 1916 bool isValidLocationForIntrinsic(const DILocation *DL) const { 1917 return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram(); 1918 } 1919 1920 static bool classof(const Metadata *MD) { 1921 return MD->getMetadataID() == DILocalVariableKind; 1922 } 1923 }; 1924 1925 /// \brief DWARF expression. 1926 /// 1927 /// This is (almost) a DWARF expression that modifies the location of a 1928 /// variable or (or the location of a single piece of a variable). 1929 /// 1930 /// FIXME: Instead of DW_OP_plus taking an argument, this should use DW_OP_const 1931 /// and have DW_OP_plus consume the topmost elements on the stack. 1932 /// 1933 /// TODO: Co-allocate the expression elements. 1934 /// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary 1935 /// storage types. 1936 class DIExpression : public MDNode { 1937 friend class LLVMContextImpl; 1938 friend class MDNode; 1939 1940 std::vector<uint64_t> Elements; 1941 1942 DIExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements) 1943 : MDNode(C, DIExpressionKind, Storage, None), 1944 Elements(Elements.begin(), Elements.end()) {} 1945 ~DIExpression() = default; 1946 1947 static DIExpression *getImpl(LLVMContext &Context, 1948 ArrayRef<uint64_t> Elements, StorageType Storage, 1949 bool ShouldCreate = true); 1950 1951 TempDIExpression cloneImpl() const { 1952 return getTemporary(getContext(), getElements()); 1953 } 1954 1955 public: 1956 DEFINE_MDNODE_GET(DIExpression, (ArrayRef<uint64_t> Elements), (Elements)) 1957 1958 TempDIExpression clone() const { return cloneImpl(); } 1959 1960 ArrayRef<uint64_t> getElements() const { return Elements; } 1961 1962 unsigned getNumElements() const { return Elements.size(); } 1963 uint64_t getElement(unsigned I) const { 1964 assert(I < Elements.size() && "Index out of range"); 1965 return Elements[I]; 1966 } 1967 1968 /// \brief Return whether this is a piece of an aggregate variable. 1969 bool isBitPiece() const; 1970 1971 /// \brief Return the offset of this piece in bits. 1972 uint64_t getBitPieceOffset() const; 1973 1974 /// \brief Return the size of this piece in bits. 1975 uint64_t getBitPieceSize() const; 1976 1977 typedef ArrayRef<uint64_t>::iterator element_iterator; 1978 element_iterator elements_begin() const { return getElements().begin(); } 1979 element_iterator elements_end() const { return getElements().end(); } 1980 1981 /// \brief A lightweight wrapper around an expression operand. 1982 /// 1983 /// TODO: Store arguments directly and change \a DIExpression to store a 1984 /// range of these. 1985 class ExprOperand { 1986 const uint64_t *Op; 1987 1988 public: 1989 explicit ExprOperand(const uint64_t *Op) : Op(Op) {} 1990 1991 const uint64_t *get() const { return Op; } 1992 1993 /// \brief Get the operand code. 1994 uint64_t getOp() const { return *Op; } 1995 1996 /// \brief Get an argument to the operand. 1997 /// 1998 /// Never returns the operand itself. 1999 uint64_t getArg(unsigned I) const { return Op[I + 1]; } 2000 2001 unsigned getNumArgs() const { return getSize() - 1; } 2002 2003 /// \brief Return the size of the operand. 2004 /// 2005 /// Return the number of elements in the operand (1 + args). 2006 unsigned getSize() const; 2007 }; 2008 2009 /// \brief An iterator for expression operands. 2010 class expr_op_iterator 2011 : public std::iterator<std::input_iterator_tag, ExprOperand> { 2012 ExprOperand Op; 2013 2014 public: 2015 explicit expr_op_iterator(element_iterator I) : Op(I) {} 2016 2017 element_iterator getBase() const { return Op.get(); } 2018 const ExprOperand &operator*() const { return Op; } 2019 const ExprOperand *operator->() const { return &Op; } 2020 2021 expr_op_iterator &operator++() { 2022 increment(); 2023 return *this; 2024 } 2025 expr_op_iterator operator++(int) { 2026 expr_op_iterator T(*this); 2027 increment(); 2028 return T; 2029 } 2030 2031 /// \brief Get the next iterator. 2032 /// 2033 /// \a std::next() doesn't work because this is technically an 2034 /// input_iterator, but it's a perfectly valid operation. This is an 2035 /// accessor to provide the same functionality. 2036 expr_op_iterator getNext() const { return ++expr_op_iterator(*this); } 2037 2038 bool operator==(const expr_op_iterator &X) const { 2039 return getBase() == X.getBase(); 2040 } 2041 bool operator!=(const expr_op_iterator &X) const { 2042 return getBase() != X.getBase(); 2043 } 2044 2045 private: 2046 void increment() { Op = ExprOperand(getBase() + Op.getSize()); } 2047 }; 2048 2049 /// \brief Visit the elements via ExprOperand wrappers. 2050 /// 2051 /// These range iterators visit elements through \a ExprOperand wrappers. 2052 /// This is not guaranteed to be a valid range unless \a isValid() gives \c 2053 /// true. 2054 /// 2055 /// \pre \a isValid() gives \c true. 2056 /// @{ 2057 expr_op_iterator expr_op_begin() const { 2058 return expr_op_iterator(elements_begin()); 2059 } 2060 expr_op_iterator expr_op_end() const { 2061 return expr_op_iterator(elements_end()); 2062 } 2063 /// @} 2064 2065 bool isValid() const; 2066 2067 static bool classof(const Metadata *MD) { 2068 return MD->getMetadataID() == DIExpressionKind; 2069 } 2070 }; 2071 2072 class DIObjCProperty : public DINode { 2073 friend class LLVMContextImpl; 2074 friend class MDNode; 2075 2076 unsigned Line; 2077 unsigned Attributes; 2078 2079 DIObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line, 2080 unsigned Attributes, ArrayRef<Metadata *> Ops) 2081 : DINode(C, DIObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property, 2082 Ops), 2083 Line(Line), Attributes(Attributes) {} 2084 ~DIObjCProperty() = default; 2085 2086 static DIObjCProperty * 2087 getImpl(LLVMContext &Context, StringRef Name, DIFile *File, unsigned Line, 2088 StringRef GetterName, StringRef SetterName, unsigned Attributes, 2089 DITypeRef Type, StorageType Storage, bool ShouldCreate = true) { 2090 return getImpl(Context, getCanonicalMDString(Context, Name), File, Line, 2091 getCanonicalMDString(Context, GetterName), 2092 getCanonicalMDString(Context, SetterName), Attributes, Type, 2093 Storage, ShouldCreate); 2094 } 2095 static DIObjCProperty *getImpl(LLVMContext &Context, MDString *Name, 2096 Metadata *File, unsigned Line, 2097 MDString *GetterName, MDString *SetterName, 2098 unsigned Attributes, Metadata *Type, 2099 StorageType Storage, bool ShouldCreate = true); 2100 2101 TempDIObjCProperty cloneImpl() const { 2102 return getTemporary(getContext(), getName(), getFile(), getLine(), 2103 getGetterName(), getSetterName(), getAttributes(), 2104 getType()); 2105 } 2106 2107 public: 2108 DEFINE_MDNODE_GET(DIObjCProperty, 2109 (StringRef Name, DIFile *File, unsigned Line, 2110 StringRef GetterName, StringRef SetterName, 2111 unsigned Attributes, DITypeRef Type), 2112 (Name, File, Line, GetterName, SetterName, Attributes, 2113 Type)) 2114 DEFINE_MDNODE_GET(DIObjCProperty, 2115 (MDString * Name, Metadata *File, unsigned Line, 2116 MDString *GetterName, MDString *SetterName, 2117 unsigned Attributes, Metadata *Type), 2118 (Name, File, Line, GetterName, SetterName, Attributes, 2119 Type)) 2120 2121 TempDIObjCProperty clone() const { return cloneImpl(); } 2122 2123 unsigned getLine() const { return Line; } 2124 unsigned getAttributes() const { return Attributes; } 2125 StringRef getName() const { return getStringOperand(0); } 2126 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); } 2127 StringRef getGetterName() const { return getStringOperand(2); } 2128 StringRef getSetterName() const { return getStringOperand(3); } 2129 DITypeRef getType() const { return DITypeRef(getRawType()); } 2130 2131 StringRef getFilename() const { 2132 if (auto *F = getFile()) 2133 return F->getFilename(); 2134 return ""; 2135 } 2136 StringRef getDirectory() const { 2137 if (auto *F = getFile()) 2138 return F->getDirectory(); 2139 return ""; 2140 } 2141 2142 MDString *getRawName() const { return getOperandAs<MDString>(0); } 2143 Metadata *getRawFile() const { return getOperand(1); } 2144 MDString *getRawGetterName() const { return getOperandAs<MDString>(2); } 2145 MDString *getRawSetterName() const { return getOperandAs<MDString>(3); } 2146 Metadata *getRawType() const { return getOperand(4); } 2147 2148 static bool classof(const Metadata *MD) { 2149 return MD->getMetadataID() == DIObjCPropertyKind; 2150 } 2151 }; 2152 2153 /// \brief An imported module (C++ using directive or similar). 2154 class DIImportedEntity : public DINode { 2155 friend class LLVMContextImpl; 2156 friend class MDNode; 2157 2158 unsigned Line; 2159 2160 DIImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag, 2161 unsigned Line, ArrayRef<Metadata *> Ops) 2162 : DINode(C, DIImportedEntityKind, Storage, Tag, Ops), Line(Line) {} 2163 ~DIImportedEntity() = default; 2164 2165 static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag, 2166 DIScope *Scope, DINodeRef Entity, 2167 unsigned Line, StringRef Name, 2168 StorageType Storage, 2169 bool ShouldCreate = true) { 2170 return getImpl(Context, Tag, Scope, Entity, Line, 2171 getCanonicalMDString(Context, Name), Storage, ShouldCreate); 2172 } 2173 static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag, 2174 Metadata *Scope, Metadata *Entity, 2175 unsigned Line, MDString *Name, 2176 StorageType Storage, 2177 bool ShouldCreate = true); 2178 2179 TempDIImportedEntity cloneImpl() const { 2180 return getTemporary(getContext(), getTag(), getScope(), getEntity(), 2181 getLine(), getName()); 2182 } 2183 2184 public: 2185 DEFINE_MDNODE_GET(DIImportedEntity, 2186 (unsigned Tag, DIScope *Scope, DINodeRef Entity, 2187 unsigned Line, StringRef Name = ""), 2188 (Tag, Scope, Entity, Line, Name)) 2189 DEFINE_MDNODE_GET(DIImportedEntity, 2190 (unsigned Tag, Metadata *Scope, Metadata *Entity, 2191 unsigned Line, MDString *Name), 2192 (Tag, Scope, Entity, Line, Name)) 2193 2194 TempDIImportedEntity clone() const { return cloneImpl(); } 2195 2196 unsigned getLine() const { return Line; } 2197 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); } 2198 DINodeRef getEntity() const { return DINodeRef(getRawEntity()); } 2199 StringRef getName() const { return getStringOperand(2); } 2200 2201 Metadata *getRawScope() const { return getOperand(0); } 2202 Metadata *getRawEntity() const { return getOperand(1); } 2203 MDString *getRawName() const { return getOperandAs<MDString>(2); } 2204 2205 static bool classof(const Metadata *MD) { 2206 return MD->getMetadataID() == DIImportedEntityKind; 2207 } 2208 }; 2209 2210 /// \brief Macro Info DWARF-like metadata node. 2211 /// 2212 /// A metadata node with a DWARF macro info (i.e., a constant named 2213 /// \c DW_MACINFO_*, defined in llvm/Support/Dwarf.h). Called \a DIMacroNode 2214 /// because it's potentially used for non-DWARF output. 2215 class DIMacroNode : public MDNode { 2216 friend class LLVMContextImpl; 2217 friend class MDNode; 2218 2219 protected: 2220 DIMacroNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned MIType, 2221 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None) 2222 : MDNode(C, ID, Storage, Ops1, Ops2) { 2223 assert(MIType < 1u << 16); 2224 SubclassData16 = MIType; 2225 } 2226 ~DIMacroNode() = default; 2227 2228 template <class Ty> Ty *getOperandAs(unsigned I) const { 2229 return cast_or_null<Ty>(getOperand(I)); 2230 } 2231 2232 StringRef getStringOperand(unsigned I) const { 2233 if (auto *S = getOperandAs<MDString>(I)) 2234 return S->getString(); 2235 return StringRef(); 2236 } 2237 2238 static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) { 2239 if (S.empty()) 2240 return nullptr; 2241 return MDString::get(Context, S); 2242 } 2243 2244 public: 2245 unsigned getMacinfoType() const { return SubclassData16; } 2246 2247 static bool classof(const Metadata *MD) { 2248 switch (MD->getMetadataID()) { 2249 default: 2250 return false; 2251 case DIMacroKind: 2252 case DIMacroFileKind: 2253 return true; 2254 } 2255 } 2256 }; 2257 2258 class DIMacro : public DIMacroNode { 2259 friend class LLVMContextImpl; 2260 friend class MDNode; 2261 2262 unsigned Line; 2263 2264 DIMacro(LLVMContext &C, StorageType Storage, unsigned MIType, unsigned Line, 2265 ArrayRef<Metadata *> Ops) 2266 : DIMacroNode(C, DIMacroKind, Storage, MIType, Ops), Line(Line) {} 2267 ~DIMacro() = default; 2268 2269 static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line, 2270 StringRef Name, StringRef Value, StorageType Storage, 2271 bool ShouldCreate = true) { 2272 return getImpl(Context, MIType, Line, getCanonicalMDString(Context, Name), 2273 getCanonicalMDString(Context, Value), Storage, ShouldCreate); 2274 } 2275 static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line, 2276 MDString *Name, MDString *Value, StorageType Storage, 2277 bool ShouldCreate = true); 2278 2279 TempDIMacro cloneImpl() const { 2280 return getTemporary(getContext(), getMacinfoType(), getLine(), getName(), 2281 getValue()); 2282 } 2283 2284 public: 2285 DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, StringRef Name, 2286 StringRef Value = ""), 2287 (MIType, Line, Name, Value)) 2288 DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, MDString *Name, 2289 MDString *Value), 2290 (MIType, Line, Name, Value)) 2291 2292 TempDIMacro clone() const { return cloneImpl(); } 2293 2294 unsigned getLine() const { return Line; } 2295 2296 StringRef getName() const { return getStringOperand(0); } 2297 StringRef getValue() const { return getStringOperand(1); } 2298 2299 MDString *getRawName() const { return getOperandAs<MDString>(0); } 2300 MDString *getRawValue() const { return getOperandAs<MDString>(1); } 2301 2302 static bool classof(const Metadata *MD) { 2303 return MD->getMetadataID() == DIMacroKind; 2304 } 2305 }; 2306 2307 class DIMacroFile : public DIMacroNode { 2308 friend class LLVMContextImpl; 2309 friend class MDNode; 2310 2311 unsigned Line; 2312 2313 DIMacroFile(LLVMContext &C, StorageType Storage, unsigned MIType, 2314 unsigned Line, ArrayRef<Metadata *> Ops) 2315 : DIMacroNode(C, DIMacroFileKind, Storage, MIType, Ops), Line(Line) {} 2316 ~DIMacroFile() = default; 2317 2318 static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType, 2319 unsigned Line, DIFile *File, 2320 DIMacroNodeArray Elements, StorageType Storage, 2321 bool ShouldCreate = true) { 2322 return getImpl(Context, MIType, Line, static_cast<Metadata *>(File), 2323 Elements.get(), Storage, ShouldCreate); 2324 } 2325 2326 static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType, 2327 unsigned Line, Metadata *File, Metadata *Elements, 2328 StorageType Storage, bool ShouldCreate = true); 2329 2330 TempDIMacroFile cloneImpl() const { 2331 return getTemporary(getContext(), getMacinfoType(), getLine(), getFile(), 2332 getElements()); 2333 } 2334 2335 public: 2336 DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line, DIFile *File, 2337 DIMacroNodeArray Elements), 2338 (MIType, Line, File, Elements)) 2339 DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line, 2340 Metadata *File, Metadata *Elements), 2341 (MIType, Line, File, Elements)) 2342 2343 TempDIMacroFile clone() const { return cloneImpl(); } 2344 2345 void replaceElements(DIMacroNodeArray Elements) { 2346 #ifndef NDEBUG 2347 for (DIMacroNode *Op : getElements()) 2348 assert(std::find(Elements->op_begin(), Elements->op_end(), Op) && 2349 "Lost a macro node during macro node list replacement"); 2350 #endif 2351 replaceOperandWith(1, Elements.get()); 2352 } 2353 2354 unsigned getLine() const { return Line; } 2355 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); } 2356 2357 DIMacroNodeArray getElements() const { 2358 return cast_or_null<MDTuple>(getRawElements()); 2359 } 2360 2361 Metadata *getRawFile() const { return getOperand(0); } 2362 Metadata *getRawElements() const { return getOperand(1); } 2363 2364 static bool classof(const Metadata *MD) { 2365 return MD->getMetadataID() == DIMacroFileKind; 2366 } 2367 }; 2368 2369 } // end namespace llvm 2370 2371 #undef DEFINE_MDNODE_GET_UNPACK_IMPL 2372 #undef DEFINE_MDNODE_GET_UNPACK 2373 #undef DEFINE_MDNODE_GET 2374 2375 #endif 2376
