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