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