include/llvm/IR/DebugInfoMetadata.h

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