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