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 63namespace llvm { 64 65extern cl::opt<bool> EnableFSDiscriminator; 66 67class DITypeRefArray { 68 const MDTuple *N = nullptr; 69 70public: 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. 127class DINode : public MDNode { 128 friend class LLVMContextImpl; 129 friend class MDNode; 130 131protected: 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 159public: 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. 225class 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 256public: 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. 296class 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 323public: 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 362class 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 383public: 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. 412class 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 443public: 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. 476class DIScope : public DINode { 477protected: 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 483public: 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. 530class DIFile : public DIScope { 531 friend class LLVMContextImpl; 532 friend class MDNode; 533 534public: 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 567private: 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 602public: 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 639StringRef DIScope::getFilename() const { 640 if (auto *F = getFile()) 641 return F->getFilename(); 642 return ""; 643} 644 645StringRef DIScope::getDirectory() const { 646 if (auto *F = getFile()) 647 return F->getDirectory(); 648 return ""; 649} 650 651Optional<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. 662class DIType : public DIScope { 663 unsigned Line; 664 DIFlags Flags; 665 uint64_t SizeInBits; 666 uint64_t OffsetInBits; 667 uint32_t AlignInBits; 668 669protected: 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 695public: 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. 769class 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 803public: 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) 837class 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 872public: 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.). 917class 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 960public: 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. 1051class 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 1112public: 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. 1263class 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 1293public: 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. 1317class DICompileUnit : public DIScope { 1318 friend class LLVMContextImpl; 1319 friend class MDNode; 1320 1321public: 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 1342private: 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 1410public: 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. 1532class DILocalScope : public DIScope { 1533protected: 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 1539public: 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. 1562class 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 1590public: 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 BASE_DIS_BIT_END; } 1745 1746 /// Returns the base discriminator for a given encoded discriminator \p D. 1747 static unsigned getBaseDiscriminatorFromDiscriminator(unsigned D) { 1748 if (EnableFSDiscriminator) 1749 return getMaskedDiscriminator(D, getBaseDiscriminatorBits()); 1750 return getUnsignedFromPrefixEncoding(D); 1751 } 1752 1753 /// Raw encoding of the discriminator. APIs such as cloneWithDuplicationFactor 1754 /// have certain special case behavior (e.g. treating empty duplication factor 1755 /// as the value '1'). 1756 /// This API, in conjunction with cloneWithDiscriminator, may be used to encode 1757 /// the raw values provided. \p BD: base discriminator \p DF: duplication factor 1758 /// \p CI: copy index 1759 /// The return is None if the values cannot be encoded in 32 bits - for 1760 /// example, values for BD or DF larger than 12 bits. Otherwise, the return 1761 /// is the encoded value. 1762 static Optional<unsigned> encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI); 1763 1764 /// Raw decoder for values in an encoded discriminator D. 1765 static void decodeDiscriminator(unsigned D, unsigned &BD, unsigned &DF, 1766 unsigned &CI); 1767 1768 /// Returns the duplication factor for a given encoded discriminator \p D, or 1769 /// 1 if no value or 0 is encoded. 1770 static unsigned getDuplicationFactorFromDiscriminator(unsigned D) { 1771 if (EnableFSDiscriminator) 1772 return 1; 1773 D = getNextComponentInDiscriminator(D); 1774 unsigned Ret = getUnsignedFromPrefixEncoding(D); 1775 if (Ret == 0) 1776 return 1; 1777 return Ret; 1778 } 1779 1780 /// Returns the copy identifier for a given encoded discriminator \p D. 1781 static unsigned getCopyIdentifierFromDiscriminator(unsigned D) { 1782 return getUnsignedFromPrefixEncoding(getNextComponentInDiscriminator( 1783 getNextComponentInDiscriminator(D))); 1784 } 1785 1786 1787 Metadata *getRawScope() const { return getOperand(0); } 1788 Metadata *getRawInlinedAt() const { 1789 if (getNumOperands() == 2) 1790 return getOperand(1); 1791 return nullptr; 1792 } 1793 1794 static bool classof(const Metadata *MD) { 1795 return MD->getMetadataID() == DILocationKind; 1796 } 1797}; 1798 1799/// Subprogram description. 1800class DISubprogram : public DILocalScope { 1801 friend class LLVMContextImpl; 1802 friend class MDNode; 1803 1804 unsigned Line; 1805 unsigned ScopeLine; 1806 unsigned VirtualIndex; 1807 1808 /// In the MS ABI, the implicit 'this' parameter is adjusted in the prologue 1809 /// of method overrides from secondary bases by this amount. It may be 1810 /// negative. 1811 int ThisAdjustment; 1812 1813public: 1814 /// Debug info subprogram flags. 1815 enum DISPFlags : uint32_t { 1816#define HANDLE_DISP_FLAG(ID, NAME) SPFlag##NAME = ID, 1817#define DISP_FLAG_LARGEST_NEEDED 1818#include "llvm/IR/DebugInfoFlags.def" 1819 SPFlagNonvirtual = SPFlagZero, 1820 SPFlagVirtuality = SPFlagVirtual | SPFlagPureVirtual, 1821 LLVM_MARK_AS_BITMASK_ENUM(SPFlagLargest) 1822 }; 1823 1824 static DISPFlags getFlag(StringRef Flag); 1825 static StringRef getFlagString(DISPFlags Flag); 1826 1827 /// Split up a flags bitfield for easier printing. 1828 /// 1829 /// Split \c Flags into \c SplitFlags, a vector of its components. Returns 1830 /// any remaining (unrecognized) bits. 1831 static DISPFlags splitFlags(DISPFlags Flags, 1832 SmallVectorImpl<DISPFlags> &SplitFlags); 1833 1834 // Helper for converting old bitfields to new flags word. 1835 static DISPFlags toSPFlags(bool IsLocalToUnit, bool IsDefinition, 1836 bool IsOptimized, 1837 unsigned Virtuality = SPFlagNonvirtual, 1838 bool IsMainSubprogram = false) { 1839 // We're assuming virtuality is the low-order field. 1840 static_assert( 1841 int(SPFlagVirtual) == int(dwarf::DW_VIRTUALITY_virtual) && 1842 int(SPFlagPureVirtual) == int(dwarf::DW_VIRTUALITY_pure_virtual), 1843 "Virtuality constant mismatch"); 1844 return static_cast<DISPFlags>( 1845 (Virtuality & SPFlagVirtuality) | 1846 (IsLocalToUnit ? SPFlagLocalToUnit : SPFlagZero) | 1847 (IsDefinition ? SPFlagDefinition : SPFlagZero) | 1848 (IsOptimized ? SPFlagOptimized : SPFlagZero) | 1849 (IsMainSubprogram ? SPFlagMainSubprogram : SPFlagZero)); 1850 } 1851 1852private: 1853 DIFlags Flags; 1854 DISPFlags SPFlags; 1855 1856 DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line, 1857 unsigned ScopeLine, unsigned VirtualIndex, int ThisAdjustment, 1858 DIFlags Flags, DISPFlags SPFlags, ArrayRef<Metadata *> Ops) 1859 : DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram, 1860 Ops), 1861 Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex), 1862 ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags) { 1863 static_assert(dwarf::DW_VIRTUALITY_max < 4, "Virtuality out of range"); 1864 } 1865 ~DISubprogram() = default; 1866 1867 static DISubprogram * 1868 getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name, 1869 StringRef LinkageName, DIFile *File, unsigned Line, 1870 DISubroutineType *Type, unsigned ScopeLine, DIType *ContainingType, 1871 unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags, 1872 DISPFlags SPFlags, DICompileUnit *Unit, 1873 DITemplateParameterArray TemplateParams, DISubprogram *Declaration, 1874 DINodeArray RetainedNodes, DITypeArray ThrownTypes, 1875 StorageType Storage, bool ShouldCreate = true) { 1876 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), 1877 getCanonicalMDString(Context, LinkageName), File, Line, Type, 1878 ScopeLine, ContainingType, VirtualIndex, ThisAdjustment, 1879 Flags, SPFlags, Unit, TemplateParams.get(), Declaration, 1880 RetainedNodes.get(), ThrownTypes.get(), Storage, 1881 ShouldCreate); 1882 } 1883 static DISubprogram *getImpl(LLVMContext &Context, Metadata *Scope, 1884 MDString *Name, MDString *LinkageName, 1885 Metadata *File, unsigned Line, Metadata *Type, 1886 unsigned ScopeLine, Metadata *ContainingType, 1887 unsigned VirtualIndex, int ThisAdjustment, 1888 DIFlags Flags, DISPFlags SPFlags, Metadata *Unit, 1889 Metadata *TemplateParams, Metadata *Declaration, 1890 Metadata *RetainedNodes, Metadata *ThrownTypes, 1891 StorageType Storage, bool ShouldCreate = true); 1892 1893 TempDISubprogram cloneImpl() const { 1894 return getTemporary(getContext(), getScope(), getName(), getLinkageName(), 1895 getFile(), getLine(), getType(), getScopeLine(), 1896 getContainingType(), getVirtualIndex(), 1897 getThisAdjustment(), getFlags(), getSPFlags(), 1898 getUnit(), getTemplateParams(), getDeclaration(), 1899 getRetainedNodes(), getThrownTypes()); 1900 } 1901 1902public: 1903 DEFINE_MDNODE_GET( 1904 DISubprogram, 1905 (DIScope * Scope, StringRef Name, StringRef LinkageName, DIFile *File, 1906 unsigned Line, DISubroutineType *Type, unsigned ScopeLine, 1907 DIType *ContainingType, unsigned VirtualIndex, int ThisAdjustment, 1908 DIFlags Flags, DISPFlags SPFlags, DICompileUnit *Unit, 1909 DITemplateParameterArray TemplateParams = nullptr, 1910 DISubprogram *Declaration = nullptr, DINodeArray RetainedNodes = nullptr, 1911 DITypeArray ThrownTypes = nullptr), 1912 (Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType, 1913 VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams, 1914 Declaration, RetainedNodes, ThrownTypes)) 1915 1916 DEFINE_MDNODE_GET( 1917 DISubprogram, 1918 (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File, 1919 unsigned Line, Metadata *Type, unsigned ScopeLine, 1920 Metadata *ContainingType, unsigned VirtualIndex, int ThisAdjustment, 1921 DIFlags Flags, DISPFlags SPFlags, Metadata *Unit, 1922 Metadata *TemplateParams = nullptr, Metadata *Declaration = nullptr, 1923 Metadata *RetainedNodes = nullptr, Metadata *ThrownTypes = nullptr), 1924 (Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType, 1925 VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams, 1926 Declaration, RetainedNodes, ThrownTypes)) 1927 1928 TempDISubprogram clone() const { return cloneImpl(); } 1929 1930 /// Returns a new temporary DISubprogram with updated Flags 1931 TempDISubprogram cloneWithFlags(DIFlags NewFlags) const { 1932 auto NewSP = clone(); 1933 NewSP->Flags = NewFlags; 1934 return NewSP; 1935 } 1936 1937public: 1938 unsigned getLine() const { return Line; } 1939 unsigned getVirtuality() const { return getSPFlags() & SPFlagVirtuality; } 1940 unsigned getVirtualIndex() const { return VirtualIndex; } 1941 int getThisAdjustment() const { return ThisAdjustment; } 1942 unsigned getScopeLine() const { return ScopeLine; } 1943 void setScopeLine(unsigned L) { assert(isDistinct()); ScopeLine = L; } 1944 DIFlags getFlags() const { return Flags; } 1945 DISPFlags getSPFlags() const { return SPFlags; } 1946 bool isLocalToUnit() const { return getSPFlags() & SPFlagLocalToUnit; } 1947 bool isDefinition() const { return getSPFlags() & SPFlagDefinition; } 1948 bool isOptimized() const { return getSPFlags() & SPFlagOptimized; } 1949 bool isMainSubprogram() const { return getSPFlags() & SPFlagMainSubprogram; } 1950 1951 bool isArtificial() const { return getFlags() & FlagArtificial; } 1952 bool isPrivate() const { 1953 return (getFlags() & FlagAccessibility) == FlagPrivate; 1954 } 1955 bool isProtected() const { 1956 return (getFlags() & FlagAccessibility) == FlagProtected; 1957 } 1958 bool isPublic() const { 1959 return (getFlags() & FlagAccessibility) == FlagPublic; 1960 } 1961 bool isExplicit() const { return getFlags() & FlagExplicit; } 1962 bool isPrototyped() const { return getFlags() & FlagPrototyped; } 1963 bool areAllCallsDescribed() const { 1964 return getFlags() & FlagAllCallsDescribed; 1965 } 1966 bool isPure() const { return getSPFlags() & SPFlagPure; } 1967 bool isElemental() const { return getSPFlags() & SPFlagElemental; } 1968 bool isRecursive() const { return getSPFlags() & SPFlagRecursive; } 1969 bool isObjCDirect() const { return getSPFlags() & SPFlagObjCDirect; } 1970 1971 /// Check if this is deleted member function. 1972 /// 1973 /// Return true if this subprogram is a C++11 special 1974 /// member function declared deleted. 1975 bool isDeleted() const { return getSPFlags() & SPFlagDeleted; } 1976 1977 /// Check if this is reference-qualified. 1978 /// 1979 /// Return true if this subprogram is a C++11 reference-qualified non-static 1980 /// member function (void foo() &). 1981 bool isLValueReference() const { return getFlags() & FlagLValueReference; } 1982 1983 /// Check if this is rvalue-reference-qualified. 1984 /// 1985 /// Return true if this subprogram is a C++11 rvalue-reference-qualified 1986 /// non-static member function (void foo() &&). 1987 bool isRValueReference() const { return getFlags() & FlagRValueReference; } 1988 1989 /// Check if this is marked as noreturn. 1990 /// 1991 /// Return true if this subprogram is C++11 noreturn or C11 _Noreturn 1992 bool isNoReturn() const { return getFlags() & FlagNoReturn; } 1993 1994 // Check if this routine is a compiler-generated thunk. 1995 // 1996 // Returns true if this subprogram is a thunk generated by the compiler. 1997 bool isThunk() const { return getFlags() & FlagThunk; } 1998 1999 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); } 2000 2001 StringRef getName() const { return getStringOperand(2); } 2002 StringRef getLinkageName() const { return getStringOperand(3); } 2003 /// Only used by clients of CloneFunction, and only right after the cloning. 2004 void replaceLinkageName(MDString *LN) { replaceOperandWith(3, LN); } 2005 2006 DISubroutineType *getType() const { 2007 return cast_or_null<DISubroutineType>(getRawType()); 2008 } 2009 DIType *getContainingType() const { 2010 return cast_or_null<DIType>(getRawContainingType()); 2011 } 2012 2013 DICompileUnit *getUnit() const { 2014 return cast_or_null<DICompileUnit>(getRawUnit()); 2015 } 2016 void replaceUnit(DICompileUnit *CU) { replaceOperandWith(5, CU); } 2017 DITemplateParameterArray getTemplateParams() const { 2018 return cast_or_null<MDTuple>(getRawTemplateParams()); 2019 } 2020 DISubprogram *getDeclaration() const { 2021 return cast_or_null<DISubprogram>(getRawDeclaration()); 2022 } 2023 DINodeArray getRetainedNodes() const { 2024 return cast_or_null<MDTuple>(getRawRetainedNodes()); 2025 } 2026 DITypeArray getThrownTypes() const { 2027 return cast_or_null<MDTuple>(getRawThrownTypes()); 2028 } 2029 2030 Metadata *getRawScope() const { return getOperand(1); } 2031 MDString *getRawName() const { return getOperandAs<MDString>(2); } 2032 MDString *getRawLinkageName() const { return getOperandAs<MDString>(3); } 2033 Metadata *getRawType() const { return getOperand(4); } 2034 Metadata *getRawUnit() const { return getOperand(5); } 2035 Metadata *getRawDeclaration() const { return getOperand(6); } 2036 Metadata *getRawRetainedNodes() const { return getOperand(7); } 2037 Metadata *getRawContainingType() const { 2038 return getNumOperands() > 8 ? getOperandAs<Metadata>(8) : nullptr; 2039 } 2040 Metadata *getRawTemplateParams() const { 2041 return getNumOperands() > 9 ? getOperandAs<Metadata>(9) : nullptr; 2042 } 2043 Metadata *getRawThrownTypes() const { 2044 return getNumOperands() > 10 ? getOperandAs<Metadata>(10) : nullptr; 2045 } 2046 2047 void replaceRawLinkageName(MDString *LinkageName) { 2048 replaceOperandWith(3, LinkageName); 2049 } 2050 2051 /// Check if this subprogram describes the given function. 2052 /// 2053 /// FIXME: Should this be looking through bitcasts? 2054 bool describes(const Function *F) const; 2055 2056 static bool classof(const Metadata *MD) { 2057 return MD->getMetadataID() == DISubprogramKind; 2058 } 2059}; 2060 2061class DILexicalBlockBase : public DILocalScope { 2062protected: 2063 DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage, 2064 ArrayRef<Metadata *> Ops) 2065 : DILocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {} 2066 ~DILexicalBlockBase() = default; 2067 2068public: 2069 DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); } 2070 2071 Metadata *getRawScope() const { return getOperand(1); } 2072 2073 static bool classof(const Metadata *MD) { 2074 return MD->getMetadataID() == DILexicalBlockKind || 2075 MD->getMetadataID() == DILexicalBlockFileKind; 2076 } 2077}; 2078 2079class DILexicalBlock : public DILexicalBlockBase { 2080 friend class LLVMContextImpl; 2081 friend class MDNode; 2082 2083 unsigned Line; 2084 uint16_t Column; 2085 2086 DILexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line, 2087 unsigned Column, ArrayRef<Metadata *> Ops) 2088 : DILexicalBlockBase(C, DILexicalBlockKind, Storage, Ops), Line(Line), 2089 Column(Column) { 2090 assert(Column < (1u << 16) && "Expected 16-bit column"); 2091 } 2092 ~DILexicalBlock() = default; 2093 2094 static DILexicalBlock *getImpl(LLVMContext &Context, DILocalScope *Scope, 2095 DIFile *File, unsigned Line, unsigned Column, 2096 StorageType Storage, 2097 bool ShouldCreate = true) { 2098 return getImpl(Context, static_cast<Metadata *>(Scope), 2099 static_cast<Metadata *>(File), Line, Column, Storage, 2100 ShouldCreate); 2101 } 2102 2103 static DILexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope, 2104 Metadata *File, unsigned Line, unsigned Column, 2105 StorageType Storage, bool ShouldCreate = true); 2106 2107 TempDILexicalBlock cloneImpl() const { 2108 return getTemporary(getContext(), getScope(), getFile(), getLine(), 2109 getColumn()); 2110 } 2111 2112public: 2113 DEFINE_MDNODE_GET(DILexicalBlock, (DILocalScope * Scope, DIFile *File, 2114 unsigned Line, unsigned Column), 2115 (Scope, File, Line, Column)) 2116 DEFINE_MDNODE_GET(DILexicalBlock, (Metadata * Scope, Metadata *File, 2117 unsigned Line, unsigned Column), 2118 (Scope, File, Line, Column)) 2119 2120 TempDILexicalBlock clone() const { return cloneImpl(); } 2121 2122 unsigned getLine() const { return Line; } 2123 unsigned getColumn() const { return Column; } 2124 2125 static bool classof(const Metadata *MD) { 2126 return MD->getMetadataID() == DILexicalBlockKind; 2127 } 2128}; 2129 2130class DILexicalBlockFile : public DILexicalBlockBase { 2131 friend class LLVMContextImpl; 2132 friend class MDNode; 2133 2134 unsigned Discriminator; 2135 2136 DILexicalBlockFile(LLVMContext &C, StorageType Storage, 2137 unsigned Discriminator, ArrayRef<Metadata *> Ops) 2138 : DILexicalBlockBase(C, DILexicalBlockFileKind, Storage, Ops), 2139 Discriminator(Discriminator) {} 2140 ~DILexicalBlockFile() = default; 2141 2142 static DILexicalBlockFile *getImpl(LLVMContext &Context, DILocalScope *Scope, 2143 DIFile *File, unsigned Discriminator, 2144 StorageType Storage, 2145 bool ShouldCreate = true) { 2146 return getImpl(Context, static_cast<Metadata *>(Scope), 2147 static_cast<Metadata *>(File), Discriminator, Storage, 2148 ShouldCreate); 2149 } 2150 2151 static DILexicalBlockFile *getImpl(LLVMContext &Context, Metadata *Scope, 2152 Metadata *File, unsigned Discriminator, 2153 StorageType Storage, 2154 bool ShouldCreate = true); 2155 2156 TempDILexicalBlockFile cloneImpl() const { 2157 return getTemporary(getContext(), getScope(), getFile(), 2158 getDiscriminator()); 2159 } 2160 2161public: 2162 DEFINE_MDNODE_GET(DILexicalBlockFile, (DILocalScope * Scope, DIFile *File, 2163 unsigned Discriminator), 2164 (Scope, File, Discriminator)) 2165 DEFINE_MDNODE_GET(DILexicalBlockFile, 2166 (Metadata * Scope, Metadata *File, unsigned Discriminator), 2167 (Scope, File, Discriminator)) 2168 2169 TempDILexicalBlockFile clone() const { return cloneImpl(); } 2170 unsigned getDiscriminator() const { return Discriminator; } 2171 2172 static bool classof(const Metadata *MD) { 2173 return MD->getMetadataID() == DILexicalBlockFileKind; 2174 } 2175}; 2176 2177unsigned DILocation::getDiscriminator() const { 2178 if (auto *F = dyn_cast<DILexicalBlockFile>(getScope())) 2179 return F->getDiscriminator(); 2180 return 0; 2181} 2182 2183const DILocation * 2184DILocation::cloneWithDiscriminator(unsigned Discriminator) const { 2185 DIScope *Scope = getScope(); 2186 // Skip all parent DILexicalBlockFile that already have a discriminator 2187 // assigned. We do not want to have nested DILexicalBlockFiles that have 2188 // mutliple discriminators because only the leaf DILexicalBlockFile's 2189 // dominator will be used. 2190 for (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope); 2191 LBF && LBF->getDiscriminator() != 0; 2192 LBF = dyn_cast<DILexicalBlockFile>(Scope)) 2193 Scope = LBF->getScope(); 2194 DILexicalBlockFile *NewScope = 2195 DILexicalBlockFile::get(getContext(), Scope, getFile(), Discriminator); 2196 return DILocation::get(getContext(), getLine(), getColumn(), NewScope, 2197 getInlinedAt()); 2198} 2199 2200unsigned DILocation::getBaseDiscriminator() const { 2201 return getBaseDiscriminatorFromDiscriminator(getDiscriminator()); 2202} 2203 2204unsigned DILocation::getDuplicationFactor() const { 2205 return getDuplicationFactorFromDiscriminator(getDiscriminator()); 2206} 2207 2208unsigned DILocation::getCopyIdentifier() const { 2209 return getCopyIdentifierFromDiscriminator(getDiscriminator()); 2210} 2211 2212Optional<const DILocation *> DILocation::cloneWithBaseDiscriminator(unsigned D) const { 2213 unsigned BD, DF, CI; 2214 2215 if (EnableFSDiscriminator) { 2216 BD = getBaseDiscriminator(); 2217 if (D == BD) 2218 return this; 2219 return cloneWithDiscriminator(D); 2220 } 2221 2222 decodeDiscriminator(getDiscriminator(), BD, DF, CI); 2223 if (D == BD) 2224 return this; 2225 if (Optional<unsigned> Encoded = encodeDiscriminator(D, DF, CI)) 2226 return cloneWithDiscriminator(*Encoded); 2227 return None; 2228} 2229 2230Optional<const DILocation *> DILocation::cloneByMultiplyingDuplicationFactor(unsigned DF) const { 2231 assert(!EnableFSDiscriminator && "FSDiscriminator should not call this."); 2232 2233 DF *= getDuplicationFactor(); 2234 if (DF <= 1) 2235 return this; 2236 2237 unsigned BD = getBaseDiscriminator(); 2238 unsigned CI = getCopyIdentifier(); 2239 if (Optional<unsigned> D = encodeDiscriminator(BD, DF, CI)) 2240 return cloneWithDiscriminator(*D); 2241 return None; 2242} 2243 2244class DINamespace : public DIScope { 2245 friend class LLVMContextImpl; 2246 friend class MDNode; 2247 2248 unsigned ExportSymbols : 1; 2249 2250 DINamespace(LLVMContext &Context, StorageType Storage, bool ExportSymbols, 2251 ArrayRef<Metadata *> Ops) 2252 : DIScope(Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace, 2253 Ops), 2254 ExportSymbols(ExportSymbols) {} 2255 ~DINamespace() = default; 2256 2257 static DINamespace *getImpl(LLVMContext &Context, DIScope *Scope, 2258 StringRef Name, bool ExportSymbols, 2259 StorageType Storage, bool ShouldCreate = true) { 2260 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), 2261 ExportSymbols, Storage, ShouldCreate); 2262 } 2263 static DINamespace *getImpl(LLVMContext &Context, Metadata *Scope, 2264 MDString *Name, bool ExportSymbols, 2265 StorageType Storage, bool ShouldCreate = true); 2266 2267 TempDINamespace cloneImpl() const { 2268 return getTemporary(getContext(), getScope(), getName(), 2269 getExportSymbols()); 2270 } 2271 2272public: 2273 DEFINE_MDNODE_GET(DINamespace, 2274 (DIScope *Scope, StringRef Name, bool ExportSymbols), 2275 (Scope, Name, ExportSymbols)) 2276 DEFINE_MDNODE_GET(DINamespace, 2277 (Metadata *Scope, MDString *Name, bool ExportSymbols), 2278 (Scope, Name, ExportSymbols)) 2279 2280 TempDINamespace clone() const { return cloneImpl(); } 2281 2282 bool getExportSymbols() const { return ExportSymbols; } 2283 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); } 2284 StringRef getName() const { return getStringOperand(2); } 2285 2286 Metadata *getRawScope() const { return getOperand(1); } 2287 MDString *getRawName() const { return getOperandAs<MDString>(2); } 2288 2289 static bool classof(const Metadata *MD) { 2290 return MD->getMetadataID() == DINamespaceKind; 2291 } 2292}; 2293 2294/// Represents a module in the programming language, for example, a Clang 2295/// module, or a Fortran module. 2296class DIModule : public DIScope { 2297 friend class LLVMContextImpl; 2298 friend class MDNode; 2299 unsigned LineNo; 2300 bool IsDecl; 2301 2302 DIModule(LLVMContext &Context, StorageType Storage, unsigned LineNo, 2303 bool IsDecl, ArrayRef<Metadata *> Ops) 2304 : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops), 2305 LineNo(LineNo), IsDecl(IsDecl) {} 2306 ~DIModule() = default; 2307 2308 static DIModule *getImpl(LLVMContext &Context, DIFile *File, DIScope *Scope, 2309 StringRef Name, StringRef ConfigurationMacros, 2310 StringRef IncludePath, StringRef APINotesFile, 2311 unsigned LineNo, bool IsDecl, StorageType Storage, 2312 bool ShouldCreate = true) { 2313 return getImpl(Context, File, Scope, getCanonicalMDString(Context, Name), 2314 getCanonicalMDString(Context, ConfigurationMacros), 2315 getCanonicalMDString(Context, IncludePath), 2316 getCanonicalMDString(Context, APINotesFile), LineNo, IsDecl, 2317 Storage, ShouldCreate); 2318 } 2319 static DIModule *getImpl(LLVMContext &Context, Metadata *File, 2320 Metadata *Scope, MDString *Name, 2321 MDString *ConfigurationMacros, MDString *IncludePath, 2322 MDString *APINotesFile, unsigned LineNo, bool IsDecl, 2323 StorageType Storage, bool ShouldCreate = true); 2324 2325 TempDIModule cloneImpl() const { 2326 return getTemporary(getContext(), getFile(), getScope(), getName(), 2327 getConfigurationMacros(), getIncludePath(), 2328 getAPINotesFile(), getLineNo(), getIsDecl()); 2329 } 2330 2331public: 2332 DEFINE_MDNODE_GET(DIModule, 2333 (DIFile * File, DIScope *Scope, StringRef Name, 2334 StringRef ConfigurationMacros, StringRef IncludePath, 2335 StringRef APINotesFile, unsigned LineNo, 2336 bool IsDecl = false), 2337 (File, Scope, Name, ConfigurationMacros, IncludePath, 2338 APINotesFile, LineNo, IsDecl)) 2339 DEFINE_MDNODE_GET(DIModule, 2340 (Metadata * File, Metadata *Scope, MDString *Name, 2341 MDString *ConfigurationMacros, MDString *IncludePath, 2342 MDString *APINotesFile, unsigned LineNo, 2343 bool IsDecl = false), 2344 (File, Scope, Name, ConfigurationMacros, IncludePath, 2345 APINotesFile, LineNo, IsDecl)) 2346 2347 TempDIModule clone() const { return cloneImpl(); } 2348 2349 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); } 2350 StringRef getName() const { return getStringOperand(2); } 2351 StringRef getConfigurationMacros() const { return getStringOperand(3); } 2352 StringRef getIncludePath() const { return getStringOperand(4); } 2353 StringRef getAPINotesFile() const { return getStringOperand(5); } 2354 unsigned getLineNo() const { return LineNo; } 2355 bool getIsDecl() const { return IsDecl; } 2356 2357 Metadata *getRawScope() const { return getOperand(1); } 2358 MDString *getRawName() const { return getOperandAs<MDString>(2); } 2359 MDString *getRawConfigurationMacros() const { 2360 return getOperandAs<MDString>(3); 2361 } 2362 MDString *getRawIncludePath() const { return getOperandAs<MDString>(4); } 2363 MDString *getRawAPINotesFile() const { return getOperandAs<MDString>(5); } 2364 2365 static bool classof(const Metadata *MD) { 2366 return MD->getMetadataID() == DIModuleKind; 2367 } 2368}; 2369 2370/// Base class for template parameters. 2371class DITemplateParameter : public DINode { 2372protected: 2373 bool IsDefault; 2374 2375 DITemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage, 2376 unsigned Tag, bool IsDefault, ArrayRef<Metadata *> Ops) 2377 : DINode(Context, ID, Storage, Tag, Ops), IsDefault(IsDefault) {} 2378 ~DITemplateParameter() = default; 2379 2380public: 2381 StringRef getName() const { return getStringOperand(0); } 2382 DIType *getType() const { return cast_or_null<DIType>(getRawType()); } 2383 2384 MDString *getRawName() const { return getOperandAs<MDString>(0); } 2385 Metadata *getRawType() const { return getOperand(1); } 2386 bool isDefault() const { return IsDefault; } 2387 2388 static bool classof(const Metadata *MD) { 2389 return MD->getMetadataID() == DITemplateTypeParameterKind || 2390 MD->getMetadataID() == DITemplateValueParameterKind; 2391 } 2392}; 2393 2394class DITemplateTypeParameter : public DITemplateParameter { 2395 friend class LLVMContextImpl; 2396 friend class MDNode; 2397 2398 DITemplateTypeParameter(LLVMContext &Context, StorageType Storage, 2399 bool IsDefault, ArrayRef<Metadata *> Ops) 2400 : DITemplateParameter(Context, DITemplateTypeParameterKind, Storage, 2401 dwarf::DW_TAG_template_type_parameter, IsDefault, 2402 Ops) {} 2403 ~DITemplateTypeParameter() = default; 2404 2405 static DITemplateTypeParameter *getImpl(LLVMContext &Context, StringRef Name, 2406 DIType *Type, bool IsDefault, 2407 StorageType Storage, 2408 bool ShouldCreate = true) { 2409 return getImpl(Context, getCanonicalMDString(Context, Name), Type, 2410 IsDefault, Storage, ShouldCreate); 2411 } 2412 static DITemplateTypeParameter *getImpl(LLVMContext &Context, MDString *Name, 2413 Metadata *Type, bool IsDefault, 2414 StorageType Storage, 2415 bool ShouldCreate = true); 2416 2417 TempDITemplateTypeParameter cloneImpl() const { 2418 return getTemporary(getContext(), getName(), getType(), isDefault()); 2419 } 2420 2421public: 2422 DEFINE_MDNODE_GET(DITemplateTypeParameter, 2423 (StringRef Name, DIType *Type, bool IsDefault), 2424 (Name, Type, IsDefault)) 2425 DEFINE_MDNODE_GET(DITemplateTypeParameter, 2426 (MDString *Name, Metadata *Type, bool IsDefault), 2427 (Name, Type, IsDefault)) 2428 2429 TempDITemplateTypeParameter clone() const { return cloneImpl(); } 2430 2431 static bool classof(const Metadata *MD) { 2432 return MD->getMetadataID() == DITemplateTypeParameterKind; 2433 } 2434}; 2435 2436class DITemplateValueParameter : public DITemplateParameter { 2437 friend class LLVMContextImpl; 2438 friend class MDNode; 2439 2440 DITemplateValueParameter(LLVMContext &Context, StorageType Storage, 2441 unsigned Tag, bool IsDefault, 2442 ArrayRef<Metadata *> Ops) 2443 : DITemplateParameter(Context, DITemplateValueParameterKind, Storage, Tag, 2444 IsDefault, Ops) {} 2445 ~DITemplateValueParameter() = default; 2446 2447 static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag, 2448 StringRef Name, DIType *Type, 2449 bool IsDefault, Metadata *Value, 2450 StorageType Storage, 2451 bool ShouldCreate = true) { 2452 return getImpl(Context, Tag, getCanonicalMDString(Context, Name), Type, 2453 IsDefault, Value, Storage, ShouldCreate); 2454 } 2455 static DITemplateValueParameter *getImpl(LLVMContext &Context, unsigned Tag, 2456 MDString *Name, Metadata *Type, 2457 bool IsDefault, Metadata *Value, 2458 StorageType Storage, 2459 bool ShouldCreate = true); 2460 2461 TempDITemplateValueParameter cloneImpl() const { 2462 return getTemporary(getContext(), getTag(), getName(), getType(), 2463 isDefault(), getValue()); 2464 } 2465 2466public: 2467 DEFINE_MDNODE_GET(DITemplateValueParameter, 2468 (unsigned Tag, StringRef Name, DIType *Type, bool IsDefault, 2469 Metadata *Value), 2470 (Tag, Name, Type, IsDefault, Value)) 2471 DEFINE_MDNODE_GET(DITemplateValueParameter, 2472 (unsigned Tag, MDString *Name, Metadata *Type, 2473 bool IsDefault, Metadata *Value), 2474 (Tag, Name, Type, IsDefault, Value)) 2475 2476 TempDITemplateValueParameter clone() const { return cloneImpl(); } 2477 2478 Metadata *getValue() const { return getOperand(2); } 2479 2480 static bool classof(const Metadata *MD) { 2481 return MD->getMetadataID() == DITemplateValueParameterKind; 2482 } 2483}; 2484 2485/// Base class for variables. 2486class DIVariable : public DINode { 2487 unsigned Line; 2488 uint32_t AlignInBits; 2489 2490protected: 2491 DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Line, 2492 ArrayRef<Metadata *> Ops, uint32_t AlignInBits = 0) 2493 : DINode(C, ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line), 2494 AlignInBits(AlignInBits) {} 2495 ~DIVariable() = default; 2496 2497public: 2498 unsigned getLine() const { return Line; } 2499 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); } 2500 StringRef getName() const { return getStringOperand(1); } 2501 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); } 2502 DIType *getType() const { return cast_or_null<DIType>(getRawType()); } 2503 uint32_t getAlignInBits() const { return AlignInBits; } 2504 uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT; } 2505 /// Determines the size of the variable's type. 2506 Optional<uint64_t> getSizeInBits() const; 2507 2508 /// Return the signedness of this variable's type, or None if this type is 2509 /// neither signed nor unsigned. 2510 Optional<DIBasicType::Signedness> getSignedness() const { 2511 if (auto *BT = dyn_cast<DIBasicType>(getType())) 2512 return BT->getSignedness(); 2513 return None; 2514 } 2515 2516 StringRef getFilename() const { 2517 if (auto *F = getFile()) 2518 return F->getFilename(); 2519 return ""; 2520 } 2521 2522 StringRef getDirectory() const { 2523 if (auto *F = getFile()) 2524 return F->getDirectory(); 2525 return ""; 2526 } 2527 2528 Optional<StringRef> getSource() const { 2529 if (auto *F = getFile()) 2530 return F->getSource(); 2531 return None; 2532 } 2533 2534 Metadata *getRawScope() const { return getOperand(0); } 2535 MDString *getRawName() const { return getOperandAs<MDString>(1); } 2536 Metadata *getRawFile() const { return getOperand(2); } 2537 Metadata *getRawType() const { return getOperand(3); } 2538 2539 static bool classof(const Metadata *MD) { 2540 return MD->getMetadataID() == DILocalVariableKind || 2541 MD->getMetadataID() == DIGlobalVariableKind; 2542 } 2543}; 2544 2545/// DWARF expression. 2546/// 2547/// This is (almost) a DWARF expression that modifies the location of a 2548/// variable, or the location of a single piece of a variable, or (when using 2549/// DW_OP_stack_value) is the constant variable value. 2550/// 2551/// TODO: Co-allocate the expression elements. 2552/// TODO: Separate from MDNode, or otherwise drop Distinct and Temporary 2553/// storage types. 2554class DIExpression : public MDNode { 2555 friend class LLVMContextImpl; 2556 friend class MDNode; 2557 2558 std::vector<uint64_t> Elements; 2559 2560 DIExpression(LLVMContext &C, StorageType Storage, ArrayRef<uint64_t> Elements) 2561 : MDNode(C, DIExpressionKind, Storage, None), 2562 Elements(Elements.begin(), Elements.end()) {} 2563 ~DIExpression() = default; 2564 2565 static DIExpression *getImpl(LLVMContext &Context, 2566 ArrayRef<uint64_t> Elements, StorageType Storage, 2567 bool ShouldCreate = true); 2568 2569 TempDIExpression cloneImpl() const { 2570 return getTemporary(getContext(), getElements()); 2571 } 2572 2573public: 2574 DEFINE_MDNODE_GET(DIExpression, (ArrayRef<uint64_t> Elements), (Elements)) 2575 2576 TempDIExpression clone() const { return cloneImpl(); } 2577 2578 ArrayRef<uint64_t> getElements() const { return Elements; } 2579 2580 unsigned getNumElements() const { return Elements.size(); } 2581 2582 uint64_t getElement(unsigned I) const { 2583 assert(I < Elements.size() && "Index out of range"); 2584 return Elements[I]; 2585 } 2586 2587 enum SignedOrUnsignedConstant { SignedConstant, UnsignedConstant }; 2588 /// Determine whether this represents a constant value, if so 2589 // return it's sign information. 2590 llvm::Optional<SignedOrUnsignedConstant> isConstant() const; 2591 2592 /// Return the number of unique location operands referred to (via 2593 /// DW_OP_LLVM_arg) in this expression; this is not necessarily the number of 2594 /// instances of DW_OP_LLVM_arg within the expression. 2595 /// For example, for the expression: 2596 /// (DW_OP_LLVM_arg 0, DW_OP_LLVM_arg 1, DW_OP_plus, 2597 /// DW_OP_LLVM_arg 0, DW_OP_mul) 2598 /// This function would return 2, as there are two unique location operands 2599 /// (0 and 1). 2600 uint64_t getNumLocationOperands() const; 2601 2602 using element_iterator = ArrayRef<uint64_t>::iterator; 2603 2604 element_iterator elements_begin() const { return getElements().begin(); } 2605 element_iterator elements_end() const { return getElements().end(); } 2606 2607 /// A lightweight wrapper around an expression operand. 2608 /// 2609 /// TODO: Store arguments directly and change \a DIExpression to store a 2610 /// range of these. 2611 class ExprOperand { 2612 const uint64_t *Op = nullptr; 2613 2614 public: 2615 ExprOperand() = default; 2616 explicit ExprOperand(const uint64_t *Op) : Op(Op) {} 2617 2618 const uint64_t *get() const { return Op; } 2619 2620 /// Get the operand code. 2621 uint64_t getOp() const { return *Op; } 2622 2623 /// Get an argument to the operand. 2624 /// 2625 /// Never returns the operand itself. 2626 uint64_t getArg(unsigned I) const { return Op[I + 1]; } 2627 2628 unsigned getNumArgs() const { return getSize() - 1; } 2629 2630 /// Return the size of the operand. 2631 /// 2632 /// Return the number of elements in the operand (1 + args). 2633 unsigned getSize() const; 2634 2635 /// Append the elements of this operand to \p V. 2636 void appendToVector(SmallVectorImpl<uint64_t> &V) const { 2637 V.append(get(), get() + getSize()); 2638 } 2639 }; 2640 2641 /// An iterator for expression operands. 2642 class expr_op_iterator { 2643 ExprOperand Op; 2644 2645 public: 2646 using iterator_category = std::input_iterator_tag; 2647 using value_type = ExprOperand; 2648 using difference_type = std::ptrdiff_t; 2649 using pointer = value_type *; 2650 using reference = value_type &; 2651 2652 expr_op_iterator() = default; 2653 explicit expr_op_iterator(element_iterator I) : Op(I) {} 2654 2655 element_iterator getBase() const { return Op.get(); } 2656 const ExprOperand &operator*() const { return Op; } 2657 const ExprOperand *operator->() const { return &Op; } 2658 2659 expr_op_iterator &operator++() { 2660 increment(); 2661 return *this; 2662 } 2663 expr_op_iterator operator++(int) { 2664 expr_op_iterator T(*this); 2665 increment(); 2666 return T; 2667 } 2668 2669 /// Get the next iterator. 2670 /// 2671 /// \a std::next() doesn't work because this is technically an 2672 /// input_iterator, but it's a perfectly valid operation. This is an 2673 /// accessor to provide the same functionality. 2674 expr_op_iterator getNext() const { return ++expr_op_iterator(*this); } 2675 2676 bool operator==(const expr_op_iterator &X) const { 2677 return getBase() == X.getBase(); 2678 } 2679 bool operator!=(const expr_op_iterator &X) const { 2680 return getBase() != X.getBase(); 2681 } 2682 2683 private: 2684 void increment() { Op = ExprOperand(getBase() + Op.getSize()); } 2685 }; 2686 2687 /// Visit the elements via ExprOperand wrappers. 2688 /// 2689 /// These range iterators visit elements through \a ExprOperand wrappers. 2690 /// This is not guaranteed to be a valid range unless \a isValid() gives \c 2691 /// true. 2692 /// 2693 /// \pre \a isValid() gives \c true. 2694 /// @{ 2695 expr_op_iterator expr_op_begin() const { 2696 return expr_op_iterator(elements_begin()); 2697 } 2698 expr_op_iterator expr_op_end() const { 2699 return expr_op_iterator(elements_end()); 2700 } 2701 iterator_range<expr_op_iterator> expr_ops() const { 2702 return {expr_op_begin(), expr_op_end()}; 2703 } 2704 /// @} 2705 2706 bool isValid() const; 2707 2708 static bool classof(const Metadata *MD) { 2709 return MD->getMetadataID() == DIExpressionKind; 2710 } 2711 2712 /// Return whether the first element a DW_OP_deref. 2713 bool startsWithDeref() const { 2714 return getNumElements() > 0 && getElement(0) == dwarf::DW_OP_deref; 2715 } 2716 2717 /// Holds the characteristics of one fragment of a larger variable. 2718 struct FragmentInfo { 2719 uint64_t SizeInBits; 2720 uint64_t OffsetInBits; 2721 }; 2722 2723 /// Retrieve the details of this fragment expression. 2724 static Optional<FragmentInfo> getFragmentInfo(expr_op_iterator Start, 2725 expr_op_iterator End); 2726 2727 /// Retrieve the details of this fragment expression. 2728 Optional<FragmentInfo> getFragmentInfo() const { 2729 return getFragmentInfo(expr_op_begin(), expr_op_end()); 2730 } 2731 2732 /// Return whether this is a piece of an aggregate variable. 2733 bool isFragment() const { return getFragmentInfo().hasValue(); } 2734 2735 /// Return whether this is an implicit location description. 2736 bool isImplicit() const; 2737 2738 /// Return whether the location is computed on the expression stack, meaning 2739 /// it cannot be a simple register location. 2740 bool isComplex() const; 2741 2742 /// Append \p Ops with operations to apply the \p Offset. 2743 static void appendOffset(SmallVectorImpl<uint64_t> &Ops, int64_t Offset); 2744 2745 /// If this is a constant offset, extract it. If there is no expression, 2746 /// return true with an offset of zero. 2747 bool extractIfOffset(int64_t &Offset) const; 2748 2749 /// Returns true iff this DIExpression contains at least one instance of 2750 /// `DW_OP_LLVM_arg, n` for all n in [0, N). 2751 bool hasAllLocationOps(unsigned N) const; 2752 2753 /// Checks if the last 4 elements of the expression are DW_OP_constu <DWARF 2754 /// Address Space> DW_OP_swap DW_OP_xderef and extracts the <DWARF Address 2755 /// Space>. 2756 static const DIExpression *extractAddressClass(const DIExpression *Expr, 2757 unsigned &AddrClass); 2758 2759 /// Used for DIExpression::prepend. 2760 enum PrependOps : uint8_t { 2761 ApplyOffset = 0, 2762 DerefBefore = 1 << 0, 2763 DerefAfter = 1 << 1, 2764 StackValue = 1 << 2, 2765 EntryValue = 1 << 3 2766 }; 2767 2768 /// Prepend \p DIExpr with a deref and offset operation and optionally turn it 2769 /// into a stack value or/and an entry value. 2770 static DIExpression *prepend(const DIExpression *Expr, uint8_t Flags, 2771 int64_t Offset = 0); 2772 2773 /// Prepend \p DIExpr with the given opcodes and optionally turn it into a 2774 /// stack value. 2775 static DIExpression *prependOpcodes(const DIExpression *Expr, 2776 SmallVectorImpl<uint64_t> &Ops, 2777 bool StackValue = false, 2778 bool EntryValue = false); 2779 2780 /// Append the opcodes \p Ops to \p DIExpr. Unlike \ref appendToStack, the 2781 /// returned expression is a stack value only if \p DIExpr is a stack value. 2782 /// If \p DIExpr describes a fragment, the returned expression will describe 2783 /// the same fragment. 2784 static DIExpression *append(const DIExpression *Expr, ArrayRef<uint64_t> Ops); 2785 2786 /// Convert \p DIExpr into a stack value if it isn't one already by appending 2787 /// DW_OP_deref if needed, and appending \p Ops to the resulting expression. 2788 /// If \p DIExpr describes a fragment, the returned expression will describe 2789 /// the same fragment. 2790 static DIExpression *appendToStack(const DIExpression *Expr, 2791 ArrayRef<uint64_t> Ops); 2792 2793 /// Create a copy of \p Expr by appending the given list of \p Ops to each 2794 /// instance of the operand `DW_OP_LLVM_arg, \p ArgNo`. This is used to 2795 /// modify a specific location used by \p Expr, such as when salvaging that 2796 /// location. 2797 static DIExpression *appendOpsToArg(const DIExpression *Expr, 2798 ArrayRef<uint64_t> Ops, unsigned ArgNo, 2799 bool StackValue = false); 2800 2801 /// Create a copy of \p Expr with each instance of 2802 /// `DW_OP_LLVM_arg, \p OldArg` replaced with `DW_OP_LLVM_arg, \p NewArg`, 2803 /// and each instance of `DW_OP_LLVM_arg, Arg` with `DW_OP_LLVM_arg, Arg - 1` 2804 /// for all Arg > \p OldArg. 2805 /// This is used when replacing one of the operands of a debug value list 2806 /// with another operand in the same list and deleting the old operand. 2807 static DIExpression *replaceArg(const DIExpression *Expr, uint64_t OldArg, 2808 uint64_t NewArg); 2809 2810 /// Create a DIExpression to describe one part of an aggregate variable that 2811 /// is fragmented across multiple Values. The DW_OP_LLVM_fragment operation 2812 /// will be appended to the elements of \c Expr. If \c Expr already contains 2813 /// a \c DW_OP_LLVM_fragment \c OffsetInBits is interpreted as an offset 2814 /// into the existing fragment. 2815 /// 2816 /// \param OffsetInBits Offset of the piece in bits. 2817 /// \param SizeInBits Size of the piece in bits. 2818 /// \return Creating a fragment expression may fail if \c Expr 2819 /// contains arithmetic operations that would be truncated. 2820 static Optional<DIExpression *> 2821 createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits, 2822 unsigned SizeInBits); 2823 2824 /// Determine the relative position of the fragments passed in. 2825 /// Returns -1 if this is entirely before Other, 0 if this and Other overlap, 2826 /// 1 if this is entirely after Other. 2827 static int fragmentCmp(const FragmentInfo &A, const FragmentInfo &B) { 2828 uint64_t l1 = A.OffsetInBits; 2829 uint64_t l2 = B.OffsetInBits; 2830 uint64_t r1 = l1 + A.SizeInBits; 2831 uint64_t r2 = l2 + B.SizeInBits; 2832 if (r1 <= l2) 2833 return -1; 2834 else if (r2 <= l1) 2835 return 1; 2836 else 2837 return 0; 2838 } 2839 2840 using ExtOps = std::array<uint64_t, 6>; 2841 2842 /// Returns the ops for a zero- or sign-extension in a DIExpression. 2843 static ExtOps getExtOps(unsigned FromSize, unsigned ToSize, bool Signed); 2844 2845 /// Append a zero- or sign-extension to \p Expr. Converts the expression to a 2846 /// stack value if it isn't one already. 2847 static DIExpression *appendExt(const DIExpression *Expr, unsigned FromSize, 2848 unsigned ToSize, bool Signed); 2849 2850 /// Check if fragments overlap between a pair of FragmentInfos. 2851 static bool fragmentsOverlap(const FragmentInfo &A, const FragmentInfo &B) { 2852 return fragmentCmp(A, B) == 0; 2853 } 2854 2855 /// Determine the relative position of the fragments described by this 2856 /// DIExpression and \p Other. Calls static fragmentCmp implementation. 2857 int fragmentCmp(const DIExpression *Other) const { 2858 auto Fragment1 = *getFragmentInfo(); 2859 auto Fragment2 = *Other->getFragmentInfo(); 2860 return fragmentCmp(Fragment1, Fragment2); 2861 } 2862 2863 /// Check if fragments overlap between this DIExpression and \p Other. 2864 bool fragmentsOverlap(const DIExpression *Other) const { 2865 if (!isFragment() || !Other->isFragment()) 2866 return true; 2867 return fragmentCmp(Other) == 0; 2868 } 2869 2870 /// Check if the expression consists of exactly one entry value operand. 2871 /// (This is the only configuration of entry values that is supported.) 2872 bool isEntryValue() const { 2873 return getNumElements() > 0 && 2874 getElement(0) == dwarf::DW_OP_LLVM_entry_value; 2875 } 2876}; 2877 2878inline bool operator==(const DIExpression::FragmentInfo &A, 2879 const DIExpression::FragmentInfo &B) { 2880 return std::tie(A.SizeInBits, A.OffsetInBits) == 2881 std::tie(B.SizeInBits, B.OffsetInBits); 2882} 2883 2884inline bool operator<(const DIExpression::FragmentInfo &A, 2885 const DIExpression::FragmentInfo &B) { 2886 return std::tie(A.SizeInBits, A.OffsetInBits) < 2887 std::tie(B.SizeInBits, B.OffsetInBits); 2888} 2889 2890template <> struct DenseMapInfo<DIExpression::FragmentInfo> { 2891 using FragInfo = DIExpression::FragmentInfo; 2892 static const uint64_t MaxVal = std::numeric_limits<uint64_t>::max(); 2893 2894 static inline FragInfo getEmptyKey() { return {MaxVal, MaxVal}; } 2895 2896 static inline FragInfo getTombstoneKey() { return {MaxVal - 1, MaxVal - 1}; } 2897 2898 static unsigned getHashValue(const FragInfo &Frag) { 2899 return (Frag.SizeInBits & 0xffff) << 16 | (Frag.OffsetInBits & 0xffff); 2900 } 2901 2902 static bool isEqual(const FragInfo &A, const FragInfo &B) { return A == B; } 2903}; 2904 2905/// Global variables. 2906/// 2907/// TODO: Remove DisplayName. It's always equal to Name. 2908class DIGlobalVariable : public DIVariable { 2909 friend class LLVMContextImpl; 2910 friend class MDNode; 2911 2912 bool IsLocalToUnit; 2913 bool IsDefinition; 2914 2915 DIGlobalVariable(LLVMContext &C, StorageType Storage, unsigned Line, 2916 bool IsLocalToUnit, bool IsDefinition, uint32_t AlignInBits, 2917 ArrayRef<Metadata *> Ops) 2918 : DIVariable(C, DIGlobalVariableKind, Storage, Line, Ops, AlignInBits), 2919 IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition) {} 2920 ~DIGlobalVariable() = default; 2921 2922 static DIGlobalVariable * 2923 getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name, 2924 StringRef LinkageName, DIFile *File, unsigned Line, DIType *Type, 2925 bool IsLocalToUnit, bool IsDefinition, 2926 DIDerivedType *StaticDataMemberDeclaration, MDTuple *TemplateParams, 2927 uint32_t AlignInBits, StorageType Storage, bool ShouldCreate = true) { 2928 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), 2929 getCanonicalMDString(Context, LinkageName), File, Line, Type, 2930 IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration, 2931 cast_or_null<Metadata>(TemplateParams), AlignInBits, Storage, 2932 ShouldCreate); 2933 } 2934 static DIGlobalVariable * 2935 getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name, 2936 MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, 2937 bool IsLocalToUnit, bool IsDefinition, 2938 Metadata *StaticDataMemberDeclaration, Metadata *TemplateParams, 2939 uint32_t AlignInBits, StorageType Storage, bool ShouldCreate = true); 2940 2941 TempDIGlobalVariable cloneImpl() const { 2942 return getTemporary(getContext(), getScope(), getName(), getLinkageName(), 2943 getFile(), getLine(), getType(), isLocalToUnit(), 2944 isDefinition(), getStaticDataMemberDeclaration(), 2945 getTemplateParams(), getAlignInBits()); 2946 } 2947 2948public: 2949 DEFINE_MDNODE_GET(DIGlobalVariable, 2950 (DIScope * Scope, StringRef Name, StringRef LinkageName, 2951 DIFile *File, unsigned Line, DIType *Type, 2952 bool IsLocalToUnit, bool IsDefinition, 2953 DIDerivedType *StaticDataMemberDeclaration, 2954 MDTuple *TemplateParams, uint32_t AlignInBits), 2955 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, 2956 IsDefinition, StaticDataMemberDeclaration, TemplateParams, 2957 AlignInBits)) 2958 DEFINE_MDNODE_GET(DIGlobalVariable, 2959 (Metadata * Scope, MDString *Name, MDString *LinkageName, 2960 Metadata *File, unsigned Line, Metadata *Type, 2961 bool IsLocalToUnit, bool IsDefinition, 2962 Metadata *StaticDataMemberDeclaration, 2963 Metadata *TemplateParams, uint32_t AlignInBits), 2964 (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit, 2965 IsDefinition, StaticDataMemberDeclaration, TemplateParams, 2966 AlignInBits)) 2967 2968 TempDIGlobalVariable clone() const { return cloneImpl(); } 2969 2970 bool isLocalToUnit() const { return IsLocalToUnit; } 2971 bool isDefinition() const { return IsDefinition; } 2972 StringRef getDisplayName() const { return getStringOperand(4); } 2973 StringRef getLinkageName() const { return getStringOperand(5); } 2974 DIDerivedType *getStaticDataMemberDeclaration() const { 2975 return cast_or_null<DIDerivedType>(getRawStaticDataMemberDeclaration()); 2976 } 2977 2978 MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); } 2979 Metadata *getRawStaticDataMemberDeclaration() const { return getOperand(6); } 2980 Metadata *getRawTemplateParams() const { return getOperand(7); } 2981 MDTuple *getTemplateParams() const { return getOperandAs<MDTuple>(7); } 2982 2983 static bool classof(const Metadata *MD) { 2984 return MD->getMetadataID() == DIGlobalVariableKind; 2985 } 2986}; 2987 2988class DICommonBlock : public DIScope { 2989 unsigned LineNo; 2990 2991 friend class LLVMContextImpl; 2992 friend class MDNode; 2993 2994 DICommonBlock(LLVMContext &Context, StorageType Storage, unsigned LineNo, 2995 ArrayRef<Metadata *> Ops) 2996 : DIScope(Context, DICommonBlockKind, Storage, dwarf::DW_TAG_common_block, 2997 Ops), LineNo(LineNo) {} 2998 2999 static DICommonBlock *getImpl(LLVMContext &Context, DIScope *Scope, 3000 DIGlobalVariable *Decl, StringRef Name, 3001 DIFile *File, unsigned LineNo, 3002 StorageType Storage, 3003 bool ShouldCreate = true) { 3004 return getImpl(Context, Scope, Decl, getCanonicalMDString(Context, Name), 3005 File, LineNo, Storage, ShouldCreate); 3006 } 3007 static DICommonBlock *getImpl(LLVMContext &Context, Metadata *Scope, 3008 Metadata *Decl, MDString *Name, Metadata *File, 3009 unsigned LineNo, 3010 StorageType Storage, bool ShouldCreate = true); 3011 3012 TempDICommonBlock cloneImpl() const { 3013 return getTemporary(getContext(), getScope(), getDecl(), getName(), 3014 getFile(), getLineNo()); 3015 } 3016 3017public: 3018 DEFINE_MDNODE_GET(DICommonBlock, 3019 (DIScope *Scope, DIGlobalVariable *Decl, StringRef Name, 3020 DIFile *File, unsigned LineNo), 3021 (Scope, Decl, Name, File, LineNo)) 3022 DEFINE_MDNODE_GET(DICommonBlock, 3023 (Metadata *Scope, Metadata *Decl, MDString *Name, 3024 Metadata *File, unsigned LineNo), 3025 (Scope, Decl, Name, File, LineNo)) 3026 3027 TempDICommonBlock clone() const { return cloneImpl(); } 3028 3029 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); } 3030 DIGlobalVariable *getDecl() const { 3031 return cast_or_null<DIGlobalVariable>(getRawDecl()); 3032 } 3033 StringRef getName() const { return getStringOperand(2); } 3034 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); } 3035 unsigned getLineNo() const { return LineNo; } 3036 3037 Metadata *getRawScope() const { return getOperand(0); } 3038 Metadata *getRawDecl() const { return getOperand(1); } 3039 MDString *getRawName() const { return getOperandAs<MDString>(2); } 3040 Metadata *getRawFile() const { return getOperand(3); } 3041 3042 static bool classof(const Metadata *MD) { 3043 return MD->getMetadataID() == DICommonBlockKind; 3044 } 3045}; 3046 3047/// Local variable. 3048/// 3049/// TODO: Split up flags. 3050class DILocalVariable : public DIVariable { 3051 friend class LLVMContextImpl; 3052 friend class MDNode; 3053 3054 unsigned Arg : 16; 3055 DIFlags Flags; 3056 3057 DILocalVariable(LLVMContext &C, StorageType Storage, unsigned Line, 3058 unsigned Arg, DIFlags Flags, uint32_t AlignInBits, 3059 ArrayRef<Metadata *> Ops) 3060 : DIVariable(C, DILocalVariableKind, Storage, Line, Ops, AlignInBits), 3061 Arg(Arg), Flags(Flags) { 3062 assert(Arg < (1 << 16) && "DILocalVariable: Arg out of range"); 3063 } 3064 ~DILocalVariable() = default; 3065 3066 static DILocalVariable *getImpl(LLVMContext &Context, DIScope *Scope, 3067 StringRef Name, DIFile *File, unsigned Line, 3068 DIType *Type, unsigned Arg, DIFlags Flags, 3069 uint32_t AlignInBits, StorageType Storage, 3070 bool ShouldCreate = true) { 3071 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File, 3072 Line, Type, Arg, Flags, AlignInBits, Storage, ShouldCreate); 3073 } 3074 static DILocalVariable *getImpl(LLVMContext &Context, Metadata *Scope, 3075 MDString *Name, Metadata *File, unsigned Line, 3076 Metadata *Type, unsigned Arg, DIFlags Flags, 3077 uint32_t AlignInBits, StorageType Storage, 3078 bool ShouldCreate = true); 3079 3080 TempDILocalVariable cloneImpl() const { 3081 return getTemporary(getContext(), getScope(), getName(), getFile(), 3082 getLine(), getType(), getArg(), getFlags(), 3083 getAlignInBits()); 3084 } 3085 3086public: 3087 DEFINE_MDNODE_GET(DILocalVariable, 3088 (DILocalScope * Scope, StringRef Name, DIFile *File, 3089 unsigned Line, DIType *Type, unsigned Arg, DIFlags Flags, 3090 uint32_t AlignInBits), 3091 (Scope, Name, File, Line, Type, Arg, Flags, AlignInBits)) 3092 DEFINE_MDNODE_GET(DILocalVariable, 3093 (Metadata * Scope, MDString *Name, Metadata *File, 3094 unsigned Line, Metadata *Type, unsigned Arg, 3095 DIFlags Flags, uint32_t AlignInBits), 3096 (Scope, Name, File, Line, Type, Arg, Flags, AlignInBits)) 3097 3098 TempDILocalVariable clone() const { return cloneImpl(); } 3099 3100 /// Get the local scope for this variable. 3101 /// 3102 /// Variables must be defined in a local scope. 3103 DILocalScope *getScope() const { 3104 return cast<DILocalScope>(DIVariable::getScope()); 3105 } 3106 3107 bool isParameter() const { return Arg; } 3108 unsigned getArg() const { return Arg; } 3109 DIFlags getFlags() const { return Flags; } 3110 3111 bool isArtificial() const { return getFlags() & FlagArtificial; } 3112 bool isObjectPointer() const { return getFlags() & FlagObjectPointer; } 3113 3114 /// Check that a location is valid for this variable. 3115 /// 3116 /// Check that \c DL exists, is in the same subprogram, and has the same 3117 /// inlined-at location as \c this. (Otherwise, it's not a valid attachment 3118 /// to a \a DbgInfoIntrinsic.) 3119 bool isValidLocationForIntrinsic(const DILocation *DL) const { 3120 return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram(); 3121 } 3122 3123 static bool classof(const Metadata *MD) { 3124 return MD->getMetadataID() == DILocalVariableKind; 3125 } 3126}; 3127 3128/// Label. 3129/// 3130class DILabel : public DINode { 3131 friend class LLVMContextImpl; 3132 friend class MDNode; 3133 3134 unsigned Line; 3135 3136 DILabel(LLVMContext &C, StorageType Storage, unsigned Line, 3137 ArrayRef<Metadata *> Ops) 3138 : DINode(C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops), Line(Line) {} 3139 ~DILabel() = default; 3140 3141 static DILabel *getImpl(LLVMContext &Context, DIScope *Scope, 3142 StringRef Name, DIFile *File, unsigned Line, 3143 StorageType Storage, 3144 bool ShouldCreate = true) { 3145 return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File, 3146 Line, Storage, ShouldCreate); 3147 } 3148 static DILabel *getImpl(LLVMContext &Context, Metadata *Scope, 3149 MDString *Name, Metadata *File, unsigned Line, 3150 StorageType Storage, 3151 bool ShouldCreate = true); 3152 3153 TempDILabel cloneImpl() const { 3154 return getTemporary(getContext(), getScope(), getName(), getFile(), 3155 getLine()); 3156 } 3157 3158public: 3159 DEFINE_MDNODE_GET(DILabel, 3160 (DILocalScope * Scope, StringRef Name, DIFile *File, 3161 unsigned Line), 3162 (Scope, Name, File, Line)) 3163 DEFINE_MDNODE_GET(DILabel, 3164 (Metadata * Scope, MDString *Name, Metadata *File, 3165 unsigned Line), 3166 (Scope, Name, File, Line)) 3167 3168 TempDILabel clone() const { return cloneImpl(); } 3169 3170 /// Get the local scope for this label. 3171 /// 3172 /// Labels must be defined in a local scope. 3173 DILocalScope *getScope() const { 3174 return cast_or_null<DILocalScope>(getRawScope()); 3175 } 3176 unsigned getLine() const { return Line; } 3177 StringRef getName() const { return getStringOperand(1); } 3178 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); } 3179 3180 Metadata *getRawScope() const { return getOperand(0); } 3181 MDString *getRawName() const { return getOperandAs<MDString>(1); } 3182 Metadata *getRawFile() const { return getOperand(2); } 3183 3184 /// Check that a location is valid for this label. 3185 /// 3186 /// Check that \c DL exists, is in the same subprogram, and has the same 3187 /// inlined-at location as \c this. (Otherwise, it's not a valid attachment 3188 /// to a \a DbgInfoIntrinsic.) 3189 bool isValidLocationForIntrinsic(const DILocation *DL) const { 3190 return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram(); 3191 } 3192 3193 static bool classof(const Metadata *MD) { 3194 return MD->getMetadataID() == DILabelKind; 3195 } 3196}; 3197 3198class DIObjCProperty : public DINode { 3199 friend class LLVMContextImpl; 3200 friend class MDNode; 3201 3202 unsigned Line; 3203 unsigned Attributes; 3204 3205 DIObjCProperty(LLVMContext &C, StorageType Storage, unsigned Line, 3206 unsigned Attributes, ArrayRef<Metadata *> Ops) 3207 : DINode(C, DIObjCPropertyKind, Storage, dwarf::DW_TAG_APPLE_property, 3208 Ops), 3209 Line(Line), Attributes(Attributes) {} 3210 ~DIObjCProperty() = default; 3211 3212 static DIObjCProperty * 3213 getImpl(LLVMContext &Context, StringRef Name, DIFile *File, unsigned Line, 3214 StringRef GetterName, StringRef SetterName, unsigned Attributes, 3215 DIType *Type, StorageType Storage, bool ShouldCreate = true) { 3216 return getImpl(Context, getCanonicalMDString(Context, Name), File, Line, 3217 getCanonicalMDString(Context, GetterName), 3218 getCanonicalMDString(Context, SetterName), Attributes, Type, 3219 Storage, ShouldCreate); 3220 } 3221 static DIObjCProperty *getImpl(LLVMContext &Context, MDString *Name, 3222 Metadata *File, unsigned Line, 3223 MDString *GetterName, MDString *SetterName, 3224 unsigned Attributes, Metadata *Type, 3225 StorageType Storage, bool ShouldCreate = true); 3226 3227 TempDIObjCProperty cloneImpl() const { 3228 return getTemporary(getContext(), getName(), getFile(), getLine(), 3229 getGetterName(), getSetterName(), getAttributes(), 3230 getType()); 3231 } 3232 3233public: 3234 DEFINE_MDNODE_GET(DIObjCProperty, 3235 (StringRef Name, DIFile *File, unsigned Line, 3236 StringRef GetterName, StringRef SetterName, 3237 unsigned Attributes, DIType *Type), 3238 (Name, File, Line, GetterName, SetterName, Attributes, 3239 Type)) 3240 DEFINE_MDNODE_GET(DIObjCProperty, 3241 (MDString * Name, Metadata *File, unsigned Line, 3242 MDString *GetterName, MDString *SetterName, 3243 unsigned Attributes, Metadata *Type), 3244 (Name, File, Line, GetterName, SetterName, Attributes, 3245 Type)) 3246 3247 TempDIObjCProperty clone() const { return cloneImpl(); } 3248 3249 unsigned getLine() const { return Line; } 3250 unsigned getAttributes() const { return Attributes; } 3251 StringRef getName() const { return getStringOperand(0); } 3252 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); } 3253 StringRef getGetterName() const { return getStringOperand(2); } 3254 StringRef getSetterName() const { return getStringOperand(3); } 3255 DIType *getType() const { return cast_or_null<DIType>(getRawType()); } 3256 3257 StringRef getFilename() const { 3258 if (auto *F = getFile()) 3259 return F->getFilename(); 3260 return ""; 3261 } 3262 3263 StringRef getDirectory() const { 3264 if (auto *F = getFile()) 3265 return F->getDirectory(); 3266 return ""; 3267 } 3268 3269 MDString *getRawName() const { return getOperandAs<MDString>(0); } 3270 Metadata *getRawFile() const { return getOperand(1); } 3271 MDString *getRawGetterName() const { return getOperandAs<MDString>(2); } 3272 MDString *getRawSetterName() const { return getOperandAs<MDString>(3); } 3273 Metadata *getRawType() const { return getOperand(4); } 3274 3275 static bool classof(const Metadata *MD) { 3276 return MD->getMetadataID() == DIObjCPropertyKind; 3277 } 3278}; 3279 3280/// An imported module (C++ using directive or similar). 3281class DIImportedEntity : public DINode { 3282 friend class LLVMContextImpl; 3283 friend class MDNode; 3284 3285 unsigned Line; 3286 3287 DIImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag, 3288 unsigned Line, ArrayRef<Metadata *> Ops) 3289 : DINode(C, DIImportedEntityKind, Storage, Tag, Ops), Line(Line) {} 3290 ~DIImportedEntity() = default; 3291 3292 static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag, 3293 DIScope *Scope, DINode *Entity, DIFile *File, 3294 unsigned Line, StringRef Name, 3295 StorageType Storage, 3296 bool ShouldCreate = true) { 3297 return getImpl(Context, Tag, Scope, Entity, File, Line, 3298 getCanonicalMDString(Context, Name), Storage, ShouldCreate); 3299 } 3300 static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag, 3301 Metadata *Scope, Metadata *Entity, 3302 Metadata *File, unsigned Line, 3303 MDString *Name, StorageType Storage, 3304 bool ShouldCreate = true); 3305 3306 TempDIImportedEntity cloneImpl() const { 3307 return getTemporary(getContext(), getTag(), getScope(), getEntity(), 3308 getFile(), getLine(), getName()); 3309 } 3310 3311public: 3312 DEFINE_MDNODE_GET(DIImportedEntity, 3313 (unsigned Tag, DIScope *Scope, DINode *Entity, DIFile *File, 3314 unsigned Line, StringRef Name = ""), 3315 (Tag, Scope, Entity, File, Line, Name)) 3316 DEFINE_MDNODE_GET(DIImportedEntity, 3317 (unsigned Tag, Metadata *Scope, Metadata *Entity, 3318 Metadata *File, unsigned Line, MDString *Name), 3319 (Tag, Scope, Entity, File, Line, Name)) 3320 3321 TempDIImportedEntity clone() const { return cloneImpl(); } 3322 3323 unsigned getLine() const { return Line; } 3324 DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); } 3325 DINode *getEntity() const { return cast_or_null<DINode>(getRawEntity()); } 3326 StringRef getName() const { return getStringOperand(2); } 3327 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); } 3328 3329 Metadata *getRawScope() const { return getOperand(0); } 3330 Metadata *getRawEntity() const { return getOperand(1); } 3331 MDString *getRawName() const { return getOperandAs<MDString>(2); } 3332 Metadata *getRawFile() const { return getOperand(3); } 3333 3334 static bool classof(const Metadata *MD) { 3335 return MD->getMetadataID() == DIImportedEntityKind; 3336 } 3337}; 3338 3339/// A pair of DIGlobalVariable and DIExpression. 3340class DIGlobalVariableExpression : public MDNode { 3341 friend class LLVMContextImpl; 3342 friend class MDNode; 3343 3344 DIGlobalVariableExpression(LLVMContext &C, StorageType Storage, 3345 ArrayRef<Metadata *> Ops) 3346 : MDNode(C, DIGlobalVariableExpressionKind, Storage, Ops) {} 3347 ~DIGlobalVariableExpression() = default; 3348 3349 static DIGlobalVariableExpression * 3350 getImpl(LLVMContext &Context, Metadata *Variable, Metadata *Expression, 3351 StorageType Storage, bool ShouldCreate = true); 3352 3353 TempDIGlobalVariableExpression cloneImpl() const { 3354 return getTemporary(getContext(), getVariable(), getExpression()); 3355 } 3356 3357public: 3358 DEFINE_MDNODE_GET(DIGlobalVariableExpression, 3359 (Metadata * Variable, Metadata *Expression), 3360 (Variable, Expression)) 3361 3362 TempDIGlobalVariableExpression clone() const { return cloneImpl(); } 3363 3364 Metadata *getRawVariable() const { return getOperand(0); } 3365 3366 DIGlobalVariable *getVariable() const { 3367 return cast_or_null<DIGlobalVariable>(getRawVariable()); 3368 } 3369 3370 Metadata *getRawExpression() const { return getOperand(1); } 3371 3372 DIExpression *getExpression() const { 3373 return cast<DIExpression>(getRawExpression()); 3374 } 3375 3376 static bool classof(const Metadata *MD) { 3377 return MD->getMetadataID() == DIGlobalVariableExpressionKind; 3378 } 3379}; 3380 3381/// Macro Info DWARF-like metadata node. 3382/// 3383/// A metadata node with a DWARF macro info (i.e., a constant named 3384/// \c DW_MACINFO_*, defined in llvm/BinaryFormat/Dwarf.h). Called \a 3385/// DIMacroNode 3386/// because it's potentially used for non-DWARF output. 3387class DIMacroNode : public MDNode { 3388 friend class LLVMContextImpl; 3389 friend class MDNode; 3390 3391protected: 3392 DIMacroNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned MIType, 3393 ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None) 3394 : MDNode(C, ID, Storage, Ops1, Ops2) { 3395 assert(MIType < 1u << 16); 3396 SubclassData16 = MIType; 3397 } 3398 ~DIMacroNode() = default; 3399 3400 template <class Ty> Ty *getOperandAs(unsigned I) const { 3401 return cast_or_null<Ty>(getOperand(I)); 3402 } 3403 3404 StringRef getStringOperand(unsigned I) const { 3405 if (auto *S = getOperandAs<MDString>(I)) 3406 return S->getString(); 3407 return StringRef(); 3408 } 3409 3410 static MDString *getCanonicalMDString(LLVMContext &Context, StringRef S) { 3411 if (S.empty()) 3412 return nullptr; 3413 return MDString::get(Context, S); 3414 } 3415 3416public: 3417 unsigned getMacinfoType() const { return SubclassData16; } 3418 3419 static bool classof(const Metadata *MD) { 3420 switch (MD->getMetadataID()) { 3421 default: 3422 return false; 3423 case DIMacroKind: 3424 case DIMacroFileKind: 3425 return true; 3426 } 3427 } 3428}; 3429 3430class DIMacro : public DIMacroNode { 3431 friend class LLVMContextImpl; 3432 friend class MDNode; 3433 3434 unsigned Line; 3435 3436 DIMacro(LLVMContext &C, StorageType Storage, unsigned MIType, unsigned Line, 3437 ArrayRef<Metadata *> Ops) 3438 : DIMacroNode(C, DIMacroKind, Storage, MIType, Ops), Line(Line) {} 3439 ~DIMacro() = default; 3440 3441 static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line, 3442 StringRef Name, StringRef Value, StorageType Storage, 3443 bool ShouldCreate = true) { 3444 return getImpl(Context, MIType, Line, getCanonicalMDString(Context, Name), 3445 getCanonicalMDString(Context, Value), Storage, ShouldCreate); 3446 } 3447 static DIMacro *getImpl(LLVMContext &Context, unsigned MIType, unsigned Line, 3448 MDString *Name, MDString *Value, StorageType Storage, 3449 bool ShouldCreate = true); 3450 3451 TempDIMacro cloneImpl() const { 3452 return getTemporary(getContext(), getMacinfoType(), getLine(), getName(), 3453 getValue()); 3454 } 3455 3456public: 3457 DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, StringRef Name, 3458 StringRef Value = ""), 3459 (MIType, Line, Name, Value)) 3460 DEFINE_MDNODE_GET(DIMacro, (unsigned MIType, unsigned Line, MDString *Name, 3461 MDString *Value), 3462 (MIType, Line, Name, Value)) 3463 3464 TempDIMacro clone() const { return cloneImpl(); } 3465 3466 unsigned getLine() const { return Line; } 3467 3468 StringRef getName() const { return getStringOperand(0); } 3469 StringRef getValue() const { return getStringOperand(1); } 3470 3471 MDString *getRawName() const { return getOperandAs<MDString>(0); } 3472 MDString *getRawValue() const { return getOperandAs<MDString>(1); } 3473 3474 static bool classof(const Metadata *MD) { 3475 return MD->getMetadataID() == DIMacroKind; 3476 } 3477}; 3478 3479class DIMacroFile : public DIMacroNode { 3480 friend class LLVMContextImpl; 3481 friend class MDNode; 3482 3483 unsigned Line; 3484 3485 DIMacroFile(LLVMContext &C, StorageType Storage, unsigned MIType, 3486 unsigned Line, ArrayRef<Metadata *> Ops) 3487 : DIMacroNode(C, DIMacroFileKind, Storage, MIType, Ops), Line(Line) {} 3488 ~DIMacroFile() = default; 3489 3490 static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType, 3491 unsigned Line, DIFile *File, 3492 DIMacroNodeArray Elements, StorageType Storage, 3493 bool ShouldCreate = true) { 3494 return getImpl(Context, MIType, Line, static_cast<Metadata *>(File), 3495 Elements.get(), Storage, ShouldCreate); 3496 } 3497 3498 static DIMacroFile *getImpl(LLVMContext &Context, unsigned MIType, 3499 unsigned Line, Metadata *File, Metadata *Elements, 3500 StorageType Storage, bool ShouldCreate = true); 3501 3502 TempDIMacroFile cloneImpl() const { 3503 return getTemporary(getContext(), getMacinfoType(), getLine(), getFile(), 3504 getElements()); 3505 } 3506 3507public: 3508 DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line, DIFile *File, 3509 DIMacroNodeArray Elements), 3510 (MIType, Line, File, Elements)) 3511 DEFINE_MDNODE_GET(DIMacroFile, (unsigned MIType, unsigned Line, 3512 Metadata *File, Metadata *Elements), 3513 (MIType, Line, File, Elements)) 3514 3515 TempDIMacroFile clone() const { return cloneImpl(); } 3516 3517 void replaceElements(DIMacroNodeArray Elements) { 3518#ifndef NDEBUG 3519 for (DIMacroNode *Op : getElements()) 3520 assert(is_contained(Elements->operands(), Op) && 3521 "Lost a macro node during macro node list replacement"); 3522#endif 3523 replaceOperandWith(1, Elements.get()); 3524 } 3525 3526 unsigned getLine() const { return Line; } 3527 DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); } 3528 3529 DIMacroNodeArray getElements() const { 3530 return cast_or_null<MDTuple>(getRawElements()); 3531 } 3532 3533 Metadata *getRawFile() const { return getOperand(0); } 3534 Metadata *getRawElements() const { return getOperand(1); } 3535 3536 static bool classof(const Metadata *MD) { 3537 return MD->getMetadataID() == DIMacroFileKind; 3538 } 3539}; 3540 3541/// List of ValueAsMetadata, to be used as an argument to a dbg.value 3542/// intrinsic. 3543class DIArgList : public MDNode { 3544 friend class LLVMContextImpl; 3545 friend class MDNode; 3546 using iterator = SmallVectorImpl<ValueAsMetadata *>::iterator; 3547 3548 SmallVector<ValueAsMetadata *, 4> Args; 3549 3550 DIArgList(LLVMContext &C, StorageType Storage, 3551 ArrayRef<ValueAsMetadata *> Args) 3552 : MDNode(C, DIArgListKind, Storage, None), 3553 Args(Args.begin(), Args.end()) { 3554 track(); 3555 } 3556 ~DIArgList() { untrack(); } 3557 3558 static DIArgList *getImpl(LLVMContext &Context, 3559 ArrayRef<ValueAsMetadata *> Args, 3560 StorageType Storage, bool ShouldCreate = true); 3561 3562 TempDIArgList cloneImpl() const { 3563 return getTemporary(getContext(), getArgs()); 3564 } 3565 3566 void track(); 3567 void untrack(); 3568 void dropAllReferences(); 3569 3570public: 3571 DEFINE_MDNODE_GET(DIArgList, (ArrayRef<ValueAsMetadata *> Args), (Args)) 3572 3573 TempDIArgList clone() const { return cloneImpl(); } 3574 3575 ArrayRef<ValueAsMetadata *> getArgs() const { return Args; } 3576 3577 iterator args_begin() { return Args.begin(); } 3578 iterator args_end() { return Args.end(); } 3579 3580 static bool classof(const Metadata *MD) { 3581 return MD->getMetadataID() == DIArgListKind; 3582 } 3583 3584 void handleChangedOperand(void *Ref, Metadata *New); 3585}; 3586 3587/// Identifies a unique instance of a variable. 3588/// 3589/// Storage for identifying a potentially inlined instance of a variable, 3590/// or a fragment thereof. This guarantees that exactly one variable instance 3591/// may be identified by this class, even when that variable is a fragment of 3592/// an aggregate variable and/or there is another inlined instance of the same 3593/// source code variable nearby. 3594/// This class does not necessarily uniquely identify that variable: it is 3595/// possible that a DebugVariable with different parameters may point to the 3596/// same variable instance, but not that one DebugVariable points to multiple 3597/// variable instances. 3598class DebugVariable { 3599 using FragmentInfo = DIExpression::FragmentInfo; 3600 3601 const DILocalVariable *Variable; 3602 Optional<FragmentInfo> Fragment; 3603 const DILocation *InlinedAt; 3604 3605 /// Fragment that will overlap all other fragments. Used as default when 3606 /// caller demands a fragment. 3607 static const FragmentInfo DefaultFragment; 3608 3609public: 3610 DebugVariable(const DILocalVariable *Var, Optional<FragmentInfo> FragmentInfo, 3611 const DILocation *InlinedAt) 3612 : Variable(Var), Fragment(FragmentInfo), InlinedAt(InlinedAt) {} 3613 3614 DebugVariable(const DILocalVariable *Var, const DIExpression *DIExpr, 3615 const DILocation *InlinedAt) 3616 : Variable(Var), 3617 Fragment(DIExpr ? DIExpr->getFragmentInfo() : NoneType()), 3618 InlinedAt(InlinedAt) {} 3619 3620 const DILocalVariable *getVariable() const { return Variable; } 3621 Optional<FragmentInfo> getFragment() const { return Fragment; } 3622 const DILocation *getInlinedAt() const { return InlinedAt; } 3623 3624 FragmentInfo getFragmentOrDefault() const { 3625 return Fragment.getValueOr(DefaultFragment); 3626 } 3627 3628 static bool isDefaultFragment(const FragmentInfo F) { 3629 return F == DefaultFragment; 3630 } 3631 3632 bool operator==(const DebugVariable &Other) const { 3633 return std::tie(Variable, Fragment, InlinedAt) == 3634 std::tie(Other.Variable, Other.Fragment, Other.InlinedAt); 3635 } 3636 3637 bool operator<(const DebugVariable &Other) const { 3638 return std::tie(Variable, Fragment, InlinedAt) < 3639 std::tie(Other.Variable, Other.Fragment, Other.InlinedAt); 3640 } 3641}; 3642 3643template <> struct DenseMapInfo<DebugVariable> { 3644 using FragmentInfo = DIExpression::FragmentInfo; 3645 3646 /// Empty key: no key should be generated that has no DILocalVariable. 3647 static inline DebugVariable getEmptyKey() { 3648 return DebugVariable(nullptr, NoneType(), nullptr); 3649 } 3650 3651 /// Difference in tombstone is that the Optional is meaningful. 3652 static inline DebugVariable getTombstoneKey() { 3653 return DebugVariable(nullptr, {{0, 0}}, nullptr); 3654 } 3655 3656 static unsigned getHashValue(const DebugVariable &D) { 3657 unsigned HV = 0; 3658 const Optional<FragmentInfo> Fragment = D.getFragment(); 3659 if (Fragment) 3660 HV = DenseMapInfo<FragmentInfo>::getHashValue(*Fragment); 3661 3662 return hash_combine(D.getVariable(), HV, D.getInlinedAt()); 3663 } 3664 3665 static bool isEqual(const DebugVariable &A, const DebugVariable &B) { 3666 return A == B; 3667 } 3668}; 3669 3670} // end namespace llvm 3671 3672#undef DEFINE_MDNODE_GET_UNPACK_IMPL 3673#undef DEFINE_MDNODE_GET_UNPACK 3674#undef DEFINE_MDNODE_GET 3675 3676#endif // LLVM_IR_DEBUGINFOMETADATA_H 3677