contrib/llvm/include/llvm/IR/DebugInfoMetadata.h

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