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