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