lib/IR/DIBuilder.cpp

   1 //===--- DIBuilder.cpp - Debug Information Builder ------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the DIBuilder.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/IR/DIBuilder.h"
  15 #include "llvm/ADT/STLExtras.h"
  16 #include "llvm/IR/Constants.h"
  17 #include "llvm/IR/DebugInfo.h"
  18 #include "llvm/IR/IntrinsicInst.h"
  19 #include "llvm/IR/Module.h"
  20 #include "llvm/Support/Debug.h"
  21 #include "llvm/Support/Dwarf.h"
  22
  23 using namespace llvm;
  24 using namespace llvm::dwarf;
  25
  26 namespace {
  27 class HeaderBuilder {
  28   /// \brief Whether there are any fields yet.
  29   ///
  30   /// Note that this is not equivalent to \c Chars.empty(), since \a concat()
  31   /// may have been called already with an empty string.
  32   bool IsEmpty;
  33   SmallVector<char, 256> Chars;
  34
  35 public:
  36   HeaderBuilder() : IsEmpty(true) {}
  37   HeaderBuilder(const HeaderBuilder &X) : IsEmpty(X.IsEmpty), Chars(X.Chars) {}
  38   HeaderBuilder(HeaderBuilder &&X)
  39       : IsEmpty(X.IsEmpty), Chars(std::move(X.Chars)) {}
  40
  41   template <class Twineable> HeaderBuilder &concat(Twineable &&X) {
  42     if (IsEmpty)
  43       IsEmpty = false;
  44     else
  45       Chars.push_back(0);
  46     Twine(X).toVector(Chars);
  47     return *this;
  48   }
  49
  50   MDString *get(LLVMContext &Context) const {
  51     return MDString::get(Context, StringRef(Chars.begin(), Chars.size()));
  52   }
  53
  54   static HeaderBuilder get(unsigned Tag) {
  55     return HeaderBuilder().concat("0x" + Twine::utohexstr(Tag));
  56   }
  57 };
  58 }
  59
  60 DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes)
  61     : M(m), VMContext(M.getContext()), TempEnumTypes(nullptr),
  62       TempRetainTypes(nullptr), TempSubprograms(nullptr), TempGVs(nullptr),
  63       DeclareFn(nullptr), ValueFn(nullptr),
  64       AllowUnresolvedNodes(AllowUnresolvedNodes) {}
  65
  66 void DIBuilder::trackIfUnresolved(MDNode *N) {
  67   if (!N)
  68     return;
  69   if (N->isResolved())
  70     return;
  71
  72   assert(AllowUnresolvedNodes && "Cannot handle unresolved nodes");
  73   UnresolvedNodes.emplace_back(N);
  74 }
  75
  76 void DIBuilder::finalize() {
  77   DIArray Enums = getOrCreateArray(AllEnumTypes);
  78   DIType(TempEnumTypes).replaceAllUsesWith(Enums);
  79
  80   SmallVector<Metadata *, 16> RetainValues;
  81   // Declarations and definitions of the same type may be retained. Some
  82   // clients RAUW these pairs, leaving duplicates in the retained types
  83   // list. Use a set to remove the duplicates while we transform the
  84   // TrackingVHs back into Values.
  85   SmallPtrSet<Metadata *, 16> RetainSet;
  86   for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++)
  87     if (RetainSet.insert(AllRetainTypes[I]).second)
  88       RetainValues.push_back(AllRetainTypes[I]);
  89   DIArray RetainTypes = getOrCreateArray(RetainValues);
  90   DIType(TempRetainTypes).replaceAllUsesWith(RetainTypes);
  91
  92   DIArray SPs = getOrCreateArray(AllSubprograms);
  93   DIType(TempSubprograms).replaceAllUsesWith(SPs);
  94   for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
  95     DISubprogram SP(SPs.getElement(i));
  96     if (MDNode *Temp = SP.getVariablesNodes()) {
  97       const auto &PV = PreservedVariables.lookup(SP);
  98       SmallVector<Metadata *, 4> Variables(PV.begin(), PV.end());
  99       DIArray AV = getOrCreateArray(Variables);
 100       DIType(Temp).replaceAllUsesWith(AV);
 101     }
 102   }
 103
 104   DIArray GVs = getOrCreateArray(AllGVs);
 105   DIType(TempGVs).replaceAllUsesWith(GVs);
 106
 107   SmallVector<Metadata *, 16> RetainValuesI(AllImportedModules.begin(),
 108                                             AllImportedModules.end());
 109   DIArray IMs = getOrCreateArray(RetainValuesI);
 110   DIType(TempImportedModules).replaceAllUsesWith(IMs);
 111
 112   // Now that all temp nodes have been replaced or deleted, resolve remaining
 113   // cycles.
 114   for (const auto &N : UnresolvedNodes)
 115     if (N && !N->isResolved())
 116       N->resolveCycles();
 117   UnresolvedNodes.clear();
 118
 119   // Can't handle unresolved nodes anymore.
 120   AllowUnresolvedNodes = false;
 121 }
 122
 123 /// If N is compile unit return NULL otherwise return N.
 124 static MDNode *getNonCompileUnitScope(MDNode *N) {
 125   if (DIDescriptor(N).isCompileUnit())
 126     return nullptr;
 127   return N;
 128 }
 129
 130 static MDNode *createFilePathPair(LLVMContext &VMContext, StringRef Filename,
 131                                   StringRef Directory) {
 132   assert(!Filename.empty() && "Unable to create file without name");
 133   Metadata *Pair[] = {MDString::get(VMContext, Filename),
 134                       MDString::get(VMContext, Directory)};
 135   return MDNode::get(VMContext, Pair);
 136 }
 137
 138 DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
 139                                            StringRef Directory,
 140                                            StringRef Producer, bool isOptimized,
 141                                            StringRef Flags, unsigned RunTimeVer,
 142                                            StringRef SplitName,
 143                                            DebugEmissionKind Kind,
 144                                            bool EmitDebugInfo) {
 145
 146   assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) ||
 147           (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
 148          "Invalid Language tag");
 149   assert(!Filename.empty() &&
 150          "Unable to create compile unit without filename");
 151
 152   // TODO: Once we make MDCompileUnit distinct, stop using temporaries here
 153   // (just start with operands assigned to nullptr).
 154   TempEnumTypes = MDTuple::getTemporary(VMContext, None).release();
 155   TempRetainTypes = MDTuple::getTemporary(VMContext, None).release();
 156   TempSubprograms = MDTuple::getTemporary(VMContext, None).release();
 157   TempGVs = MDTuple::getTemporary(VMContext, None).release();
 158   TempImportedModules = MDTuple::getTemporary(VMContext, None).release();
 159
 160   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_compile_unit)
 161                           .concat(Lang)
 162                           .concat(Producer)
 163                           .concat(isOptimized)
 164                           .concat(Flags)
 165                           .concat(RunTimeVer)
 166                           .concat(SplitName)
 167                           .concat(Kind)
 168                           .get(VMContext),
 169                       createFilePathPair(VMContext, Filename, Directory),
 170                       TempEnumTypes, TempRetainTypes, TempSubprograms, TempGVs,
 171                       TempImportedModules};
 172
 173   // TODO: Switch to getDistinct().  We never want to merge compile units based
 174   // on contents.
 175   MDNode *CUNode = MDNode::get(VMContext, Elts);
 176
 177   // Create a named metadata so that it is easier to find cu in a module.
 178   // Note that we only generate this when the caller wants to actually
 179   // emit debug information. When we are only interested in tracking
 180   // source line locations throughout the backend, we prevent codegen from
 181   // emitting debug info in the final output by not generating llvm.dbg.cu.
 182   if (EmitDebugInfo) {
 183     NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
 184     NMD->addOperand(CUNode);
 185   }
 186
 187   trackIfUnresolved(CUNode);
 188   return DICompileUnit(CUNode);
 189 }
 190
 191 static DIImportedEntity
 192 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope Context,
 193                      Metadata *NS, unsigned Line, StringRef Name,
 194                      SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
 195   const MDNode *R;
 196   Metadata *Elts[] = {HeaderBuilder::get(Tag).concat(Line).concat(Name).get(C),
 197                       Context, NS};
 198   R = MDNode::get(C, Elts);
 199   DIImportedEntity M(R);
 200   assert(M.Verify() && "Imported module should be valid");
 201   AllImportedModules.emplace_back(M.get());
 202   return M;
 203 }
 204
 205 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
 206                                                  DINameSpace NS,
 207                                                  unsigned Line) {
 208   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
 209                                 Context, NS, Line, StringRef(), AllImportedModules);
 210 }
 211
 212 DIImportedEntity DIBuilder::createImportedModule(DIScope Context,
 213                                                  DIImportedEntity NS,
 214                                                  unsigned Line) {
 215   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
 216                                 Context, NS, Line, StringRef(), AllImportedModules);
 217 }
 218
 219 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
 220                                                       DIDescriptor Decl,
 221                                                       unsigned Line, StringRef Name) {
 222   // Make sure to use the unique identifier based metadata reference for
 223   // types that have one.
 224   Metadata *V =
 225       Decl.isType() ? static_cast<Metadata *>(DIType(Decl).getRef()) : Decl;
 226   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
 227                                 Context, V, Line, Name,
 228                                 AllImportedModules);
 229 }
 230
 231 DIImportedEntity DIBuilder::createImportedDeclaration(DIScope Context,
 232                                                       DIImportedEntity Imp,
 233                                                       unsigned Line, StringRef Name) {
 234   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
 235                                 Context, Imp, Line, Name, AllImportedModules);
 236 }
 237
 238 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
 239   Metadata *Elts[] = {
 240       HeaderBuilder::get(dwarf::DW_TAG_file_type).get(VMContext),
 241       createFilePathPair(VMContext, Filename, Directory)};
 242   return DIFile(MDNode::get(VMContext, Elts));
 243 }
 244
 245 DIEnumerator DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
 246   assert(!Name.empty() && "Unable to create enumerator without name");
 247   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_enumerator)
 248                           .concat(Name)
 249                           .concat(Val)
 250                           .get(VMContext)};
 251   return DIEnumerator(MDNode::get(VMContext, Elts));
 252 }
 253
 254 DIBasicType DIBuilder::createUnspecifiedType(StringRef Name) {
 255   assert(!Name.empty() && "Unable to create type without name");
 256   // Unspecified types are encoded in DIBasicType format. Line number, filename,
 257   // size, alignment, offset and flags are always empty here.
 258   Metadata *Elts[] = {
 259       HeaderBuilder::get(dwarf::DW_TAG_unspecified_type)
 260           .concat(Name)
 261           .concat(0)
 262           .concat(0)
 263           .concat(0)
 264           .concat(0)
 265           .concat(0)
 266           .concat(0)
 267           .get(VMContext),
 268       nullptr, // Filename
 269       nullptr  // Unused
 270   };
 271   return DIBasicType(MDNode::get(VMContext, Elts));
 272 }
 273
 274 DIBasicType DIBuilder::createNullPtrType() {
 275   return createUnspecifiedType("decltype(nullptr)");
 276 }
 277
 278 DIBasicType
 279 DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
 280                            uint64_t AlignInBits, unsigned Encoding) {
 281   assert(!Name.empty() && "Unable to create type without name");
 282   // Basic types are encoded in DIBasicType format. Line number, filename,
 283   // offset and flags are always empty here.
 284   Metadata *Elts[] = {
 285       HeaderBuilder::get(dwarf::DW_TAG_base_type)
 286           .concat(Name)
 287           .concat(0) // Line
 288           .concat(SizeInBits)
 289           .concat(AlignInBits)
 290           .concat(0) // Offset
 291           .concat(0) // Flags
 292           .concat(Encoding)
 293           .get(VMContext),
 294       nullptr, // Filename
 295       nullptr  // Unused
 296   };
 297   return DIBasicType(MDNode::get(VMContext, Elts));
 298 }
 299
 300 DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
 301   // Qualified types are encoded in DIDerivedType format.
 302   Metadata *Elts[] = {HeaderBuilder::get(Tag)
 303                           .concat(StringRef()) // Name
 304                           .concat(0)           // Line
 305                           .concat(0)           // Size
 306                           .concat(0)           // Align
 307                           .concat(0)           // Offset
 308                           .concat(0)           // Flags
 309                           .get(VMContext),
 310                       nullptr, // Filename
 311                       nullptr, // Unused
 312                       FromTy.getRef()};
 313   return DIDerivedType(MDNode::get(VMContext, Elts));
 314 }
 315
 316 DIDerivedType
 317 DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
 318                              uint64_t AlignInBits, StringRef Name) {
 319   // Pointer types are encoded in DIDerivedType format.
 320   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_pointer_type)
 321                           .concat(Name)
 322                           .concat(0) // Line
 323                           .concat(SizeInBits)
 324                           .concat(AlignInBits)
 325                           .concat(0) // Offset
 326                           .concat(0) // Flags
 327                           .get(VMContext),
 328                       nullptr, // Filename
 329                       nullptr, // Unused
 330                       PointeeTy.getRef()};
 331   return DIDerivedType(MDNode::get(VMContext, Elts));
 332 }
 333
 334 DIDerivedType
 335 DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base,
 336                                    uint64_t SizeInBits, uint64_t AlignInBits) {
 337   // Pointer types are encoded in DIDerivedType format.
 338   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_ptr_to_member_type)
 339                           .concat(StringRef())
 340                           .concat(0) // Line
 341                           .concat(SizeInBits) // Size
 342                           .concat(AlignInBits) // Align
 343                           .concat(0) // Offset
 344                           .concat(0) // Flags
 345                           .get(VMContext),
 346                       nullptr, // Filename
 347                       nullptr, // Unused
 348                       PointeeTy.getRef(), Base.getRef()};
 349   return DIDerivedType(MDNode::get(VMContext, Elts));
 350 }
 351
 352 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
 353   assert(RTy.isType() && "Unable to create reference type");
 354   // References are encoded in DIDerivedType format.
 355   Metadata *Elts[] = {HeaderBuilder::get(Tag)
 356                           .concat(StringRef()) // Name
 357                           .concat(0)           // Line
 358                           .concat(0)           // Size
 359                           .concat(0)           // Align
 360                           .concat(0)           // Offset
 361                           .concat(0)           // Flags
 362                           .get(VMContext),
 363                       nullptr, // Filename
 364                       nullptr, // TheCU,
 365                       RTy.getRef()};
 366   return DIDerivedType(MDNode::get(VMContext, Elts));
 367 }
 368
 369 DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
 370                                        unsigned LineNo, DIDescriptor Context) {
 371   // typedefs are encoded in DIDerivedType format.
 372   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_typedef)
 373                           .concat(Name)
 374                           .concat(LineNo)
 375                           .concat(0) // Size
 376                           .concat(0) // Align
 377                           .concat(0) // Offset
 378                           .concat(0) // Flags
 379                           .get(VMContext),
 380                       File.getFileNode(),
 381                       DIScope(getNonCompileUnitScope(Context)).getRef(),
 382                       Ty.getRef()};
 383   return DIDerivedType(MDNode::get(VMContext, Elts));
 384 }
 385
 386 DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
 387   // typedefs are encoded in DIDerivedType format.
 388   assert(Ty.isType() && "Invalid type!");
 389   assert(FriendTy.isType() && "Invalid friend type!");
 390   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_friend)
 391                           .concat(StringRef()) // Name
 392                           .concat(0)           // Line
 393                           .concat(0)           // Size
 394                           .concat(0)           // Align
 395                           .concat(0)           // Offset
 396                           .concat(0)           // Flags
 397                           .get(VMContext),
 398                       nullptr, Ty.getRef(), FriendTy.getRef()};
 399   return DIDerivedType(MDNode::get(VMContext, Elts));
 400 }
 401
 402 DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
 403                                            uint64_t BaseOffset,
 404                                            unsigned Flags) {
 405   assert(Ty.isType() && "Unable to create inheritance");
 406   // TAG_inheritance is encoded in DIDerivedType format.
 407   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_inheritance)
 408                           .concat(StringRef()) // Name
 409                           .concat(0)           // Line
 410                           .concat(0)           // Size
 411                           .concat(0)           // Align
 412                           .concat(BaseOffset)
 413                           .concat(Flags)
 414                           .get(VMContext),
 415                       nullptr, Ty.getRef(), BaseTy.getRef()};
 416   auto R = DIDerivedType(MDNode::get(VMContext, Elts));
 417   return R;
 418 }
 419
 420 DIDerivedType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
 421                                           DIFile File, unsigned LineNumber,
 422                                           uint64_t SizeInBits,
 423                                           uint64_t AlignInBits,
 424                                           uint64_t OffsetInBits, unsigned Flags,
 425                                           DIType Ty) {
 426   // TAG_member is encoded in DIDerivedType format.
 427   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
 428                           .concat(Name)
 429                           .concat(LineNumber)
 430                           .concat(SizeInBits)
 431                           .concat(AlignInBits)
 432                           .concat(OffsetInBits)
 433                           .concat(Flags)
 434                           .get(VMContext),
 435                       File.getFileNode(),
 436                       DIScope(getNonCompileUnitScope(Scope)).getRef(),
 437                       Ty.getRef()};
 438   return DIDerivedType(MDNode::get(VMContext, Elts));
 439 }
 440
 441 static Metadata *getConstantOrNull(Constant *C) {
 442   if (C)
 443     return ConstantAsMetadata::get(C);
 444   return nullptr;
 445 }
 446
 447 DIDerivedType DIBuilder::createStaticMemberType(DIDescriptor Scope,
 448                                                 StringRef Name, DIFile File,
 449                                                 unsigned LineNumber, DIType Ty,
 450                                                 unsigned Flags,
 451                                                 llvm::Constant *Val) {
 452   // TAG_member is encoded in DIDerivedType format.
 453   Flags |= DIDescriptor::FlagStaticMember;
 454   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
 455                           .concat(Name)
 456                           .concat(LineNumber)
 457                           .concat(0) // Size
 458                           .concat(0) // Align
 459                           .concat(0) // Offset
 460                           .concat(Flags)
 461                           .get(VMContext),
 462                       File.getFileNode(),
 463                       DIScope(getNonCompileUnitScope(Scope)).getRef(),
 464                       Ty.getRef(), getConstantOrNull(Val)};
 465   return DIDerivedType(MDNode::get(VMContext, Elts));
 466 }
 467
 468 DIDerivedType DIBuilder::createObjCIVar(StringRef Name, DIFile File,
 469                                         unsigned LineNumber,
 470                                         uint64_t SizeInBits,
 471                                         uint64_t AlignInBits,
 472                                         uint64_t OffsetInBits, unsigned Flags,
 473                                         DIType Ty, MDNode *PropertyNode) {
 474   // TAG_member is encoded in DIDerivedType format.
 475   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_member)
 476                           .concat(Name)
 477                           .concat(LineNumber)
 478                           .concat(SizeInBits)
 479                           .concat(AlignInBits)
 480                           .concat(OffsetInBits)
 481                           .concat(Flags)
 482                           .get(VMContext),
 483                       File.getFileNode(), getNonCompileUnitScope(File), Ty,
 484                       PropertyNode};
 485   return DIDerivedType(MDNode::get(VMContext, Elts));
 486 }
 487
 488 DIObjCProperty
 489 DIBuilder::createObjCProperty(StringRef Name, DIFile File, unsigned LineNumber,
 490                               StringRef GetterName, StringRef SetterName,
 491                               unsigned PropertyAttributes, DIType Ty) {
 492   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_APPLE_property)
 493                           .concat(Name)
 494                           .concat(LineNumber)
 495                           .concat(GetterName)
 496                           .concat(SetterName)
 497                           .concat(PropertyAttributes)
 498                           .get(VMContext),
 499                       File, Ty};
 500   return DIObjCProperty(MDNode::get(VMContext, Elts));
 501 }
 502
 503 DITemplateTypeParameter
 504 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
 505                                        DIType Ty) {
 506   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
 507                           .concat(Name)
 508                           .concat(0)
 509                           .concat(0)
 510                           .get(VMContext),
 511                       DIScope(getNonCompileUnitScope(Context)).getRef(),
 512                       Ty.getRef(), nullptr};
 513   return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
 514 }
 515
 516 static DITemplateValueParameter
 517 createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
 518                                    DIDescriptor Context, StringRef Name,
 519                                    DIType Ty, Metadata *MD) {
 520   Metadata *Elts[] = {
 521       HeaderBuilder::get(Tag).concat(Name).concat(0).concat(0).get(VMContext),
 522       DIScope(getNonCompileUnitScope(Context)).getRef(), Ty.getRef(), MD,
 523       nullptr};
 524   return DITemplateValueParameter(MDNode::get(VMContext, Elts));
 525 }
 526
 527 DITemplateValueParameter
 528 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
 529                                         DIType Ty, Constant *Val) {
 530   return createTemplateValueParameterHelper(
 531       VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
 532       getConstantOrNull(Val));
 533 }
 534
 535 DITemplateValueParameter
 536 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
 537                                            DIType Ty, StringRef Val) {
 538   return createTemplateValueParameterHelper(
 539       VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
 540       MDString::get(VMContext, Val));
 541 }
 542
 543 DITemplateValueParameter
 544 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
 545                                        DIType Ty, DIArray Val) {
 546   return createTemplateValueParameterHelper(
 547       VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
 548       Val);
 549 }
 550
 551 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
 552                                            DIFile File, unsigned LineNumber,
 553                                            uint64_t SizeInBits,
 554                                            uint64_t AlignInBits,
 555                                            uint64_t OffsetInBits,
 556                                            unsigned Flags, DIType DerivedFrom,
 557                                            DIArray Elements,
 558                                            DIType VTableHolder,
 559                                            MDNode *TemplateParams,
 560                                            StringRef UniqueIdentifier) {
 561   assert((!Context || Context.isScope() || Context.isType()) &&
 562          "createClassType should be called with a valid Context");
 563   // TAG_class_type is encoded in DICompositeType format.
 564   Metadata *Elts[] = {
 565       HeaderBuilder::get(dwarf::DW_TAG_class_type)
 566           .concat(Name)
 567           .concat(LineNumber)
 568           .concat(SizeInBits)
 569           .concat(AlignInBits)
 570           .concat(OffsetInBits)
 571           .concat(Flags)
 572           .concat(0)
 573           .get(VMContext),
 574       File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
 575       DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
 576       UniqueIdentifier.empty() ? nullptr
 577                                : MDString::get(VMContext, UniqueIdentifier)};
 578   DICompositeType R(MDNode::get(VMContext, Elts));
 579   assert(R.isCompositeType() &&
 580          "createClassType should return a DICompositeType");
 581   if (!UniqueIdentifier.empty())
 582     retainType(R);
 583   trackIfUnresolved(R);
 584   return R;
 585 }
 586
 587 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
 588                                             StringRef Name, DIFile File,
 589                                             unsigned LineNumber,
 590                                             uint64_t SizeInBits,
 591                                             uint64_t AlignInBits,
 592                                             unsigned Flags, DIType DerivedFrom,
 593                                             DIArray Elements,
 594                                             unsigned RunTimeLang,
 595                                             DIType VTableHolder,
 596                                             StringRef UniqueIdentifier) {
 597  // TAG_structure_type is encoded in DICompositeType format.
 598   Metadata *Elts[] = {
 599       HeaderBuilder::get(dwarf::DW_TAG_structure_type)
 600           .concat(Name)
 601           .concat(LineNumber)
 602           .concat(SizeInBits)
 603           .concat(AlignInBits)
 604           .concat(0)
 605           .concat(Flags)
 606           .concat(RunTimeLang)
 607           .get(VMContext),
 608       File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
 609       DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
 610       UniqueIdentifier.empty() ? nullptr
 611                                : MDString::get(VMContext, UniqueIdentifier)};
 612   DICompositeType R(MDNode::get(VMContext, Elts));
 613   assert(R.isCompositeType() &&
 614          "createStructType should return a DICompositeType");
 615   if (!UniqueIdentifier.empty())
 616     retainType(R);
 617   trackIfUnresolved(R);
 618   return R;
 619 }
 620
 621 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
 622                                            DIFile File, unsigned LineNumber,
 623                                            uint64_t SizeInBits,
 624                                            uint64_t AlignInBits, unsigned Flags,
 625                                            DIArray Elements,
 626                                            unsigned RunTimeLang,
 627                                            StringRef UniqueIdentifier) {
 628   // TAG_union_type is encoded in DICompositeType format.
 629   Metadata *Elts[] = {
 630       HeaderBuilder::get(dwarf::DW_TAG_union_type)
 631           .concat(Name)
 632           .concat(LineNumber)
 633           .concat(SizeInBits)
 634           .concat(AlignInBits)
 635           .concat(0) // Offset
 636           .concat(Flags)
 637           .concat(RunTimeLang)
 638           .get(VMContext),
 639       File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
 640       nullptr, Elements, nullptr, nullptr,
 641       UniqueIdentifier.empty() ? nullptr
 642                                : MDString::get(VMContext, UniqueIdentifier)};
 643   DICompositeType R(MDNode::get(VMContext, Elts));
 644   if (!UniqueIdentifier.empty())
 645     retainType(R);
 646   trackIfUnresolved(R);
 647   return R;
 648 }
 649
 650 DISubroutineType DIBuilder::createSubroutineType(DIFile File,
 651                                                  DITypeArray ParameterTypes,
 652                                                  unsigned Flags) {
 653   // TAG_subroutine_type is encoded in DICompositeType format.
 654   Metadata *Elts[] = {
 655       HeaderBuilder::get(dwarf::DW_TAG_subroutine_type)
 656           .concat(StringRef())
 657           .concat(0)     // Line
 658           .concat(0)     // Size
 659           .concat(0)     // Align
 660           .concat(0)     // Offset
 661           .concat(Flags) // Flags
 662           .concat(0)
 663           .get(VMContext),
 664       nullptr, nullptr, nullptr, ParameterTypes, nullptr, nullptr,
 665       nullptr // Type Identifer
 666   };
 667   return DISubroutineType(MDNode::get(VMContext, Elts));
 668 }
 669
 670 DICompositeType DIBuilder::createEnumerationType(
 671     DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
 672     uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
 673     DIType UnderlyingType, StringRef UniqueIdentifier) {
 674   // TAG_enumeration_type is encoded in DICompositeType format.
 675   Metadata *Elts[] = {
 676       HeaderBuilder::get(dwarf::DW_TAG_enumeration_type)
 677           .concat(Name)
 678           .concat(LineNumber)
 679           .concat(SizeInBits)
 680           .concat(AlignInBits)
 681           .concat(0) // Offset
 682           .concat(0) // Flags
 683           .concat(0)
 684           .get(VMContext),
 685       File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
 686       UnderlyingType.getRef(), Elements, nullptr, nullptr,
 687       UniqueIdentifier.empty() ? nullptr
 688                                : MDString::get(VMContext, UniqueIdentifier)};
 689   DICompositeType CTy(MDNode::get(VMContext, Elts));
 690   AllEnumTypes.push_back(CTy);
 691   if (!UniqueIdentifier.empty())
 692     retainType(CTy);
 693   trackIfUnresolved(CTy);
 694   return CTy;
 695 }
 696
 697 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
 698                                            DIType Ty, DIArray Subscripts) {
 699   // TAG_array_type is encoded in DICompositeType format.
 700   Metadata *Elts[] = {
 701       HeaderBuilder::get(dwarf::DW_TAG_array_type)
 702           .concat(StringRef())
 703           .concat(0) // Line
 704           .concat(Size)
 705           .concat(AlignInBits)
 706           .concat(0) // Offset
 707           .concat(0) // Flags
 708           .concat(0)
 709           .get(VMContext),
 710       nullptr, // Filename/Directory,
 711       nullptr, // Unused
 712       Ty.getRef(), Subscripts, nullptr, nullptr,
 713       nullptr // Type Identifer
 714   };
 715   DICompositeType R(MDNode::get(VMContext, Elts));
 716   trackIfUnresolved(R);
 717   return R;
 718 }
 719
 720 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
 721                                             DIType Ty, DIArray Subscripts) {
 722   // A vector is an array type with the FlagVector flag applied.
 723   Metadata *Elts[] = {
 724       HeaderBuilder::get(dwarf::DW_TAG_array_type)
 725           .concat("")
 726           .concat(0) // Line
 727           .concat(Size)
 728           .concat(AlignInBits)
 729           .concat(0) // Offset
 730           .concat(DIType::FlagVector)
 731           .concat(0)
 732           .get(VMContext),
 733       nullptr, // Filename/Directory,
 734       nullptr, // Unused
 735       Ty.getRef(), Subscripts, nullptr, nullptr,
 736       nullptr // Type Identifer
 737   };
 738   DICompositeType R(MDNode::get(VMContext, Elts));
 739   trackIfUnresolved(R);
 740   return R;
 741 }
 742
 743 static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
 744                                           unsigned FlagsToSet) {
 745   DIHeaderFieldIterator I(Header);
 746   std::advance(I, 6);
 747
 748   unsigned Flags;
 749   if (I->getAsInteger(0, Flags))
 750     Flags = 0;
 751   Flags |= FlagsToSet;
 752
 753   return HeaderBuilder()
 754       .concat(I.getPrefix())
 755       .concat(Flags)
 756       .concat(I.getSuffix());
 757 }
 758
 759 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
 760                                   unsigned FlagsToSet) {
 761   SmallVector<Metadata *, 9> Elts;
 762   MDNode *N = Ty;
 763   assert(N && "Unexpected input DIType!");
 764   // Update header field.
 765   Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
 766   Elts.append(N->op_begin() + 1, N->op_end());
 767
 768   return DIType(MDNode::get(Context, Elts));
 769 }
 770
 771 DIType DIBuilder::createArtificialType(DIType Ty) {
 772   if (Ty.isArtificial())
 773     return Ty;
 774   return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
 775 }
 776
 777 DIType DIBuilder::createObjectPointerType(DIType Ty) {
 778   if (Ty.isObjectPointer())
 779     return Ty;
 780   unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
 781   return createTypeWithFlags(VMContext, Ty, Flags);
 782 }
 783
 784 void DIBuilder::retainType(DIType T) { AllRetainTypes.emplace_back(T); }
 785
 786 DIBasicType DIBuilder::createUnspecifiedParameter() {
 787   return DIBasicType();
 788 }
 789
 790 DICompositeType
 791 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
 792                              DIFile F, unsigned Line, unsigned RuntimeLang,
 793                              uint64_t SizeInBits, uint64_t AlignInBits,
 794                              StringRef UniqueIdentifier) {
 795   // Create a temporary MDNode.
 796   Metadata *Elts[] = {
 797       HeaderBuilder::get(Tag)
 798           .concat(Name)
 799           .concat(Line)
 800           .concat(SizeInBits)
 801           .concat(AlignInBits)
 802           .concat(0) // Offset
 803           .concat(DIDescriptor::FlagFwdDecl)
 804           .concat(RuntimeLang)
 805           .get(VMContext),
 806       F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
 807       DIArray(), nullptr,
 808       nullptr, // TemplateParams
 809       UniqueIdentifier.empty() ? nullptr
 810                                : MDString::get(VMContext, UniqueIdentifier)};
 811   MDNode *Node = MDNode::get(VMContext, Elts);
 812   DICompositeType RetTy(Node);
 813   assert(RetTy.isCompositeType() &&
 814          "createForwardDecl result should be a DIType");
 815   if (!UniqueIdentifier.empty())
 816     retainType(RetTy);
 817   trackIfUnresolved(RetTy);
 818   return RetTy;
 819 }
 820
 821 DICompositeType DIBuilder::createReplaceableCompositeType(
 822     unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
 823     unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
 824     unsigned Flags, StringRef UniqueIdentifier) {
 825   // Create a temporary MDNode.
 826   Metadata *Elts[] = {
 827       HeaderBuilder::get(Tag)
 828           .concat(Name)
 829           .concat(Line)
 830           .concat(SizeInBits)
 831           .concat(AlignInBits)
 832           .concat(0) // Offset
 833           .concat(Flags)
 834           .concat(RuntimeLang)
 835           .get(VMContext),
 836       F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
 837       DIArray(), nullptr,
 838       nullptr, // TemplateParams
 839       UniqueIdentifier.empty() ? nullptr
 840                                : MDString::get(VMContext, UniqueIdentifier)};
 841   DICompositeType RetTy(MDNode::getTemporary(VMContext, Elts).release());
 842   assert(RetTy.isCompositeType() &&
 843          "createReplaceableForwardDecl result should be a DIType");
 844   if (!UniqueIdentifier.empty())
 845     retainType(RetTy);
 846   trackIfUnresolved(RetTy);
 847   return RetTy;
 848 }
 849
 850 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
 851   return DIArray(MDNode::get(VMContext, Elements));
 852 }
 853
 854 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
 855   SmallVector<llvm::Metadata *, 16> Elts;
 856   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
 857     if (Elements[i] && isa<MDNode>(Elements[i]))
 858       Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
 859     else
 860       Elts.push_back(Elements[i]);
 861   }
 862   return DITypeArray(MDNode::get(VMContext, Elts));
 863 }
 864
 865 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
 866   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
 867                           .concat(Lo)
 868                           .concat(Count)
 869                           .get(VMContext)};
 870
 871   return DISubrange(MDNode::get(VMContext, Elts));
 872 }
 873
 874 static DIGlobalVariable createGlobalVariableHelper(
 875     LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
 876     StringRef LinkageName, DIFile F, unsigned LineNumber, DITypeRef Ty,
 877     bool isLocalToUnit, Constant *Val, MDNode *Decl, bool isDefinition,
 878     std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
 879
 880   MDNode *TheCtx = getNonCompileUnitScope(Context);
 881   if (DIScope(TheCtx).isCompositeType()) {
 882     assert(!DICompositeType(TheCtx).getIdentifier() &&
 883            "Context of a global variable should not be a type with identifier");
 884   }
 885
 886   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
 887                           .concat(Name)
 888                           .concat(Name)
 889                           .concat(LinkageName)
 890                           .concat(LineNumber)
 891                           .concat(isLocalToUnit)
 892                           .concat(isDefinition)
 893                           .get(VMContext),
 894                       TheCtx, F, Ty, getConstantOrNull(Val),
 895                       DIDescriptor(Decl)};
 896
 897   return DIGlobalVariable(CreateFunc(Elts));
 898 }
 899
 900 DIGlobalVariable DIBuilder::createGlobalVariable(
 901     DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
 902     unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
 903     MDNode *Decl) {
 904   return createGlobalVariableHelper(
 905       VMContext, Context, Name, LinkageName, F, LineNumber, Ty, isLocalToUnit,
 906       Val, Decl, true, [&](ArrayRef<Metadata *> Elts) -> MDNode *{
 907         MDNode *Node = MDNode::get(VMContext, Elts);
 908         AllGVs.push_back(Node);
 909         return Node;
 910       });
 911 }
 912
 913 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
 914     DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
 915     unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
 916     MDNode *Decl) {
 917   return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
 918                                     LineNumber, Ty, isLocalToUnit, Val, Decl,
 919                                     false, [&](ArrayRef<Metadata *> Elts) {
 920     return MDNode::getTemporary(VMContext, Elts).release();
 921   });
 922 }
 923
 924 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
 925                                           StringRef Name, DIFile File,
 926                                           unsigned LineNo, DITypeRef Ty,
 927                                           bool AlwaysPreserve, unsigned Flags,
 928                                           unsigned ArgNo) {
 929   DIDescriptor Context(getNonCompileUnitScope(Scope));
 930   assert((!Context || Context.isScope()) &&
 931          "createLocalVariable should be called with a valid Context");
 932   Metadata *Elts[] = {HeaderBuilder::get(Tag)
 933                           .concat(Name)
 934                           .concat(LineNo | (ArgNo << 24))
 935                           .concat(Flags)
 936                           .get(VMContext),
 937                       getNonCompileUnitScope(Scope), File, Ty};
 938   MDNode *Node = MDNode::get(VMContext, Elts);
 939   if (AlwaysPreserve) {
 940     // The optimizer may remove local variable. If there is an interest
 941     // to preserve variable info in such situation then stash it in a
 942     // named mdnode.
 943     DISubprogram Fn(getDISubprogram(Scope));
 944     assert(Fn && "Missing subprogram for local variable");
 945     PreservedVariables[Fn].emplace_back(Node);
 946   }
 947   DIVariable RetVar(Node);
 948   assert(RetVar.isVariable() &&
 949          "createLocalVariable should return a valid DIVariable");
 950   return RetVar;
 951 }
 952
 953 DIExpression DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
 954   auto Header = HeaderBuilder::get(DW_TAG_expression);
 955   for (uint64_t I : Addr)
 956     Header.concat(I);
 957   Metadata *Elts[] = {Header.get(VMContext)};
 958   return DIExpression(MDNode::get(VMContext, Elts));
 959 }
 960
 961 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
 962   // TODO: Remove the callers of this signed version and delete.
 963   SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
 964   return createExpression(Addr);
 965 }
 966
 967 DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBits,
 968                                                  unsigned SizeInBits) {
 969   int64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBits, SizeInBits};
 970   return createExpression(Addr);
 971 }
 972
 973 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
 974                                        StringRef LinkageName, DIFile File,
 975                                        unsigned LineNo, DICompositeType Ty,
 976                                        bool isLocalToUnit, bool isDefinition,
 977                                        unsigned ScopeLine, unsigned Flags,
 978                                        bool isOptimized, Function *Fn,
 979                                        MDNode *TParams, MDNode *Decl) {
 980   // dragonegg does not generate identifier for types, so using an empty map
 981   // to resolve the context should be fine.
 982   DITypeIdentifierMap EmptyMap;
 983   return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
 984                         LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
 985                         Flags, isOptimized, Fn, TParams, Decl);
 986 }
 987
 988 static DISubprogram createFunctionHelper(
 989     LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
 990     StringRef LinkageName, DIFile File, unsigned LineNo, DICompositeType Ty,
 991     bool isLocalToUnit, bool isDefinition, unsigned ScopeLine, unsigned Flags,
 992     bool isOptimized, Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
 993     std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
 994   assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
 995          "function types should be subroutines");
 996   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
 997                           .concat(Name)
 998                           .concat(Name)
 999                           .concat(LinkageName)
1000                           .concat(LineNo)
1001                           .concat(isLocalToUnit)
1002                           .concat(isDefinition)
1003                           .concat(0)
1004                           .concat(0)
1005                           .concat(Flags)
1006                           .concat(isOptimized)
1007                           .concat(ScopeLine)
1008                           .get(VMContext),
1009                       File.getFileNode(),
1010                       DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
1011                       nullptr, getConstantOrNull(Fn), TParams, Decl, Vars};
1012
1013   DISubprogram S(CreateFunc(Elts));
1014   assert(S.isSubprogram() &&
1015          "createFunction should return a valid DISubprogram");
1016   return S;
1017 }
1018
1019
1020 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
1021                                        StringRef LinkageName, DIFile File,
1022                                        unsigned LineNo, DICompositeType Ty,
1023                                        bool isLocalToUnit, bool isDefinition,
1024                                        unsigned ScopeLine, unsigned Flags,
1025                                        bool isOptimized, Function *Fn,
1026                                        MDNode *TParams, MDNode *Decl) {
1027   return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1028                               LineNo, Ty, isLocalToUnit, isDefinition,
1029                               ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1030                               MDNode::getTemporary(VMContext, None).release(),
1031                               [&](ArrayRef<Metadata *> Elts) -> MDNode *{
1032     MDNode *Node = MDNode::get(VMContext, Elts);
1033     // Create a named metadata so that we
1034     // do not lose this mdnode.
1035     if (isDefinition)
1036       AllSubprograms.push_back(Node);
1037     trackIfUnresolved(Node);
1038     return Node;
1039   });
1040 }
1041
1042 DISubprogram
1043 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1044                                      StringRef LinkageName, DIFile File,
1045                                      unsigned LineNo, DICompositeType Ty,
1046                                      bool isLocalToUnit, bool isDefinition,
1047                                      unsigned ScopeLine, unsigned Flags,
1048                                      bool isOptimized, Function *Fn,
1049                                      MDNode *TParams, MDNode *Decl) {
1050   return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1051                               LineNo, Ty, isLocalToUnit, isDefinition,
1052                               ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1053                               nullptr, [&](ArrayRef<Metadata *> Elts) {
1054     return MDNode::getTemporary(VMContext, Elts).release();
1055   });
1056 }
1057
1058 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1059                                      StringRef LinkageName, DIFile F,
1060                                      unsigned LineNo, DICompositeType Ty,
1061                                      bool isLocalToUnit, bool isDefinition,
1062                                      unsigned VK, unsigned VIndex,
1063                                      DIType VTableHolder, unsigned Flags,
1064                                      bool isOptimized, Function *Fn,
1065                                      MDNode *TParam) {
1066   assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1067          "function types should be subroutines");
1068   assert(getNonCompileUnitScope(Context) &&
1069          "Methods should have both a Context and a context that isn't "
1070          "the compile unit.");
1071   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1072                           .concat(Name)
1073                           .concat(Name)
1074                           .concat(LinkageName)
1075                           .concat(LineNo)
1076                           .concat(isLocalToUnit)
1077                           .concat(isDefinition)
1078                           .concat(VK)
1079                           .concat(VIndex)
1080                           .concat(Flags)
1081                           .concat(isOptimized)
1082                           .concat(LineNo)
1083                           // FIXME: Do we want to use different scope/lines?
1084                           .get(VMContext),
1085                       F.getFileNode(), DIScope(Context).getRef(), Ty,
1086                       VTableHolder.getRef(), getConstantOrNull(Fn), TParam,
1087                       nullptr, nullptr};
1088   MDNode *Node = MDNode::get(VMContext, Elts);
1089   if (isDefinition)
1090     AllSubprograms.push_back(Node);
1091   DISubprogram S(Node);
1092   assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1093   trackIfUnresolved(S);
1094   return S;
1095 }
1096
1097 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1098                                        DIFile File, unsigned LineNo) {
1099   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1100                           .concat(Name)
1101                           .concat(LineNo)
1102                           .get(VMContext),
1103                       File.getFileNode(), getNonCompileUnitScope(Scope)};
1104   DINameSpace R(MDNode::get(VMContext, Elts));
1105   assert(R.Verify() &&
1106          "createNameSpace should return a verifiable DINameSpace");
1107   return R;
1108 }
1109
1110 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1111                                                      DIFile File,
1112                                                      unsigned Discriminator) {
1113   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1114                           .concat(Discriminator)
1115                           .get(VMContext),
1116                       File.getFileNode(), Scope};
1117   DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1118   assert(
1119       R.Verify() &&
1120       "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1121   return R;
1122 }
1123
1124 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1125                                              unsigned Line, unsigned Col) {
1126   // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1127   // I believe the right way is to have a self-referential element in the node.
1128   // Also: why do we bother with line/column - they're not used and the
1129   // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1130   // for uniquing, yet then we have this other solution (because line/col were
1131   // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1132
1133   // Defeat MDNode uniquing for lexical blocks by using unique id.
1134   static unsigned int unique_id = 0;
1135   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1136                           .concat(Line)
1137                           .concat(Col)
1138                           .concat(unique_id++)
1139                           .get(VMContext),
1140                       File.getFileNode(), getNonCompileUnitScope(Scope)};
1141   DILexicalBlock R(MDNode::get(VMContext, Elts));
1142   assert(R.Verify() &&
1143          "createLexicalBlock should return a verifiable DILexicalBlock");
1144   return R;
1145 }
1146
1147 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
1148   assert(V && "no value passed to dbg intrinsic");
1149   return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
1150 }
1151
1152 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1153                                       DIExpression Expr,
1154                                       Instruction *InsertBefore) {
1155   assert(VarInfo.isVariable() &&
1156          "empty or invalid DIVariable passed to dbg.declare");
1157   if (!DeclareFn)
1158     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1159
1160   trackIfUnresolved(VarInfo);
1161   trackIfUnresolved(Expr);
1162   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1163                    MetadataAsValue::get(VMContext, VarInfo),
1164                    MetadataAsValue::get(VMContext, Expr)};
1165   return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1166 }
1167
1168 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1169                                       DIExpression Expr,
1170                                       BasicBlock *InsertAtEnd) {
1171   assert(VarInfo.isVariable() &&
1172          "empty or invalid DIVariable passed to dbg.declare");
1173   if (!DeclareFn)
1174     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1175
1176   trackIfUnresolved(VarInfo);
1177   trackIfUnresolved(Expr);
1178   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1179                    MetadataAsValue::get(VMContext, VarInfo),
1180                    MetadataAsValue::get(VMContext, Expr)};
1181
1182   // If this block already has a terminator then insert this intrinsic
1183   // before the terminator.
1184   if (TerminatorInst *T = InsertAtEnd->getTerminator())
1185     return CallInst::Create(DeclareFn, Args, "", T);
1186   else
1187     return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1188 }
1189
1190 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1191                                                 DIVariable VarInfo,
1192                                                 DIExpression Expr,
1193                                                 Instruction *InsertBefore) {
1194   assert(V && "no value passed to dbg.value");
1195   assert(VarInfo.isVariable() &&
1196          "empty or invalid DIVariable passed to dbg.value");
1197   if (!ValueFn)
1198     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1199
1200   trackIfUnresolved(VarInfo);
1201   trackIfUnresolved(Expr);
1202   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1203                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1204                    MetadataAsValue::get(VMContext, VarInfo),
1205                    MetadataAsValue::get(VMContext, Expr)};
1206   return CallInst::Create(ValueFn, Args, "", InsertBefore);
1207 }
1208
1209 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1210                                                 DIVariable VarInfo,
1211                                                 DIExpression Expr,
1212                                                 BasicBlock *InsertAtEnd) {
1213   assert(V && "no value passed to dbg.value");
1214   assert(VarInfo.isVariable() &&
1215          "empty or invalid DIVariable passed to dbg.value");
1216   if (!ValueFn)
1217     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1218
1219   trackIfUnresolved(VarInfo);
1220   trackIfUnresolved(Expr);
1221   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1222                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1223                    MetadataAsValue::get(VMContext, VarInfo),
1224                    MetadataAsValue::get(VMContext, Expr)};
1225   return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1226 }
1227
1228 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
1229   T.setContainingType(VTableHolder);
1230
1231   // If this didn't create a self-reference, just return.
1232   if (T != VTableHolder)
1233     return;
1234
1235   // Look for unresolved operands.  T will drop RAUW support, orphaning any
1236   // cycles underneath it.
1237   if (T->isResolved())
1238     for (const MDOperand &O : T->operands())
1239       if (auto *N = dyn_cast_or_null<MDNode>(O))
1240         trackIfUnresolved(N);
1241 }
1242
1243 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
1244                               DIArray TParams) {
1245   T.setArrays(Elements, TParams);
1246
1247   // If T isn't resolved, there's no problem.
1248   if (!T->isResolved())
1249     return;
1250
1251   // If "T" is resolved, it may be due to a self-reference cycle.  Track the
1252   // arrays explicitly if they're unresolved, or else the cycles will be
1253   // orphaned.
1254   if (Elements)
1255     trackIfUnresolved(Elements);
1256   if (TParams)
1257     trackIfUnresolved(TParams);
1258 }