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