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(
 552     DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
 553     uint64_t SizeInBits, uint64_t AlignInBits, unsigned Flags, DIArray Elements,
 554     unsigned RunTimeLang) {
 555   // TAG_union_type is encoded in DICompositeType format.
 556   Value *Elts[] = {
 557     GetTagConstant(VMContext, dwarf::DW_TAG_union_type),
 558     File.getFileNode(),
 559     getNonCompileUnitScope(Scope),
 560     MDString::get(VMContext, Name),
 561     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 562     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 563     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 564     ConstantInt::get(Type::getInt64Ty(VMContext), 0),
 565     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 566     NULL,
 567     Elements,
 568     ConstantInt::get(Type::getInt32Ty(VMContext), RunTimeLang),
 569     Constant::getNullValue(Type::getInt32Ty(VMContext))
 570   };
 571   return DICompositeType(MDNode::get(VMContext, Elts));
 572 }
 573
 574 /// createSubroutineType - Create subroutine type.
 575 DICompositeType
 576 DIBuilder::createSubroutineType(DIFile File, DIArray ParameterTypes) {
 577   // TAG_subroutine_type is encoded in DICompositeType format.
 578   Value *Elts[] = {
 579     GetTagConstant(VMContext, dwarf::DW_TAG_subroutine_type),
 580     Constant::getNullValue(Type::getInt32Ty(VMContext)),
 581     Constant::getNullValue(Type::getInt32Ty(VMContext)),
 582     MDString::get(VMContext, ""),
 583     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 584     ConstantInt::get(Type::getInt64Ty(VMContext), 0),
 585     ConstantInt::get(Type::getInt64Ty(VMContext), 0),
 586     ConstantInt::get(Type::getInt64Ty(VMContext), 0),
 587     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 588     NULL,
 589     ParameterTypes,
 590     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 591     Constant::getNullValue(Type::getInt32Ty(VMContext))
 592   };
 593   return DICompositeType(MDNode::get(VMContext, Elts));
 594 }
 595
 596 /// createEnumerationType - Create debugging information entry for an
 597 /// enumeration.
 598 DICompositeType DIBuilder::createEnumerationType(
 599     DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
 600     uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
 601     DIType ClassType) {
 602   // TAG_enumeration_type is encoded in DICompositeType format.
 603   Value *Elts[] = {
 604     GetTagConstant(VMContext, dwarf::DW_TAG_enumeration_type),
 605     File.getFileNode(),
 606     getNonCompileUnitScope(Scope),
 607     MDString::get(VMContext, Name),
 608     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 609     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 610     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 611     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 612     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 613     ClassType,
 614     Elements,
 615     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 616     Constant::getNullValue(Type::getInt32Ty(VMContext))
 617   };
 618   MDNode *Node = MDNode::get(VMContext, Elts);
 619   AllEnumTypes.push_back(Node);
 620   return DICompositeType(Node);
 621 }
 622
 623 /// createArrayType - Create debugging information entry for an array.
 624 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
 625                                            DIType Ty, DIArray Subscripts) {
 626   // TAG_array_type is encoded in DICompositeType format.
 627   Value *Elts[] = {
 628     GetTagConstant(VMContext, dwarf::DW_TAG_array_type),
 629     NULL, // Filename/Directory,
 630     NULL, //TheCU,
 631     MDString::get(VMContext, ""),
 632     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 633     ConstantInt::get(Type::getInt64Ty(VMContext), Size),
 634     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 635     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 636     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 637     Ty,
 638     Subscripts,
 639     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 640     Constant::getNullValue(Type::getInt32Ty(VMContext))
 641   };
 642   return DICompositeType(MDNode::get(VMContext, Elts));
 643 }
 644
 645 /// createVectorType - Create debugging information entry for a vector.
 646 DIType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
 647                                    DIType Ty, DIArray Subscripts) {
 648
 649   // A vector is an array type with the FlagVector flag applied.
 650   Value *Elts[] = {
 651     GetTagConstant(VMContext, dwarf::DW_TAG_array_type),
 652     NULL, // Filename/Directory,
 653     NULL, //TheCU,
 654     MDString::get(VMContext, ""),
 655     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 656     ConstantInt::get(Type::getInt64Ty(VMContext), Size),
 657     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 658     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 659     ConstantInt::get(Type::getInt32Ty(VMContext), DIType::FlagVector),
 660     Ty,
 661     Subscripts,
 662     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 663     Constant::getNullValue(Type::getInt32Ty(VMContext))
 664   };
 665   return DIType(MDNode::get(VMContext, Elts));
 666 }
 667
 668 /// createArtificialType - Create a new DIType with "artificial" flag set.
 669 DIType DIBuilder::createArtificialType(DIType Ty) {
 670   if (Ty.isArtificial())
 671     return Ty;
 672
 673   SmallVector<Value *, 9> Elts;
 674   MDNode *N = Ty;
 675   assert (N && "Unexpected input DIType!");
 676   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
 677     if (Value *V = N->getOperand(i))
 678       Elts.push_back(V);
 679     else
 680       Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)));
 681   }
 682
 683   unsigned CurFlags = Ty.getFlags();
 684   CurFlags = CurFlags | DIType::FlagArtificial;
 685
 686   // Flags are stored at this slot.
 687   Elts[8] =  ConstantInt::get(Type::getInt32Ty(VMContext), CurFlags);
 688
 689   return DIType(MDNode::get(VMContext, Elts));
 690 }
 691
 692 /// createObjectPointerType - Create a new type with both the object pointer
 693 /// and artificial flags set.
 694 DIType DIBuilder::createObjectPointerType(DIType Ty) {
 695   if (Ty.isObjectPointer())
 696     return Ty;
 697
 698   SmallVector<Value *, 9> Elts;
 699   MDNode *N = Ty;
 700   assert (N && "Unexpected input DIType!");
 701   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
 702     if (Value *V = N->getOperand(i))
 703       Elts.push_back(V);
 704     else
 705       Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)));
 706   }
 707
 708   unsigned CurFlags = Ty.getFlags();
 709   CurFlags = CurFlags | (DIType::FlagObjectPointer | DIType::FlagArtificial);
 710
 711   // Flags are stored at this slot.
 712   Elts[8] = ConstantInt::get(Type::getInt32Ty(VMContext), CurFlags);
 713
 714   return DIType(MDNode::get(VMContext, Elts));
 715 }
 716
 717 /// retainType - Retain DIType in a module even if it is not referenced
 718 /// through debug info anchors.
 719 void DIBuilder::retainType(DIType T) {
 720   AllRetainTypes.push_back(T);
 721 }
 722
 723 /// createUnspecifiedParameter - Create unspeicified type descriptor
 724 /// for the subroutine type.
 725 DIDescriptor DIBuilder::createUnspecifiedParameter() {
 726   Value *Elts[] = {
 727     GetTagConstant(VMContext, dwarf::DW_TAG_unspecified_parameters)
 728   };
 729   return DIDescriptor(MDNode::get(VMContext, Elts));
 730 }
 731
 732 /// createForwardDecl - Create a temporary forward-declared type that
 733 /// can be RAUW'd if the full type is seen.
 734 DIType DIBuilder::createForwardDecl(unsigned Tag, StringRef Name,
 735                                     DIDescriptor Scope, DIFile F,
 736                                     unsigned Line, unsigned RuntimeLang,
 737                                     uint64_t SizeInBits,
 738                                     uint64_t AlignInBits) {
 739   // Create a temporary MDNode.
 740   Value *Elts[] = {
 741     GetTagConstant(VMContext, Tag),
 742     F.getFileNode(),
 743     getNonCompileUnitScope(Scope),
 744     MDString::get(VMContext, Name),
 745     ConstantInt::get(Type::getInt32Ty(VMContext), Line),
 746     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 747     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 748     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 749     ConstantInt::get(Type::getInt32Ty(VMContext),
 750                      DIDescriptor::FlagFwdDecl),
 751     NULL,
 752     DIArray(),
 753     ConstantInt::get(Type::getInt32Ty(VMContext), RuntimeLang)
 754   };
 755   MDNode *Node = MDNode::getTemporary(VMContext, Elts);
 756   assert(DIType(Node).Verify() &&
 757          "createForwardDecl result should be verifiable");
 758   return DIType(Node);
 759 }
 760
 761 /// getOrCreateArray - Get a DIArray, create one if required.
 762 DIArray DIBuilder::getOrCreateArray(ArrayRef<Value *> Elements) {
 763   if (Elements.empty()) {
 764     Value *Null = Constant::getNullValue(Type::getInt32Ty(VMContext));
 765     return DIArray(MDNode::get(VMContext, Null));
 766   }
 767   return DIArray(MDNode::get(VMContext, Elements));
 768 }
 769
 770 /// getOrCreateSubrange - Create a descriptor for a value range.  This
 771 /// implicitly uniques the values returned.
 772 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
 773   Value *Elts[] = {
 774     GetTagConstant(VMContext, dwarf::DW_TAG_subrange_type),
 775     ConstantInt::get(Type::getInt64Ty(VMContext), Lo),
 776     ConstantInt::get(Type::getInt64Ty(VMContext), Count)
 777   };
 778
 779   return DISubrange(MDNode::get(VMContext, Elts));
 780 }
 781
 782 /// \brief Create a new descriptor for the specified global.
 783 DIGlobalVariable DIBuilder::
 784 createGlobalVariable(StringRef Name, StringRef LinkageName, DIFile F,
 785                      unsigned LineNumber, DIType Ty, bool isLocalToUnit,
 786                      Value *Val) {
 787   Value *Elts[] = {
 788     GetTagConstant(VMContext, dwarf::DW_TAG_variable),
 789     Constant::getNullValue(Type::getInt32Ty(VMContext)),
 790     NULL, // TheCU,
 791     MDString::get(VMContext, Name),
 792     MDString::get(VMContext, Name),
 793     MDString::get(VMContext, LinkageName),
 794     F,
 795     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 796     Ty,
 797     ConstantInt::get(Type::getInt32Ty(VMContext), isLocalToUnit),
 798     ConstantInt::get(Type::getInt32Ty(VMContext), 1), /* isDefinition*/
 799     Val,
 800     DIDescriptor()
 801   };
 802   MDNode *Node = MDNode::get(VMContext, Elts);
 803   AllGVs.push_back(Node);
 804   return DIGlobalVariable(Node);
 805 }
 806
 807 /// \brief Create a new descriptor for the specified global.
 808 DIGlobalVariable DIBuilder::
 809 createGlobalVariable(StringRef Name, DIFile F, unsigned LineNumber,
 810                      DIType Ty, bool isLocalToUnit, Value *Val) {
 811   return createGlobalVariable(Name, Name, F, LineNumber, Ty, isLocalToUnit,
 812                               Val);
 813 }
 814
 815 /// createStaticVariable - Create a new descriptor for the specified static
 816 /// variable.
 817 DIGlobalVariable DIBuilder::
 818 createStaticVariable(DIDescriptor Context, StringRef Name,
 819                      StringRef LinkageName, DIFile F, unsigned LineNumber,
 820                      DIType Ty, bool isLocalToUnit, Value *Val, MDNode *Decl) {
 821   Value *Elts[] = {
 822     GetTagConstant(VMContext, dwarf::DW_TAG_variable),
 823     Constant::getNullValue(Type::getInt32Ty(VMContext)),
 824     getNonCompileUnitScope(Context),
 825     MDString::get(VMContext, Name),
 826     MDString::get(VMContext, Name),
 827     MDString::get(VMContext, LinkageName),
 828     F,
 829     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 830     Ty,
 831     ConstantInt::get(Type::getInt32Ty(VMContext), isLocalToUnit),
 832     ConstantInt::get(Type::getInt32Ty(VMContext), 1), /* isDefinition*/
 833     Val,
 834     DIDescriptor(Decl)
 835   };
 836   MDNode *Node = MDNode::get(VMContext, Elts);
 837   AllGVs.push_back(Node);
 838   return DIGlobalVariable(Node);
 839 }
 840
 841 /// createVariable - Create a new descriptor for the specified variable.
 842 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
 843                                           StringRef Name, DIFile File,
 844                                           unsigned LineNo, DIType Ty,
 845                                           bool AlwaysPreserve, unsigned Flags,
 846                                           unsigned ArgNo) {
 847   DIDescriptor Context(getNonCompileUnitScope(Scope));
 848   assert((!Context || Context.Verify()) &&
 849          "createLocalVariable should be called with a valid Context");
 850   assert(Ty.Verify() &&
 851          "createLocalVariable should be called with a valid type");
 852   Value *Elts[] = {
 853     GetTagConstant(VMContext, Tag),
 854     getNonCompileUnitScope(Scope),
 855     MDString::get(VMContext, Name),
 856     File,
 857     ConstantInt::get(Type::getInt32Ty(VMContext), (LineNo | (ArgNo << 24))),
 858     Ty,
 859     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 860     Constant::getNullValue(Type::getInt32Ty(VMContext))
 861   };
 862   MDNode *Node = MDNode::get(VMContext, Elts);
 863   if (AlwaysPreserve) {
 864     // The optimizer may remove local variable. If there is an interest
 865     // to preserve variable info in such situation then stash it in a
 866     // named mdnode.
 867     DISubprogram Fn(getDISubprogram(Scope));
 868     NamedMDNode *FnLocals = getOrInsertFnSpecificMDNode(M, Fn);
 869     FnLocals->addOperand(Node);
 870   }
 871   assert(DIVariable(Node).Verify() &&
 872          "createLocalVariable should return a verifiable DIVariable");
 873   return DIVariable(Node);
 874 }
 875
 876 /// createComplexVariable - Create a new descriptor for the specified variable
 877 /// which has a complex address expression for its address.
 878 DIVariable DIBuilder::createComplexVariable(unsigned Tag, DIDescriptor Scope,
 879                                             StringRef Name, DIFile F,
 880                                             unsigned LineNo,
 881                                             DIType Ty, ArrayRef<Value *> Addr,
 882                                             unsigned ArgNo) {
 883   SmallVector<Value *, 15> Elts;
 884   Elts.push_back(GetTagConstant(VMContext, Tag));
 885   Elts.push_back(getNonCompileUnitScope(Scope)),
 886   Elts.push_back(MDString::get(VMContext, Name));
 887   Elts.push_back(F);
 888   Elts.push_back(ConstantInt::get(Type::getInt32Ty(VMContext),
 889                                   (LineNo | (ArgNo << 24))));
 890   Elts.push_back(Ty);
 891   Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)));
 892   Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)));
 893   Elts.append(Addr.begin(), Addr.end());
 894
 895   return DIVariable(MDNode::get(VMContext, Elts));
 896 }
 897
 898 /// createFunction - Create a new descriptor for the specified function.
 899 DISubprogram DIBuilder::createFunction(DIDescriptor Context,
 900                                        StringRef Name,
 901                                        StringRef LinkageName,
 902                                        DIFile File, unsigned LineNo,
 903                                        DIType Ty,
 904                                        bool isLocalToUnit, bool isDefinition,
 905                                        unsigned ScopeLine,
 906                                        unsigned Flags, bool isOptimized,
 907                                        Function *Fn,
 908                                        MDNode *TParams,
 909                                        MDNode *Decl) {
 910   Value *TElts[] = { GetTagConstant(VMContext, DW_TAG_base_type) };
 911   Value *Elts[] = {
 912     GetTagConstant(VMContext, dwarf::DW_TAG_subprogram),
 913     File.getFileNode(),
 914     getNonCompileUnitScope(Context),
 915     MDString::get(VMContext, Name),
 916     MDString::get(VMContext, Name),
 917     MDString::get(VMContext, LinkageName),
 918     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
 919     Ty,
 920     ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
 921     ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
 922     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 923     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 924     NULL,
 925     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 926     ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
 927     Fn,
 928     TParams,
 929     Decl,
 930     MDNode::getTemporary(VMContext, TElts),
 931     ConstantInt::get(Type::getInt32Ty(VMContext), ScopeLine)
 932   };
 933   MDNode *Node = MDNode::get(VMContext, Elts);
 934
 935   // Create a named metadata so that we do not lose this mdnode.
 936   if (isDefinition)
 937     AllSubprograms.push_back(Node);
 938   DISubprogram S(Node);
 939   assert(S.Verify() && "createFunction should return a valid DISubprogram");
 940   return S;
 941 }
 942
 943 /// createMethod - Create a new descriptor for the specified C++ method.
 944 DISubprogram DIBuilder::createMethod(DIDescriptor Context,
 945                                      StringRef Name,
 946                                      StringRef LinkageName,
 947                                      DIFile F,
 948                                      unsigned LineNo, DIType Ty,
 949                                      bool isLocalToUnit,
 950                                      bool isDefinition,
 951                                      unsigned VK, unsigned VIndex,
 952                                      MDNode *VTableHolder,
 953                                      unsigned Flags,
 954                                      bool isOptimized,
 955                                      Function *Fn,
 956                                      MDNode *TParam) {
 957   Value *TElts[] = { GetTagConstant(VMContext, DW_TAG_base_type) };
 958   Value *Elts[] = {
 959     GetTagConstant(VMContext, dwarf::DW_TAG_subprogram),
 960     F.getFileNode(),
 961     getNonCompileUnitScope(Context),
 962     MDString::get(VMContext, Name),
 963     MDString::get(VMContext, Name),
 964     MDString::get(VMContext, LinkageName),
 965     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
 966     Ty,
 967     ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
 968     ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
 969     ConstantInt::get(Type::getInt32Ty(VMContext), (unsigned)VK),
 970     ConstantInt::get(Type::getInt32Ty(VMContext), VIndex),
 971     VTableHolder,
 972     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 973     ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
 974     Fn,
 975     TParam,
 976     Constant::getNullValue(Type::getInt32Ty(VMContext)),
 977     MDNode::getTemporary(VMContext, TElts),
 978     // FIXME: Do we want to use different scope/lines?
 979     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo)
 980   };
 981   MDNode *Node = MDNode::get(VMContext, Elts);
 982   if (isDefinition)
 983     AllSubprograms.push_back(Node);
 984   DISubprogram S(Node);
 985   assert(S.Verify() && "createMethod should return a valid DISubprogram");
 986   return S;
 987 }
 988
 989 /// createNameSpace - This creates new descriptor for a namespace
 990 /// with the specified parent scope.
 991 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
 992                                        DIFile File, unsigned LineNo) {
 993   Value *Elts[] = {
 994     GetTagConstant(VMContext, dwarf::DW_TAG_namespace),
 995     File.getFileNode(),
 996     getNonCompileUnitScope(Scope),
 997     MDString::get(VMContext, Name),
 998     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo)
 999   };
1000   DINameSpace R(MDNode::get(VMContext, Elts));
1001   assert(R.Verify() &&
1002          "createNameSpace should return a verifiable DINameSpace");
1003   return R;
1004 }
1005
1006 /// createLexicalBlockFile - This creates a new MDNode that encapsulates
1007 /// an existing scope with a new filename.
1008 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
1009                                                      DIFile File) {
1010   Value *Elts[] = {
1011     GetTagConstant(VMContext, dwarf::DW_TAG_lexical_block),
1012     File.getFileNode(),
1013     Scope
1014   };
1015   DILexicalBlockFile R(MDNode::get(VMContext, Elts));
1016   assert(
1017       R.Verify() &&
1018       "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1019   return R;
1020 }
1021
1022 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1023                                              unsigned Line, unsigned Col) {
1024   // Defeat MDNode uniqing for lexical blocks by using unique id.
1025   static unsigned int unique_id = 0;
1026   Value *Elts[] = {
1027     GetTagConstant(VMContext, dwarf::DW_TAG_lexical_block),
1028     File.getFileNode(),
1029     getNonCompileUnitScope(Scope),
1030     ConstantInt::get(Type::getInt32Ty(VMContext), Line),
1031     ConstantInt::get(Type::getInt32Ty(VMContext), Col),
1032     ConstantInt::get(Type::getInt32Ty(VMContext), unique_id++)
1033   };
1034   DILexicalBlock R(MDNode::get(VMContext, Elts));
1035   assert(R.Verify() &&
1036          "createLexicalBlock should return a verifiable DILexicalBlock");
1037   return R;
1038 }
1039
1040 /// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
1041 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1042                                       Instruction *InsertBefore) {
1043   assert(Storage && "no storage passed to dbg.declare");
1044   assert(VarInfo.Verify() && "empty DIVariable passed to dbg.declare");
1045   if (!DeclareFn)
1046     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1047
1048   Value *Args[] = { MDNode::get(Storage->getContext(), Storage), VarInfo };
1049   return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1050 }
1051
1052 /// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
1053 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1054                                       BasicBlock *InsertAtEnd) {
1055   assert(Storage && "no storage passed to dbg.declare");
1056   assert(VarInfo.Verify() && "invalid DIVariable passed to dbg.declare");
1057   if (!DeclareFn)
1058     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1059
1060   Value *Args[] = { MDNode::get(Storage->getContext(), Storage), VarInfo };
1061
1062   // If this block already has a terminator then insert this intrinsic
1063   // before the terminator.
1064   if (TerminatorInst *T = InsertAtEnd->getTerminator())
1065     return CallInst::Create(DeclareFn, Args, "", T);
1066   else
1067     return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1068 }
1069
1070 /// insertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
1071 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1072                                                 DIVariable VarInfo,
1073                                                 Instruction *InsertBefore) {
1074   assert(V && "no value passed to dbg.value");
1075   assert(VarInfo.Verify() && "invalid DIVariable passed to dbg.value");
1076   if (!ValueFn)
1077     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1078
1079   Value *Args[] = { MDNode::get(V->getContext(), V),
1080                     ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
1081                     VarInfo };
1082   return CallInst::Create(ValueFn, Args, "", InsertBefore);
1083 }
1084
1085 /// insertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
1086 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1087                                                 DIVariable VarInfo,
1088                                                 BasicBlock *InsertAtEnd) {
1089   assert(V && "no value passed to dbg.value");
1090   assert(VarInfo.Verify() && "invalid DIVariable passed to dbg.value");
1091   if (!ValueFn)
1092     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1093
1094   Value *Args[] = { MDNode::get(V->getContext(), V),
1095                     ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
1096                     VarInfo };
1097   return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1098 }