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