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