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