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