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   DIType RetTy(Node);
 867   assert(RetTy.isType() &&
 868          "createForwardDecl result should be a DIType");
 869   return RetTy;
 870 }
 871
 872 /// getOrCreateArray - Get a DIArray, create one if required.
 873 DIArray DIBuilder::getOrCreateArray(ArrayRef<Value *> Elements) {
 874   if (Elements.empty()) {
 875     Value *Null = Constant::getNullValue(Type::getInt32Ty(VMContext));
 876     return DIArray(MDNode::get(VMContext, Null));
 877   }
 878   return DIArray(MDNode::get(VMContext, Elements));
 879 }
 880
 881 /// getOrCreateSubrange - Create a descriptor for a value range.  This
 882 /// implicitly uniques the values returned.
 883 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
 884   Value *Elts[] = {
 885     GetTagConstant(VMContext, dwarf::DW_TAG_subrange_type),
 886     ConstantInt::get(Type::getInt64Ty(VMContext), Lo),
 887     ConstantInt::get(Type::getInt64Ty(VMContext), Count)
 888   };
 889
 890   return DISubrange(MDNode::get(VMContext, Elts));
 891 }
 892
 893 /// \brief Create a new descriptor for the specified global.
 894 DIGlobalVariable DIBuilder::
 895 createGlobalVariable(StringRef Name, StringRef LinkageName, DIFile F,
 896                      unsigned LineNumber, DIType Ty, bool isLocalToUnit,
 897                      Value *Val) {
 898   Value *Elts[] = {
 899     GetTagConstant(VMContext, dwarf::DW_TAG_variable),
 900     Constant::getNullValue(Type::getInt32Ty(VMContext)),
 901     NULL, // TheCU,
 902     MDString::get(VMContext, Name),
 903     MDString::get(VMContext, Name),
 904     MDString::get(VMContext, LinkageName),
 905     F,
 906     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 907     Ty,
 908     ConstantInt::get(Type::getInt32Ty(VMContext), isLocalToUnit),
 909     ConstantInt::get(Type::getInt32Ty(VMContext), 1), /* isDefinition*/
 910     Val,
 911     DIDescriptor()
 912   };
 913   MDNode *Node = MDNode::get(VMContext, Elts);
 914   AllGVs.push_back(Node);
 915   return DIGlobalVariable(Node);
 916 }
 917
 918 /// \brief Create a new descriptor for the specified global.
 919 DIGlobalVariable DIBuilder::
 920 createGlobalVariable(StringRef Name, DIFile F, unsigned LineNumber,
 921                      DIType Ty, bool isLocalToUnit, Value *Val) {
 922   return createGlobalVariable(Name, Name, F, LineNumber, Ty, isLocalToUnit,
 923                               Val);
 924 }
 925
 926 /// createStaticVariable - Create a new descriptor for the specified static
 927 /// variable.
 928 DIGlobalVariable DIBuilder::
 929 createStaticVariable(DIDescriptor Context, StringRef Name,
 930                      StringRef LinkageName, DIFile F, unsigned LineNumber,
 931                      DIType Ty, bool isLocalToUnit, Value *Val, MDNode *Decl) {
 932   Value *Elts[] = {
 933     GetTagConstant(VMContext, dwarf::DW_TAG_variable),
 934     Constant::getNullValue(Type::getInt32Ty(VMContext)),
 935     getNonCompileUnitScope(Context),
 936     MDString::get(VMContext, Name),
 937     MDString::get(VMContext, Name),
 938     MDString::get(VMContext, LinkageName),
 939     F,
 940     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 941     Ty,
 942     ConstantInt::get(Type::getInt32Ty(VMContext), isLocalToUnit),
 943     ConstantInt::get(Type::getInt32Ty(VMContext), 1), /* isDefinition*/
 944     Val,
 945     DIDescriptor(Decl)
 946   };
 947   MDNode *Node = MDNode::get(VMContext, Elts);
 948   AllGVs.push_back(Node);
 949   return DIGlobalVariable(Node);
 950 }
 951
 952 /// createVariable - Create a new descriptor for the specified variable.
 953 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
 954                                           StringRef Name, DIFile File,
 955                                           unsigned LineNo, DIType Ty,
 956                                           bool AlwaysPreserve, unsigned Flags,
 957                                           unsigned ArgNo) {
 958   DIDescriptor Context(getNonCompileUnitScope(Scope));
 959   assert((!Context || Context.isScope()) &&
 960          "createLocalVariable should be called with a valid Context");
 961   assert(Ty.isType() &&
 962          "createLocalVariable should be called with a valid type");
 963   Value *Elts[] = {
 964     GetTagConstant(VMContext, Tag),
 965     getNonCompileUnitScope(Scope),
 966     MDString::get(VMContext, Name),
 967     File,
 968     ConstantInt::get(Type::getInt32Ty(VMContext), (LineNo | (ArgNo << 24))),
 969     Ty,
 970     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 971     Constant::getNullValue(Type::getInt32Ty(VMContext))
 972   };
 973   MDNode *Node = MDNode::get(VMContext, Elts);
 974   if (AlwaysPreserve) {
 975     // The optimizer may remove local variable. If there is an interest
 976     // to preserve variable info in such situation then stash it in a
 977     // named mdnode.
 978     DISubprogram Fn(getDISubprogram(Scope));
 979     NamedMDNode *FnLocals = getOrInsertFnSpecificMDNode(M, Fn);
 980     FnLocals->addOperand(Node);
 981   }
 982   DIVariable RetVar(Node);
 983   assert(RetVar.isVariable() &&
 984          "createLocalVariable should return a valid DIVariable");
 985   return RetVar;
 986 }
 987
 988 /// createComplexVariable - Create a new descriptor for the specified variable
 989 /// which has a complex address expression for its address.
 990 DIVariable DIBuilder::createComplexVariable(unsigned Tag, DIDescriptor Scope,
 991                                             StringRef Name, DIFile F,
 992                                             unsigned LineNo,
 993                                             DIType Ty, ArrayRef<Value *> Addr,
 994                                             unsigned ArgNo) {
 995   SmallVector<Value *, 15> Elts;
 996   Elts.push_back(GetTagConstant(VMContext, Tag));
 997   Elts.push_back(getNonCompileUnitScope(Scope)),
 998   Elts.push_back(MDString::get(VMContext, Name));
 999   Elts.push_back(F);
1000   Elts.push_back(ConstantInt::get(Type::getInt32Ty(VMContext),
1001                                   (LineNo | (ArgNo << 24))));
1002   Elts.push_back(Ty);
1003   Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)));
1004   Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)));
1005   Elts.append(Addr.begin(), Addr.end());
1006
1007   return DIVariable(MDNode::get(VMContext, Elts));
1008 }
1009
1010 /// createFunction - Create a new descriptor for the specified function.
1011 DISubprogram DIBuilder::createFunction(DIDescriptor Context,
1012                                        StringRef Name,
1013                                        StringRef LinkageName,
1014                                        DIFile File, unsigned LineNo,
1015                                        DICompositeType Ty,
1016                                        bool isLocalToUnit, bool isDefinition,
1017                                        unsigned ScopeLine,
1018                                        unsigned Flags, bool isOptimized,
1019                                        Function *Fn,
1020                                        MDNode *TParams,
1021                                        MDNode *Decl) {
1022   assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1023          "function types should be subroutines");
1024   Value *TElts[] = { GetTagConstant(VMContext, DW_TAG_base_type) };
1025   Value *Elts[] = {
1026     GetTagConstant(VMContext, dwarf::DW_TAG_subprogram),
1027     File.getFileNode(),
1028     getNonCompileUnitScope(Context),
1029     MDString::get(VMContext, Name),
1030     MDString::get(VMContext, Name),
1031     MDString::get(VMContext, LinkageName),
1032     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
1033     Ty,
1034     ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
1035     ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
1036     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
1037     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
1038     NULL,
1039     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
1040     ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
1041     Fn,
1042     TParams,
1043     Decl,
1044     MDNode::getTemporary(VMContext, TElts),
1045     ConstantInt::get(Type::getInt32Ty(VMContext), ScopeLine)
1046   };
1047   MDNode *Node = MDNode::get(VMContext, Elts);
1048
1049   // Create a named metadata so that we do not lose this mdnode.
1050   if (isDefinition)
1051     AllSubprograms.push_back(Node);
1052   DISubprogram S(Node);
1053   assert(S.isSubprogram() && "createFunction should return a valid DISubprogram");
1054   return S;
1055 }
1056
1057 /// createMethod - Create a new descriptor for the specified C++ method.
1058 DISubprogram DIBuilder::createMethod(DIDescriptor Context,
1059                                      StringRef Name,
1060                                      StringRef LinkageName,
1061                                      DIFile F,
1062                                      unsigned LineNo, DICompositeType Ty,
1063                                      bool isLocalToUnit,
1064                                      bool isDefinition,
1065                                      unsigned VK, unsigned VIndex,
1066                                      MDNode *VTableHolder,
1067                                      unsigned Flags,
1068                                      bool isOptimized,
1069                                      Function *Fn,
1070                                      MDNode *TParam) {
1071   assert(Ty.getTag() == dwarf::DW_TAG_subroutine_type &&
1072          "function types should be subroutines");
1073   Value *TElts[] = { GetTagConstant(VMContext, DW_TAG_base_type) };
1074   Value *Elts[] = {
1075     GetTagConstant(VMContext, dwarf::DW_TAG_subprogram),
1076     F.getFileNode(),
1077     getNonCompileUnitScope(Context),
1078     MDString::get(VMContext, Name),
1079     MDString::get(VMContext, Name),
1080     MDString::get(VMContext, LinkageName),
1081     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
1082     Ty,
1083     ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
1084     ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
1085     ConstantInt::get(Type::getInt32Ty(VMContext), (unsigned)VK),
1086     ConstantInt::get(Type::getInt32Ty(VMContext), VIndex),
1087     VTableHolder,
1088     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
1089     ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
1090     Fn,
1091     TParam,
1092     Constant::getNullValue(Type::getInt32Ty(VMContext)),
1093     MDNode::getTemporary(VMContext, TElts),
1094     // FIXME: Do we want to use different scope/lines?
1095     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo)
1096   };
1097   MDNode *Node = MDNode::get(VMContext, Elts);
1098   if (isDefinition)
1099     AllSubprograms.push_back(Node);
1100   DISubprogram S(Node);
1101   assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
1102   return S;
1103 }
1104
1105 /// createNameSpace - This creates new descriptor for a namespace
1106 /// with the specified parent scope.
1107 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
1108                                        DIFile File, unsigned LineNo) {
1109   Value *Elts[] = {
1110     GetTagConstant(VMContext, dwarf::DW_TAG_namespace),
1111     File.getFileNode(),
1112     getNonCompileUnitScope(Scope),
1113     MDString::get(VMContext, Name),
1114     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo)
1115   };
1116   DINameSpace R(MDNode::get(VMContext, Elts));
1117   assert(R.Verify() &&
1118          "createNameSpace should return a verifiable DINameSpace");
1119   return R;
1120 }
1121
1122 /// createLexicalBlockFile - This creates a new MDNode that encapsulates
1123 /// an existing scope with a new filename.
1124 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1125                                                      DIFile File) {
1126   Value *Elts[] = {
1127     GetTagConstant(VMContext, dwarf::DW_TAG_lexical_block),
1128     File.getFileNode(),
1129     Scope
1130   };
1131   DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1132   assert(
1133       R.Verify() &&
1134       "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1135   return R;
1136 }
1137
1138 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1139                                              unsigned Line, unsigned Col) {
1140   // Defeat MDNode uniquing for lexical blocks by using unique id.
1141   static unsigned int unique_id = 0;
1142   Value *Elts[] = {
1143     GetTagConstant(VMContext, dwarf::DW_TAG_lexical_block),
1144     File.getFileNode(),
1145     getNonCompileUnitScope(Scope),
1146     ConstantInt::get(Type::getInt32Ty(VMContext), Line),
1147     ConstantInt::get(Type::getInt32Ty(VMContext), Col),
1148     ConstantInt::get(Type::getInt32Ty(VMContext), unique_id++)
1149   };
1150   DILexicalBlock R(MDNode::get(VMContext, Elts));
1151   assert(R.Verify() &&
1152          "createLexicalBlock should return a verifiable DILexicalBlock");
1153   return R;
1154 }
1155
1156 /// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
1157 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1158                                       Instruction *InsertBefore) {
1159   assert(Storage && "no storage passed to dbg.declare");
1160   assert(VarInfo.isVariable() &&
1161          "empty or invalid DIVariable passed to dbg.declare");
1162   if (!DeclareFn)
1163     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1164
1165   Value *Args[] = { MDNode::get(Storage->getContext(), Storage), VarInfo };
1166   return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1167 }
1168
1169 /// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
1170 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1171                                       BasicBlock *InsertAtEnd) {
1172   assert(Storage && "no storage passed to dbg.declare");
1173   assert(VarInfo.isVariable() &&
1174          "empty or invalid DIVariable passed to dbg.declare");
1175   if (!DeclareFn)
1176     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1177
1178   Value *Args[] = { MDNode::get(Storage->getContext(), Storage), VarInfo };
1179
1180   // If this block already has a terminator then insert this intrinsic
1181   // before the terminator.
1182   if (TerminatorInst *T = InsertAtEnd->getTerminator())
1183     return CallInst::Create(DeclareFn, Args, "", T);
1184   else
1185     return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1186 }
1187
1188 /// insertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
1189 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1190                                                 DIVariable VarInfo,
1191                                                 Instruction *InsertBefore) {
1192   assert(V && "no value passed to dbg.value");
1193   assert(VarInfo.isVariable() &&
1194          "empty or invalid DIVariable passed to dbg.value");
1195   if (!ValueFn)
1196     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1197
1198   Value *Args[] = { MDNode::get(V->getContext(), V),
1199                     ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
1200                     VarInfo };
1201   return CallInst::Create(ValueFn, Args, "", InsertBefore);
1202 }
1203
1204 /// insertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
1205 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1206                                                 DIVariable VarInfo,
1207                                                 BasicBlock *InsertAtEnd) {
1208   assert(V && "no value passed to dbg.value");
1209   assert(VarInfo.isVariable() &&
1210          "empty or invalid DIVariable passed to dbg.value");
1211   if (!ValueFn)
1212     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1213
1214   Value *Args[] = { MDNode::get(V->getContext(), V),
1215                     ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
1216                     VarInfo };
1217   return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1218 }