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