lib/IR/DIBuilder.cpp

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