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_OCaml && 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::createReplaceableForwardDecl(
 820     unsigned Tag, StringRef Name, DIDescriptor Scope, DIFile F, unsigned Line,
 821     unsigned RuntimeLang, uint64_t SizeInBits, uint64_t AlignInBits,
 822     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(DIDescriptor::FlagFwdDecl)
 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<int64_t> Addr) {
 951   auto Header = HeaderBuilder::get(DW_TAG_expression);
 952   for (int64_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::createPieceExpression(unsigned OffsetInBytes,
 959                                               unsigned SizeInBytes) {
 960   int64_t Addr[] = {dwarf::DW_OP_piece, OffsetInBytes, SizeInBytes};
 961   return createExpression(Addr);
 962 }
 963
 964 DISubprogram DIBuilder::createFunction(DIScopeRef Context, StringRef Name,
 965                                        StringRef LinkageName, DIFile File,
 966                                        unsigned LineNo, DICompositeType Ty,
 967                                        bool isLocalToUnit, bool isDefinition,
 968                                        unsigned ScopeLine, unsigned Flags,
 969                                        bool isOptimized, Function *Fn,
 970                                        MDNode *TParams, MDNode *Decl) {
 971   // dragonegg does not generate identifier for types, so using an empty map
 972   // to resolve the context should be fine.
 973   DITypeIdentifierMap EmptyMap;
 974   return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
 975                         LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
 976                         Flags, isOptimized, Fn, TParams, Decl);
 977 }
 978
 979 static DISubprogram createFunctionHelper(
 980     LLVMContext &VMContext, DIDescriptor Context, StringRef Name,
 981     StringRef LinkageName, DIFile File, unsigned LineNo, DICompositeType Ty,
 982     bool isLocalToUnit, bool isDefinition, unsigned ScopeLine, unsigned Flags,
 983     bool isOptimized, Function *Fn, MDNode *TParams, MDNode *Decl, MDNode *Vars,
 984     std::function<MDNode *(ArrayRef<Metadata *>)> CreateFunc) {
 985   assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
 986          "function types should be subroutines");
 987   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
 988                           .concat(Name)
 989                           .concat(Name)
 990                           .concat(LinkageName)
 991                           .concat(LineNo)
 992                           .concat(isLocalToUnit)
 993                           .concat(isDefinition)
 994                           .concat(0)
 995                           .concat(0)
 996                           .concat(Flags)
 997                           .concat(isOptimized)
 998                           .concat(ScopeLine)
 999                           .get(VMContext),
1000                       File.getFileNode(),
1001                       DIScope(getNonCompileUnitScope(Context)).getRef(), Ty,
1002                       nullptr, getConstantOrNull(Fn), TParams, Decl, Vars};
1003
1004   DISubprogram S(CreateFunc(Elts));
1005   assert(S.isSubprogram() &&
1006          "createFunction should return a valid DISubprogram");
1007   return S;
1008 }
1009
1010
1011 DISubprogram DIBuilder::createFunction(DIDescriptor Context, StringRef Name,
1012                                        StringRef LinkageName, DIFile File,
1013                                        unsigned LineNo, DICompositeType Ty,
1014                                        bool isLocalToUnit, bool isDefinition,
1015                                        unsigned ScopeLine, unsigned Flags,
1016                                        bool isOptimized, Function *Fn,
1017                                        MDNode *TParams, MDNode *Decl) {
1018   return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1019                               LineNo, Ty, isLocalToUnit, isDefinition,
1020                               ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1021                               MDNode::getTemporary(VMContext, None).release(),
1022                               [&](ArrayRef<Metadata *> Elts) -> MDNode *{
1023     MDNode *Node = MDNode::get(VMContext, Elts);
1024     // Create a named metadata so that we
1025     // do not lose this mdnode.
1026     if (isDefinition)
1027       AllSubprograms.push_back(Node);
1028     return Node;
1029   });
1030 }
1031
1032 DISubprogram
1033 DIBuilder::createTempFunctionFwdDecl(DIDescriptor Context, StringRef Name,
1034                                      StringRef LinkageName, DIFile File,
1035                                      unsigned LineNo, DICompositeType Ty,
1036                                      bool isLocalToUnit, bool isDefinition,
1037                                      unsigned ScopeLine, unsigned Flags,
1038                                      bool isOptimized, Function *Fn,
1039                                      MDNode *TParams, MDNode *Decl) {
1040   return createFunctionHelper(VMContext, Context, Name, LinkageName, File,
1041                               LineNo, Ty, isLocalToUnit, isDefinition,
1042                               ScopeLine, Flags, isOptimized, Fn, TParams, Decl,
1043                               nullptr, [&](ArrayRef<Metadata *> Elts) {
1044     return MDNode::getTemporary(VMContext, Elts).release();
1045   });
1046 }
1047
1048 DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
1049                                      StringRef LinkageName, DIFile F,
1050                                      unsigned LineNo, DICompositeType Ty,
1051                                      bool isLocalToUnit, bool isDefinition,
1052                                      unsigned VK, unsigned VIndex,
1053                                      DIType VTableHolder, unsigned Flags,
1054                                      bool isOptimized, Function *Fn,
1055                                      MDNode *TParam) {
1056   assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1057          "function types should be subroutines");
1058   assert(getNonCompileUnitScope(Context) &&
1059          "Methods should have both a Context and a context that isn't "
1060          "the compile unit.");
1061   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_subprogram)
1062                           .concat(Name)
1063                           .concat(Name)
1064                           .concat(LinkageName)
1065                           .concat(LineNo)
1066                           .concat(isLocalToUnit)
1067                           .concat(isDefinition)
1068                           .concat(VK)
1069                           .concat(VIndex)
1070                           .concat(Flags)
1071                           .concat(isOptimized)
1072                           .concat(LineNo)
1073                           // FIXME: Do we want to use different scope/lines?
1074                           .get(VMContext),
1075                       F.getFileNode(), DIScope(Context).getRef(), Ty,
1076                       VTableHolder.getRef(), getConstantOrNull(Fn), TParam,
1077                       nullptr, nullptr};
1078   MDNode *Node = MDNode::get(VMContext, Elts);
1079   if (isDefinition)
1080     AllSubprograms.push_back(Node);
1081   DISubprogram S(Node);
1082   assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1083   return S;
1084 }
1085
1086 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1087                                        DIFile File, unsigned LineNo) {
1088   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_namespace)
1089                           .concat(Name)
1090                           .concat(LineNo)
1091                           .get(VMContext),
1092                       File.getFileNode(), getNonCompileUnitScope(Scope)};
1093   DINameSpace R(MDNode::get(VMContext, Elts));
1094   assert(R.Verify() &&
1095          "createNameSpace should return a verifiable DINameSpace");
1096   return R;
1097 }
1098
1099 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1100                                                      DIFile File,
1101                                                      unsigned Discriminator) {
1102   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1103                           .concat(Discriminator)
1104                           .get(VMContext),
1105                       File.getFileNode(), Scope};
1106   DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1107   assert(
1108       R.Verify() &&
1109       "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1110   return R;
1111 }
1112
1113 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1114                                              unsigned Line, unsigned Col) {
1115   // FIXME: This isn't thread safe nor the right way to defeat MDNode uniquing.
1116   // I believe the right way is to have a self-referential element in the node.
1117   // Also: why do we bother with line/column - they're not used and the
1118   // documentation (SourceLevelDebugging.rst) claims the line/col are necessary
1119   // for uniquing, yet then we have this other solution (because line/col were
1120   // inadequate) anyway. Remove all 3 and replace them with a self-reference.
1121
1122   // Defeat MDNode uniquing for lexical blocks by using unique id.
1123   static unsigned int unique_id = 0;
1124   Metadata *Elts[] = {HeaderBuilder::get(dwarf::DW_TAG_lexical_block)
1125                           .concat(Line)
1126                           .concat(Col)
1127                           .concat(unique_id++)
1128                           .get(VMContext),
1129                       File.getFileNode(), getNonCompileUnitScope(Scope)};
1130   DILexicalBlock R(MDNode::get(VMContext, Elts));
1131   assert(R.Verify() &&
1132          "createLexicalBlock should return a verifiable DILexicalBlock");
1133   return R;
1134 }
1135
1136 static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
1137   assert(V && "no value passed to dbg intrinsic");
1138   return MetadataAsValue::get(VMContext, ValueAsMetadata::get(V));
1139 }
1140
1141 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1142                                       DIExpression Expr,
1143                                       Instruction *InsertBefore) {
1144   assert(VarInfo.isVariable() &&
1145          "empty or invalid DIVariable passed to dbg.declare");
1146   if (!DeclareFn)
1147     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1148
1149   trackIfUnresolved(VarInfo);
1150   trackIfUnresolved(Expr);
1151   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1152                    MetadataAsValue::get(VMContext, VarInfo),
1153                    MetadataAsValue::get(VMContext, Expr)};
1154   return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1155 }
1156
1157 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1158                                       DIExpression Expr,
1159                                       BasicBlock *InsertAtEnd) {
1160   assert(VarInfo.isVariable() &&
1161          "empty or invalid DIVariable passed to dbg.declare");
1162   if (!DeclareFn)
1163     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1164
1165   trackIfUnresolved(VarInfo);
1166   trackIfUnresolved(Expr);
1167   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, Storage),
1168                    MetadataAsValue::get(VMContext, VarInfo),
1169                    MetadataAsValue::get(VMContext, Expr)};
1170
1171   // If this block already has a terminator then insert this intrinsic
1172   // before the terminator.
1173   if (TerminatorInst *T = InsertAtEnd->getTerminator())
1174     return CallInst::Create(DeclareFn, Args, "", T);
1175   else
1176     return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1177 }
1178
1179 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1180                                                 DIVariable VarInfo,
1181                                                 DIExpression Expr,
1182                                                 Instruction *InsertBefore) {
1183   assert(V && "no value passed to dbg.value");
1184   assert(VarInfo.isVariable() &&
1185          "empty or invalid DIVariable passed to dbg.value");
1186   if (!ValueFn)
1187     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1188
1189   trackIfUnresolved(VarInfo);
1190   trackIfUnresolved(Expr);
1191   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1192                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1193                    MetadataAsValue::get(VMContext, VarInfo),
1194                    MetadataAsValue::get(VMContext, Expr)};
1195   return CallInst::Create(ValueFn, Args, "", InsertBefore);
1196 }
1197
1198 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1199                                                 DIVariable VarInfo,
1200                                                 DIExpression Expr,
1201                                                 BasicBlock *InsertAtEnd) {
1202   assert(V && "no value passed to dbg.value");
1203   assert(VarInfo.isVariable() &&
1204          "empty or invalid DIVariable passed to dbg.value");
1205   if (!ValueFn)
1206     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1207
1208   trackIfUnresolved(VarInfo);
1209   trackIfUnresolved(Expr);
1210   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
1211                    ConstantInt::get(Type::getInt64Ty(VMContext), Offset),
1212                    MetadataAsValue::get(VMContext, VarInfo),
1213                    MetadataAsValue::get(VMContext, Expr)};
1214   return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1215 }
1216
1217 void DIBuilder::replaceVTableHolder(DICompositeType &T, DICompositeType VTableHolder) {
1218   T.setContainingType(VTableHolder);
1219
1220   // If this didn't create a self-reference, just return.
1221   if (T != VTableHolder)
1222     return;
1223
1224   // Look for unresolved operands.  T has dropped RAUW support and is already
1225   // marked resolved, orphaning any cycles underneath it.
1226   assert(T->isResolved() && "Expected self-reference to be resolved");
1227   for (const MDOperand &O : T->operands())
1228     if (auto *N = dyn_cast_or_null<MDNode>(O))
1229       trackIfUnresolved(N);
1230 }
1231
1232 void DIBuilder::replaceArrays(DICompositeType &T, DIArray Elements,
1233                               DIArray TParams) {
1234   T.setArrays(Elements, TParams);
1235
1236   // If T isn't resolved, there's no problem.
1237   if (!T->isResolved())
1238     return;
1239
1240   // If "T" is resolved, it may be due to a self-reference cycle.  Track the
1241   // arrays explicitly if they're unresolved, or else the cycles will be
1242   // orphaned.
1243   if (Elements)
1244     trackIfUnresolved(Elements);
1245   if (TParams)
1246     trackIfUnresolved(TParams);
1247 }