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