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