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) {
 509   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_template_type_parameter)
 510                           .concat(Name)
 511                           .concat(0)
 512                           .concat(0)
 513                           .get(VMContext),
 514                       DIScope(getNonCompileUnitScope(Context)).getRef(),
 515                       Ty.getRef(), nullptr};
 516   return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
 517 }
 518
 519 static DITemplateValueParameter
 520 createTemplateValueParameterHelper(LLVMContext &VMContext, unsigned Tag,
 521                                    DIDescriptor Context, StringRef Name,
 522                                    DIType Ty, Metadata *MD) {
 523   Metadata *Elts[] = {
 524       HeaderBuilder::get(Tag).concat(Name).concat(0).concat(0).get(VMContext),
 525       DIScope(getNonCompileUnitScope(Context)).getRef(), Ty.getRef(), MD,
 526       nullptr};
 527   return DITemplateValueParameter(MDNode::get(VMContext, Elts));
 528 }
 529
 530 DITemplateValueParameter
 531 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
 532                                         DIType Ty, Constant *Val) {
 533   return createTemplateValueParameterHelper(
 534       VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
 535       getConstantOrNull(Val));
 536 }
 537
 538 DITemplateValueParameter
 539 DIBuilder::createTemplateTemplateParameter(DIDescriptor Context, StringRef Name,
 540                                            DIType Ty, StringRef Val) {
 541   return createTemplateValueParameterHelper(
 542       VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
 543       MDString::get(VMContext, Val));
 544 }
 545
 546 DITemplateValueParameter
 547 DIBuilder::createTemplateParameterPack(DIDescriptor Context, StringRef Name,
 548                                        DIType Ty, DIArray Val) {
 549   return createTemplateValueParameterHelper(
 550       VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
 551       Val);
 552 }
 553
 554 DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
 555                                            DIFile File, unsigned LineNumber,
 556                                            uint64_t SizeInBits,
 557                                            uint64_t AlignInBits,
 558                                            uint64_t OffsetInBits,
 559                                            unsigned Flags, DIType DerivedFrom,
 560                                            DIArray Elements,
 561                                            DIType VTableHolder,
 562                                            MDNode *TemplateParams,
 563                                            StringRef UniqueIdentifier) {
 564   assert((!Context || Context.isScope() || Context.isType()) &&
 565          "createClassType should be called with a valid Context");
 566   // TAG_class_type is encoded in DICompositeType format.
 567   Metadata *Elts[] = {
 568       HeaderBuilder::get(dwarf::DW_TAG_class_type)
 569           .concat(Name)
 570           .concat(LineNumber)
 571           .concat(SizeInBits)
 572           .concat(AlignInBits)
 573           .concat(OffsetInBits)
 574           .concat(Flags)
 575           .concat(0)
 576           .get(VMContext),
 577       File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
 578       DerivedFrom.getRef(), Elements, VTableHolder.getRef(), TemplateParams,
 579       UniqueIdentifier.empty() ? nullptr
 580                                : MDString::get(VMContext, UniqueIdentifier)};
 581   DICompositeType R(MDNode::get(VMContext, Elts));
 582   assert(R.isCompositeType() &&
 583          "createClassType should return a DICompositeType");
 584   if (!UniqueIdentifier.empty())
 585     retainType(R);
 586   return R;
 587 }
 588
 589 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
 590                                             StringRef Name, DIFile File,
 591                                             unsigned LineNumber,
 592                                             uint64_t SizeInBits,
 593                                             uint64_t AlignInBits,
 594                                             unsigned Flags, DIType DerivedFrom,
 595                                             DIArray Elements,
 596                                             unsigned RunTimeLang,
 597                                             DIType VTableHolder,
 598                                             StringRef UniqueIdentifier) {
 599  // TAG_structure_type is encoded in DICompositeType format.
 600   Metadata *Elts[] = {
 601       HeaderBuilder::get(dwarf::DW_TAG_structure_type)
 602           .concat(Name)
 603           .concat(LineNumber)
 604           .concat(SizeInBits)
 605           .concat(AlignInBits)
 606           .concat(0)
 607           .concat(Flags)
 608           .concat(RunTimeLang)
 609           .get(VMContext),
 610       File.getFileNode(), DIScope(getNonCompileUnitScope(Context)).getRef(),
 611       DerivedFrom.getRef(), Elements, VTableHolder.getRef(), nullptr,
 612       UniqueIdentifier.empty() ? nullptr
 613                                : MDString::get(VMContext, UniqueIdentifier)};
 614   DICompositeType R(MDNode::get(VMContext, Elts));
 615   assert(R.isCompositeType() &&
 616          "createStructType should return a DICompositeType");
 617   if (!UniqueIdentifier.empty())
 618     retainType(R);
 619   return R;
 620 }
 621
 622 DICompositeType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
 623                                            DIFile File, unsigned LineNumber,
 624                                            uint64_t SizeInBits,
 625                                            uint64_t AlignInBits, unsigned Flags,
 626                                            DIArray Elements,
 627                                            unsigned RunTimeLang,
 628                                            StringRef UniqueIdentifier) {
 629   // TAG_union_type is encoded in DICompositeType format.
 630   Metadata *Elts[] = {
 631       HeaderBuilder::get(dwarf::DW_TAG_union_type)
 632           .concat(Name)
 633           .concat(LineNumber)
 634           .concat(SizeInBits)
 635           .concat(AlignInBits)
 636           .concat(0) // Offset
 637           .concat(Flags)
 638           .concat(RunTimeLang)
 639           .get(VMContext),
 640       File.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(),
 641       nullptr, Elements, nullptr, nullptr,
 642       UniqueIdentifier.empty() ? nullptr
 643                                : MDString::get(VMContext, UniqueIdentifier)};
 644   DICompositeType R(MDNode::get(VMContext, Elts));
 645   if (!UniqueIdentifier.empty())
 646     retainType(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   return CTy;
 694 }
 695
 696 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
 697                                            DIType Ty, DIArray Subscripts) {
 698   // TAG_array_type is encoded in DICompositeType format.
 699   Metadata *Elts[] = {
 700       HeaderBuilder::get(dwarf::DW_TAG_array_type)
 701           .concat(StringRef())
 702           .concat(0) // Line
 703           .concat(Size)
 704           .concat(AlignInBits)
 705           .concat(0) // Offset
 706           .concat(0) // Flags
 707           .concat(0)
 708           .get(VMContext),
 709       nullptr, // Filename/Directory,
 710       nullptr, // Unused
 711       Ty.getRef(), Subscripts, nullptr, nullptr,
 712       nullptr // Type Identifer
 713   };
 714   return DICompositeType(MDNode::get(VMContext, Elts));
 715 }
 716
 717 DICompositeType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
 718                                             DIType Ty, DIArray Subscripts) {
 719   // A vector is an array type with the FlagVector flag applied.
 720   Metadata *Elts[] = {
 721       HeaderBuilder::get(dwarf::DW_TAG_array_type)
 722           .concat("")
 723           .concat(0) // Line
 724           .concat(Size)
 725           .concat(AlignInBits)
 726           .concat(0) // Offset
 727           .concat(DIType::FlagVector)
 728           .concat(0)
 729           .get(VMContext),
 730       nullptr, // Filename/Directory,
 731       nullptr, // Unused
 732       Ty.getRef(), Subscripts, nullptr, nullptr,
 733       nullptr // Type Identifer
 734   };
 735   return DICompositeType(MDNode::get(VMContext, Elts));
 736 }
 737
 738 static HeaderBuilder setTypeFlagsInHeader(StringRef Header,
 739                                           unsigned FlagsToSet) {
 740   DIHeaderFieldIterator I(Header);
 741   std::advance(I, 6);
 742
 743   unsigned Flags;
 744   if (I->getAsInteger(0, Flags))
 745     Flags = 0;
 746   Flags |= FlagsToSet;
 747
 748   return HeaderBuilder()
 749       .concat(I.getPrefix())
 750       .concat(Flags)
 751       .concat(I.getSuffix());
 752 }
 753
 754 static DIType createTypeWithFlags(LLVMContext &Context, DIType Ty,
 755                                   unsigned FlagsToSet) {
 756   SmallVector<Metadata *, 9> Elts;
 757   MDNode *N = Ty;
 758   assert(N && "Unexpected input DIType!");
 759   // Update header field.
 760   Elts.push_back(setTypeFlagsInHeader(Ty.getHeader(), FlagsToSet).get(Context));
 761   for (unsigned I = 1, E = N->getNumOperands(); I != E; ++I)
 762     Elts.push_back(N->getOperand(I));
 763
 764   return DIType(MDNode::get(Context, Elts));
 765 }
 766
 767 DIType DIBuilder::createArtificialType(DIType Ty) {
 768   if (Ty.isArtificial())
 769     return Ty;
 770   return createTypeWithFlags(VMContext, Ty, DIType::FlagArtificial);
 771 }
 772
 773 DIType DIBuilder::createObjectPointerType(DIType Ty) {
 774   if (Ty.isObjectPointer())
 775     return Ty;
 776   unsigned Flags = DIType::FlagObjectPointer | DIType::FlagArtificial;
 777   return createTypeWithFlags(VMContext, Ty, Flags);
 778 }
 779
 780 void DIBuilder::retainType(DIType T) { AllRetainTypes.emplace_back(T); }
 781
 782 DIBasicType DIBuilder::createUnspecifiedParameter() {
 783   return DIBasicType();
 784 }
 785
 786 DICompositeType
 787 DIBuilder::createForwardDecl(unsigned Tag, StringRef Name, DIDescriptor Scope,
 788                              DIFile F, unsigned Line, unsigned RuntimeLang,
 789                              uint64_t SizeInBits, uint64_t AlignInBits,
 790                              StringRef UniqueIdentifier) {
 791   // Create a temporary MDNode.
 792   Metadata *Elts[] = {
 793       HeaderBuilder::get(Tag)
 794           .concat(Name)
 795           .concat(Line)
 796           .concat(SizeInBits)
 797           .concat(AlignInBits)
 798           .concat(0) // Offset
 799           .concat(DIDescriptor::FlagFwdDecl)
 800           .concat(RuntimeLang)
 801           .get(VMContext),
 802       F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
 803       DIArray(), nullptr,
 804       nullptr, // TemplateParams
 805       UniqueIdentifier.empty() ? nullptr
 806                                : MDString::get(VMContext, UniqueIdentifier)};
 807   MDNode *Node = MDNode::get(VMContext, Elts);
 808   DICompositeType RetTy(Node);
 809   assert(RetTy.isCompositeType() &&
 810          "createForwardDecl result should be a DIType");
 811   if (!UniqueIdentifier.empty())
 812     retainType(RetTy);
 813   return RetTy;
 814 }
 815
 816 DICompositeType DIBuilder::createReplaceableCompositeType(
 817     unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
 818     unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
 819     unsigned Flags, StringRef UniqueIdentifier) {
 820   // Create a temporary MDNode.
 821   Metadata *Elts[] = {
 822       HeaderBuilder::get(Tag)
 823           .concat(Name)
 824           .concat(Line)
 825           .concat(SizeInBits)
 826           .concat(AlignInBits)
 827           .concat(0) // Offset
 828           .concat(Flags)
 829           .concat(RuntimeLang)
 830           .get(VMContext),
 831       F.getFileNode(), DIScope(getNonCompileUnitScope(Scope)).getRef(), nullptr,
 832       DIArray(), nullptr,
 833       nullptr, // TemplateParams
 834       UniqueIdentifier.empty() ? nullptr
 835                                : MDString::get(VMContext, UniqueIdentifier)};
 836   DICompositeType RetTy(MDNode::getTemporary(VMContext, Elts).release());
 837   assert(RetTy.isCompositeType() &&
 838          "createReplaceableForwardDecl result should be a DIType");
 839   if (!UniqueIdentifier.empty())
 840     retainType(RetTy);
 841   return RetTy;
 842 }
 843
 844 DIArray DIBuilder::getOrCreateArray(ArrayRef<Metadata *> Elements) {
 845   return DIArray(MDNode::get(VMContext, Elements));
 846 }
 847
 848 DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
 849   SmallVector<llvm::Metadata *, 16> Elts;
 850   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
 851     if (Elements[i] && isa<MDNode>(Elements[i]))
 852       Elts.push_back(DIType(cast<MDNode>(Elements[i])).getRef());
 853     else
 854       Elts.push_back(Elements[i]);
 855   }
 856   return DITypeArray(MDNode::get(VMContext, Elts));
 857 }
 858
 859 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
 860   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subrange_type)
 861                           .concat(Lo)
 862                           .concat(Count)
 863                           .get(VMContext)};
 864
 865   return DISubrange(MDNode::get(VMContext, Elts));
 866 }
 867
 868 static DIGlobalVariable createGlobalVariableHelper(
 869     LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
 870     StringRef LinkageName, DIFile F, unsigned LineNumber, DITypeRef Ty,
 871     bool isLocalToUnit, Constant *Val, MDNode *Decl, bool isDefinition,
 872     std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
 873
 874   MDNode *TheCtx = getNonCompileUnitScope(Context);
 875   if (DIScope(TheCtx).isCompositeType()) {
 876     assert(!DICompositeType(TheCtx).getIdentifier() &&
 877            "Context of a global variable should not be a type with identifier");
 878   }
 879
 880   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_variable)
 881                           .concat(Name)
 882                           .concat(Name)
 883                           .concat(LinkageName)
 884                           .concat(LineNumber)
 885                           .concat(isLocalToUnit)
 886                           .concat(isDefinition)
 887                           .get(VMContext),
 888                       TheCtx, F, Ty, getConstantOrNull(Val),
 889                       DIDescriptor(Decl)};
 890
 891   return DIGlobalVariable(CreateFunc(Elts));
 892 }
 893
 894 DIGlobalVariable DIBuilder::createGlobalVariable(
 895     DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
 896     unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
 897     MDNode *Decl) {
 898   return createGlobalVariableHelper(
 899       VMContext, Context, Name, LinkageName, F, LineNumber, Ty, isLocalToUnit,
 900       Val, Decl, true, [&](ArrayRef<Metadata *> Elts) -> MDNode *{
 901         MDNode *Node = MDNode::get(VMContext, Elts);
 902         AllGVs.push_back(Node);
 903         return Node;
 904       });
 905 }
 906
 907 DIGlobalVariable DIBuilder::createTempGlobalVariableFwdDecl(
 908     DIDescriptor Context, StringRef Name, StringRef LinkageName, DIFile F,
 909     unsigned LineNumber, DITypeRef Ty, bool isLocalToUnit, Constant *Val,
 910     MDNode *Decl) {
 911   return createGlobalVariableHelper(VMContext, Context, Name, LinkageName, F,
 912                                     LineNumber, Ty, isLocalToUnit, Val, Decl,
 913                                     false, [&](ArrayRef<Metadata *> Elts) {
 914     return MDNode::getTemporary(VMContext, Elts).release();
 915   });
 916 }
 917
 918 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
 919                                           StringRef Name, DIFile File,
 920                                           unsigned LineNo, DITypeRef Ty,
 921                                           bool AlwaysPreserve, unsigned Flags,
 922                                           unsigned ArgNo) {
 923   DIDescriptor Context(getNonCompileUnitScope(Scope));
 924   assert((!Context || Context.isScope()) &&
 925          "createLocalVariable should be called with a valid Context");
 926   Metadata *Elts[] = {HeaderBuilder::get(Tag)
 927                           .concat(Name)
 928                           .concat(LineNo | (ArgNo << 24))
 929                           .concat(Flags)
 930                           .get(VMContext),
 931                       getNonCompileUnitScope(Scope), File, Ty};
 932   MDNode *Node = MDNode::get(VMContext, Elts);
 933   if (AlwaysPreserve) {
 934     // The optimizer may remove local variable. If there is an interest
 935     // to preserve variable info in such situation then stash it in a
 936     // named mdnode.
 937     DISubprogram Fn(getDISubprogram(Scope));
 938     assert(Fn && "Missing subprogram for local variable");
 939     PreservedVariables[Fn].emplace_back(Node);
 940   }
 941   DIVariable RetVar(Node);
 942   assert(RetVar.isVariable() &&
 943          "createLocalVariable should return a valid DIVariable");
 944   return RetVar;
 945 }
 946
 947 DIExpression DIBuilder::createExpression(ArrayRef<uint64_t> Addr) {
 948   auto Header = HeaderBuilder::get(DW_TAG_expression);
 949   for (uint64_t I : Addr)
 950     Header.concat(I);
 951   Metadata *Elts[] = {Header.get(VMContext)};
 952   return DIExpression(MDNode::get(VMContext, Elts));
 953 }
 954
 955 DIExpression DIBuilder::createExpression(ArrayRef<int64_t> Signed) {
 956   // TODO: Remove the callers of this signed version and delete.
 957   SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());
 958   return createExpression(Addr);
 959 }
 960
 961 DIExpression DIBuilder::createBitPieceExpression(unsigned OffsetInBits,
 962                                                  unsigned SizeInBits) {
 963   int64_t Addr[] = {dwarf::DW_OP_bit_piece, OffsetInBits, SizeInBits};
 964   return createExpression(Addr);
 965 }
 966
 967 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
 968                                        StringRef LinkageName, DIFile File,
 969                                        unsigned LineNo, DICompositeType Ty,
 970                                        bool isLocalToUnit, bool isDefinition,
 971                                        unsigned ScopeLine, unsigned Flags,
 972                                        bool isOptimized, Function *Fn,
 973                                        MDNode *TParams, MDNode *Decl) {
 974   // dragonegg does not generate identifier for types, so using an empty map
 975   // to resolve the context should be fine.
 976   DITypeIdentifierMap EmptyMap;
 977   return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
 978                         LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
 979                         Flags, isOptimized, Fn, TParams, Decl);
 980 }
 981
 982 static DISubprogram createFunctionHelper(
 983     LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
 984     StringRef LinkageName, DIFile File, unsigned LineNo, DICompositeType Ty,
 985     bool isLocalToUnit, bool isDefinition, unsigned ScopeLine, unsigned Flags,
 986     bool isOptimized, Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
 987     std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
 988   assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
 989          "function types should be subroutines");
 990   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
 991                           .concat(Name)
 992                           .concat(Name)
 993                           .concat(LinkageName)
 994                           .concat(LineNo)
 995                           .concat(isLocalToUnit)
 996                           .concat(isDefinition)
 997                           .concat(0)
 998                           .concat(0)
 999                           .concat(Flags)
1000                           .concat(isOptimized)
1001                           .concat(ScopeLine)
1002                           .get(VMContext),
1003                       File.getFileNode(),
1004                       DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
1005                       nullptr, getConstantOrNull(Fn), TParams, Decl, Vars};
1006
1007   DISubprogram S(CreateFunc(Elts));
1008   assert(S.isSubprogram() &&
1009          "createFunction should return a valid DISubprogram");
1010   return S;
1011 }
1012
1013
1014 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
1015                                        StringRef LinkageName, DIFile File,
1016                                        unsigned LineNo, DICompositeType Ty,
1017                                        bool isLocalToUnit, bool isDefinition,
1018                                        unsigned ScopeLine, unsigned Flags,
1019                                        bool isOptimized, Function *Fn,
1020                                        MDNode *TParams, MDNode *Decl) {
1021   return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1022                               LineNo, Ty, isLocalToUnit, isDefinition,
1023                               ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1024                               MDNode::getTemporary(VMContext, None).release(),
1025                               [&](ArrayRef<Metadata *> Elts) -> MDNode *{
1026     MDNode *Node = MDNode::get(VMContext, Elts);
1027     // Create a named metadata so that we
1028     // do not lose this mdnode.
1029     if (isDefinition)
1030       AllSubprograms.push_back(Node);
1031     return Node;
1032   });
1033 }
1034
1035 DISubprogram
1036 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1037                                      StringRef LinkageName, DIFile File,
1038                                      unsigned LineNo, DICompositeType Ty,
1039                                      bool isLocalToUnit, bool isDefinition,
1040                                      unsigned ScopeLine, unsigned Flags,
1041                                      bool isOptimized, Function *Fn,
1042                                      MDNode *TParams, MDNode *Decl) {
1043   return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1044                               LineNo, Ty, isLocalToUnit, isDefinition,
1045                               ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1046                               nullptr, [&](ArrayRef<Metadata *> Elts) {
1047     return MDNode::getTemporary(VMContext, Elts).release();
1048   });
1049 }
1050
1051 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1052                                      StringRef LinkageName, DIFile F,
1053                                      unsigned LineNo, DICompositeType Ty,
1054                                      bool isLocalToUnit, bool isDefinition,
1055                                      unsigned VK, unsigned VIndex,
1056                                      DIType VTableHolder, unsigned Flags,
1057                                      bool isOptimized, Function *Fn,
1058                                      MDNode *TParam) {
1059   assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1060          "function types should be subroutines");
1061   assert(getNonCompileUnitScope(Context) &&
1062          "Methods should have both a Context and a context that isn't "
1063          "the compile unit.");
1064   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1065                           .concat(Name)
1066                           .concat(Name)
1067                           .concat(LinkageName)
1068                           .concat(LineNo)
1069                           .concat(isLocalToUnit)
1070                           .concat(isDefinition)
1071                           .concat(VK)
1072                           .concat(VIndex)
1073                           .concat(Flags)
1074                           .concat(isOptimized)
1075                           .concat(LineNo)
1076                           // FIXME: Do we want to use different scope/lines?
1077                           .get(VMContext),
1078                       F.getFileNode(), DIScope(Context).getRef(), Ty,
1079                       VTableHolder.getRef(), getConstantOrNull(Fn), TParam,
1080                       nullptr, nullptr};
1081   MDNode *Node = MDNode::get(VMContext, Elts);
1082   if (isDefinition)
1083     AllSubprograms.push_back(Node);
1084   DISubprogram S(Node);
1085   assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1086   return S;
1087 }
1088
1089 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1090                                        DIFile File, unsigned LineNo) {
1091   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1092                           .concat(Name)
1093                           .concat(LineNo)
1094                           .get(VMContext),
1095                       File.getFileNode(), getNonCompileUnitScope(Scope)};
1096   DINameSpace R(MDNode::get(VMContext, Elts));
1097   assert(R.Verify() &&
1098          "createNameSpace should return a verifiable DINameSpace");
1099   return R;
1100 }
1101
1102 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1103                                                      DIFile File,
1104                                                      unsigned Discriminator) {
1105   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1106                           .concat(Discriminator)
1107                           .get(VMContext),
1108                       File.getFileNode(), Scope};
1109   DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1110   assert(
1111       R.Verify() &&
1112       "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1113   return R;
1114 }
1115
1116 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1117                                              unsigned Line, unsigned Col) {
1118   // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1119   // I believe the right way is to have a self-referential element in the node.
1120   // Also: why do we bother with line/column - they're not used and the
1121   // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1122   // for uniquing, yet then we have this other solution (because line/col were
1123   // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1124
1125   // Defeat MDNode uniquing for lexical blocks by using unique id.
1126   static unsigned int unique_id = 0;
1127   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1128                           .concat(Line)
1129                           .concat(Col)
1130                           .concat(unique_id++)
1131                           .get(VMContext),
1132                       File.getFileNode(), getNonCompileUnitScope(Scope)};
1133   DILexicalBlock R(MDNode::get(VMContext, Elts));
1134   assert(R.Verify() &&
1135          "createLexicalBlock should return a verifiable DILexicalBlock");
1136   return R;
1137 }
1138
1139 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
1140   assert(V && "no value passed to dbg intrinsic");
1141   return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
1142 }
1143
1144 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1145                                       DIExpression Expr,
1146                                       Instruction *InsertBefore) {
1147   assert(VarInfo.isVariable() &&
1148          "empty or invalid DIVariable passed to dbg.declare");
1149   if (!DeclareFn)
1150     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1151
1152   trackIfUnresolved(VarInfo);
1153   trackIfUnresolved(Expr);
1154   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1155                    MetadataAsValue::get(VMContext, VarInfo),
1156                    MetadataAsValue::get(VMContext, Expr)};
1157   return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1158 }
1159
1160 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1161                                       DIExpression Expr,
1162                                       BasicBlock *InsertAtEnd) {
1163   assert(VarInfo.isVariable() &&
1164          "empty or invalid DIVariable passed to dbg.declare");
1165   if (!DeclareFn)
1166     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1167
1168   trackIfUnresolved(VarInfo);
1169   trackIfUnresolved(Expr);
1170   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1171                    MetadataAsValue::get(VMContext, VarInfo),
1172                    MetadataAsValue::get(VMContext, Expr)};
1173
1174   // If this block already has a terminator then insert this intrinsic
1175   // before the terminator.
1176   if (TerminatorInst *T = InsertAtEnd->getTerminator())
1177     return CallInst::Create(DeclareFn, Args, "", T);
1178   else
1179     return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1180 }
1181
1182 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1183                                                 DIVariable VarInfo,
1184                                                 DIExpression Expr,
1185                                                 Instruction *InsertBefore) {
1186   assert(V && "no value passed to dbg.value");
1187   assert(VarInfo.isVariable() &&
1188          "empty or invalid DIVariable passed to dbg.value");
1189   if (!ValueFn)
1190     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1191
1192   trackIfUnresolved(VarInfo);
1193   trackIfUnresolved(Expr);
1194   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1195                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1196                    MetadataAsValue::get(VMContext, VarInfo),
1197                    MetadataAsValue::get(VMContext, Expr)};
1198   return CallInst::Create(ValueFn, Args, "", InsertBefore);
1199 }
1200
1201 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1202                                                 DIVariable VarInfo,
1203                                                 DIExpression Expr,
1204                                                 BasicBlock *InsertAtEnd) {
1205   assert(V && "no value passed to dbg.value");
1206   assert(VarInfo.isVariable() &&
1207          "empty or invalid DIVariable passed to dbg.value");
1208   if (!ValueFn)
1209     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1210
1211   trackIfUnresolved(VarInfo);
1212   trackIfUnresolved(Expr);
1213   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1214                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1215                    MetadataAsValue::get(VMContext, VarInfo),
1216                    MetadataAsValue::get(VMContext, Expr)};
1217   return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1218 }
1219
1220 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
1221   T.setContainingType(VTableHolder);
1222
1223   // If this didn't create a self-reference, just return.
1224   if (T != VTableHolder)
1225     return;
1226
1227   // Look for unresolved operands.  T will drop RAUW support, orphaning any
1228   // cycles underneath it.
1229   if (T->isResolved())
1230     for (const MDOperand &O : T->operands())
1231       if (auto *N = dyn_cast_or_null<MDNode>(O))
1232         trackIfUnresolved(N);
1233 }
1234
1235 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
1236                               DIArray TParams) {
1237   T.setArrays(Elements, TParams);
1238
1239   // If T isn't resolved, there's no problem.
1240   if (!T->isResolved())
1241     return;
1242
1243   // If "T" is resolved, it may be due to a self-reference cycle.  Track the
1244   // arrays explicitly if they're unresolved, or else the cycles will be
1245   // orphaned.
1246   if (Elements)
1247     trackIfUnresolved(Elements);
1248   if (TParams)
1249     trackIfUnresolved(TParams);
1250 }