lib/IR/DIBuilder.cpp

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