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