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                                                       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
 410 DIBuilder::createStaticMemberType(DIDescriptor Scope, StringRef Name,
 411                                   DIFile File, unsigned LineNumber,
 412                                   DIType Ty, unsigned Flags,
 413                                   llvm::Value *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, Value *Val,
 493                                         MDNode *File, unsigned LineNo,
 494                                         unsigned ColumnNo) {
 495   return createTemplateValueParameterHelper(
 496       VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty, Val,
 497       File, LineNo, 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 createTemplateValueParameterHelper(
 506       VMContext, 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 createTemplateValueParameterHelper(
 516       VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
 517       Val, File, LineNo, 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 }