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