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