lib/Analysis/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/Analysis/DIBuilder.h"
  15 #include "llvm/Analysis/DebugInfo.h"
  16 #include "llvm/Constants.h"
  17 #include "llvm/IntrinsicInst.h"
  18 #include "llvm/Module.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/Support/Dwarf.h"
  21
  22 using namespace llvm;
  23 using namespace llvm::dwarf;
  24
  25 static Constant *GetTagConstant(LLVMContext &VMContext, unsigned Tag) {
  26   assert((Tag & LLVMDebugVersionMask) == 0 &&
  27          "Tag too large for debug encoding!");
  28   return ConstantInt::get(Type::getInt32Ty(VMContext), Tag | LLVMDebugVersion);
  29 }
  30
  31 DIBuilder::DIBuilder(Module &m)
  32   : M(m), VMContext(M.getContext()), TheCU(0), TempEnumTypes(0),
  33     TempRetainTypes(0), TempSubprograms(0), TempGVs(0), DeclareFn(0),
  34     ValueFn(0)
  35 {}
  36
  37 /// finalize - Construct any deferred debug info descriptors.
  38 void DIBuilder::finalize() {
  39   DIArray Enums = getOrCreateArray(AllEnumTypes);
  40   DIType(TempEnumTypes).replaceAllUsesWith(Enums);
  41
  42   DIArray RetainTypes = getOrCreateArray(AllRetainTypes);
  43   DIType(TempRetainTypes).replaceAllUsesWith(RetainTypes);
  44
  45   DIArray SPs = getOrCreateArray(AllSubprograms);
  46   DIType(TempSubprograms).replaceAllUsesWith(SPs);
  47   for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
  48     DISubprogram SP(SPs.getElement(i));
  49     if (NamedMDNode *NMD = getFnSpecificMDNode(M, SP)) {
  50       SmallVector<Value *, 4> Variables;
  51       for (unsigned ii = 0, ee = NMD->getNumOperands(); ii != ee; ++ii)
  52         Variables.push_back(NMD->getOperand(ii));
  53       if (MDNode *Temp = SP.getVariablesNodes()) {
  54         DIArray AV = getOrCreateArray(Variables);
  55         DIType(Temp).replaceAllUsesWith(AV);
  56       }
  57       NMD->eraseFromParent();
  58     }
  59   }
  60
  61   DIArray GVs = getOrCreateArray(AllGVs);
  62   DIType(TempGVs).replaceAllUsesWith(GVs);
  63 }
  64
  65 /// getNonCompileUnitScope - If N is compile unit return NULL otherwise return
  66 /// N.
  67 static MDNode *getNonCompileUnitScope(MDNode *N) {
  68   if (DIDescriptor(N).isCompileUnit())
  69     return NULL;
  70   return N;
  71 }
  72
  73 /// createCompileUnit - A CompileUnit provides an anchor for all debugging
  74 /// information generated during this instance of compilation.
  75 void DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
  76                                   StringRef Directory, StringRef Producer,
  77                                   bool isOptimized, StringRef Flags,
  78                                   unsigned RunTimeVer) {
  79   assert ((Lang <= dwarf::DW_LANG_Python && Lang >= dwarf::DW_LANG_C89
  80           || Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)
  81           && "Invalid Language tag");
  82   assert (!Filename.empty()
  83           && "Unable to create compile unit without filename");
  84   Value *TElts[] = { GetTagConstant(VMContext, DW_TAG_base_type) };
  85   TempEnumTypes = MDNode::getTemporary(VMContext, TElts);
  86   Value *THElts[] = { TempEnumTypes };
  87   MDNode *EnumHolder = MDNode::get(VMContext, THElts);
  88
  89   TempRetainTypes = MDNode::getTemporary(VMContext, TElts);
  90   Value *TRElts[] = { TempRetainTypes };
  91   MDNode *RetainHolder = MDNode::get(VMContext, TRElts);
  92
  93   TempSubprograms = MDNode::getTemporary(VMContext, TElts);
  94   Value *TSElts[] = { TempSubprograms };
  95   MDNode *SPHolder = MDNode::get(VMContext, TSElts);
  96
  97   TempGVs = MDNode::getTemporary(VMContext, TElts);
  98   Value *TVElts[] = { TempGVs };
  99   MDNode *GVHolder = MDNode::get(VMContext, TVElts);
 100
 101   Value *Elts[] = {
 102     GetTagConstant(VMContext, dwarf::DW_TAG_compile_unit),
 103     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 104     ConstantInt::get(Type::getInt32Ty(VMContext), Lang),
 105     MDString::get(VMContext, Filename),
 106     MDString::get(VMContext, Directory),
 107     MDString::get(VMContext, Producer),
 108     // Deprecate isMain field.
 109     ConstantInt::get(Type::getInt1Ty(VMContext), true), // isMain
 110     ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
 111     MDString::get(VMContext, Flags),
 112     ConstantInt::get(Type::getInt32Ty(VMContext), RunTimeVer),
 113     EnumHolder,
 114     RetainHolder,
 115     SPHolder,
 116     GVHolder
 117   };
 118   TheCU = DICompileUnit(MDNode::get(VMContext, Elts));
 119
 120   // Create a named metadata so that it is easier to find cu in a module.
 121   NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
 122   NMD->addOperand(TheCU);
 123 }
 124
 125 /// createFile - Create a file descriptor to hold debugging information
 126 /// for a file.
 127 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
 128   assert(TheCU && "Unable to create DW_TAG_file_type without CompileUnit");
 129   assert(!Filename.empty() && "Unable to create file without name");
 130   Value *Elts[] = {
 131     GetTagConstant(VMContext, dwarf::DW_TAG_file_type),
 132     MDString::get(VMContext, Filename),
 133     MDString::get(VMContext, Directory),
 134     NULL // TheCU
 135   };
 136   return DIFile(MDNode::get(VMContext, Elts));
 137 }
 138
 139 /// createEnumerator - Create a single enumerator value.
 140 DIEnumerator DIBuilder::createEnumerator(StringRef Name, uint64_t Val) {
 141   assert(!Name.empty() && "Unable to create enumerator without name");
 142   Value *Elts[] = {
 143     GetTagConstant(VMContext, dwarf::DW_TAG_enumerator),
 144     MDString::get(VMContext, Name),
 145     ConstantInt::get(Type::getInt64Ty(VMContext), Val)
 146   };
 147   return DIEnumerator(MDNode::get(VMContext, Elts));
 148 }
 149
 150 /// createNullPtrType - Create C++0x nullptr type.
 151 DIType DIBuilder::createNullPtrType(StringRef Name) {
 152   assert(!Name.empty() && "Unable to create type without name");
 153   // nullptr is encoded in DIBasicType format. Line number, filename,
 154   // ,size, alignment, offset and flags are always empty here.
 155   Value *Elts[] = {
 156     GetTagConstant(VMContext, dwarf::DW_TAG_unspecified_type),
 157     NULL, //TheCU,
 158     MDString::get(VMContext, Name),
 159     NULL, // Filename
 160     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
 161     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size
 162     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align
 163     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
 164     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags;
 165     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Encoding
 166   };
 167   return DIType(MDNode::get(VMContext, Elts));
 168 }
 169
 170 /// createBasicType - Create debugging information entry for a basic
 171 /// type, e.g 'char'.
 172 DIType DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
 173                                   uint64_t AlignInBits,
 174                                   unsigned Encoding) {
 175   assert(!Name.empty() && "Unable to create type without name");
 176   // Basic types are encoded in DIBasicType format. Line number, filename,
 177   // offset and flags are always empty here.
 178   Value *Elts[] = {
 179     GetTagConstant(VMContext, dwarf::DW_TAG_base_type),
 180     NULL, //TheCU,
 181     MDString::get(VMContext, Name),
 182     NULL, // Filename
 183     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
 184     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 185     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 186     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
 187     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags;
 188     ConstantInt::get(Type::getInt32Ty(VMContext), Encoding)
 189   };
 190   return DIType(MDNode::get(VMContext, Elts));
 191 }
 192
 193 /// createQualifiedType - Create debugging information entry for a qualified
 194 /// type, e.g. 'const int'.
 195 DIType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
 196   // Qualified types are encoded in DIDerivedType format.
 197   Value *Elts[] = {
 198     GetTagConstant(VMContext, Tag),
 199     NULL, //TheCU,
 200     MDString::get(VMContext, StringRef()), // Empty name.
 201     NULL, // Filename
 202     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
 203     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size
 204     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align
 205     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
 206     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags
 207     FromTy
 208   };
 209   return DIType(MDNode::get(VMContext, Elts));
 210 }
 211
 212 /// createPointerType - Create debugging information entry for a pointer.
 213 DIType DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
 214                                     uint64_t AlignInBits, StringRef Name) {
 215   // Pointer types are encoded in DIDerivedType format.
 216   Value *Elts[] = {
 217     GetTagConstant(VMContext, dwarf::DW_TAG_pointer_type),
 218     NULL, //TheCU,
 219     MDString::get(VMContext, Name),
 220     NULL, // Filename
 221     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
 222     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 223     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 224     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
 225     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags
 226     PointeeTy
 227   };
 228   return DIType(MDNode::get(VMContext, Elts));
 229 }
 230
 231 /// createReferenceType - Create debugging information entry for a reference.
 232 DIType DIBuilder::createReferenceType(DIType RTy) {
 233   assert(RTy.Verify() && "Unable to create reference type");
 234   // References are encoded in DIDerivedType format.
 235   Value *Elts[] = {
 236     GetTagConstant(VMContext, dwarf::DW_TAG_reference_type),
 237     NULL, // TheCU,
 238     NULL, // Name
 239     NULL, // Filename
 240     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
 241     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size
 242     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align
 243     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
 244     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags
 245     RTy
 246   };
 247   return DIType(MDNode::get(VMContext, Elts));
 248 }
 249
 250 /// createTypedef - Create debugging information entry for a typedef.
 251 DIType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
 252                                 unsigned LineNo, DIDescriptor Context) {
 253   // typedefs are encoded in DIDerivedType format.
 254   assert(Ty.Verify() && "Invalid typedef type!");
 255   Value *Elts[] = {
 256     GetTagConstant(VMContext, dwarf::DW_TAG_typedef),
 257     getNonCompileUnitScope(Context),
 258     MDString::get(VMContext, Name),
 259     File,
 260     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
 261     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size
 262     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align
 263     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
 264     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags
 265     Ty
 266   };
 267   return DIType(MDNode::get(VMContext, Elts));
 268 }
 269
 270 /// createFriend - Create debugging information entry for a 'friend'.
 271 DIType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
 272   // typedefs are encoded in DIDerivedType format.
 273   assert(Ty.Verify() && "Invalid type!");
 274   assert(FriendTy.Verify() && "Invalid friend type!");
 275   Value *Elts[] = {
 276     GetTagConstant(VMContext, dwarf::DW_TAG_friend),
 277     Ty,
 278     NULL, // Name
 279     Ty.getFile(),
 280     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
 281     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size
 282     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align
 283     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
 284     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags
 285     FriendTy
 286   };
 287   return DIType(MDNode::get(VMContext, Elts));
 288 }
 289
 290 /// createInheritance - Create debugging information entry to establish
 291 /// inheritance relationship between two types.
 292 DIType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
 293                                     uint64_t BaseOffset, unsigned Flags) {
 294   assert(Ty.Verify() && "Unable to create inheritance");
 295   // TAG_inheritance is encoded in DIDerivedType format.
 296   Value *Elts[] = {
 297     GetTagConstant(VMContext, dwarf::DW_TAG_inheritance),
 298     Ty,
 299     NULL, // Name
 300     Ty.getFile(),
 301     ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
 302     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size
 303     ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align
 304     ConstantInt::get(Type::getInt64Ty(VMContext), BaseOffset),
 305     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 306     BaseTy
 307   };
 308   return DIType(MDNode::get(VMContext, Elts));
 309 }
 310
 311 /// createMemberType - Create debugging information entry for a member.
 312 DIType DIBuilder::createMemberType(DIDescriptor Scope, StringRef Name,
 313                                    DIFile File, unsigned LineNumber,
 314                                    uint64_t SizeInBits, uint64_t AlignInBits,
 315                                    uint64_t OffsetInBits, unsigned Flags,
 316                                    DIType Ty) {
 317   // TAG_member is encoded in DIDerivedType format.
 318   Value *Elts[] = {
 319     GetTagConstant(VMContext, dwarf::DW_TAG_member),
 320     getNonCompileUnitScope(Scope),
 321     MDString::get(VMContext, Name),
 322     File,
 323     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 324     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 325     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 326     ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
 327     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 328     Ty
 329   };
 330   return DIType(MDNode::get(VMContext, Elts));
 331 }
 332
 333 /// createObjCIVar - Create debugging information entry for Objective-C
 334 /// instance variable.
 335 DIType DIBuilder::createObjCIVar(StringRef Name,
 336                                  DIFile File, unsigned LineNumber,
 337                                  uint64_t SizeInBits, uint64_t AlignInBits,
 338                                  uint64_t OffsetInBits, unsigned Flags,
 339                                  DIType Ty, StringRef PropertyName,
 340                                  StringRef GetterName, StringRef SetterName,
 341                                  unsigned PropertyAttributes) {
 342   // TAG_member is encoded in DIDerivedType format.
 343   Value *Elts[] = {
 344     GetTagConstant(VMContext, dwarf::DW_TAG_member),
 345     getNonCompileUnitScope(File),
 346     MDString::get(VMContext, Name),
 347     File,
 348     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 349     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 350     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 351     ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
 352     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 353     Ty,
 354     MDString::get(VMContext, PropertyName),
 355     MDString::get(VMContext, GetterName),
 356     MDString::get(VMContext, SetterName),
 357     ConstantInt::get(Type::getInt32Ty(VMContext), PropertyAttributes)
 358   };
 359   return DIType(MDNode::get(VMContext, Elts));
 360 }
 361
 362 /// createClassType - Create debugging information entry for a class.
 363 DIType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
 364                                   DIFile File, unsigned LineNumber,
 365                                   uint64_t SizeInBits, uint64_t AlignInBits,
 366                                   uint64_t OffsetInBits, unsigned Flags,
 367                                   DIType DerivedFrom, DIArray Elements,
 368                                   MDNode *VTableHoder, MDNode *TemplateParams) {
 369  // TAG_class_type is encoded in DICompositeType format.
 370   Value *Elts[] = {
 371     GetTagConstant(VMContext, dwarf::DW_TAG_class_type),
 372     getNonCompileUnitScope(Context),
 373     MDString::get(VMContext, Name),
 374     File,
 375     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 376     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 377     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 378     ConstantInt::get(Type::getInt32Ty(VMContext), OffsetInBits),
 379     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 380     DerivedFrom,
 381     Elements,
 382     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 383     VTableHoder,
 384     TemplateParams
 385   };
 386   return DIType(MDNode::get(VMContext, Elts));
 387 }
 388
 389 /// createTemplateTypeParameter - Create debugging information for template
 390 /// type parameter.
 391 DITemplateTypeParameter
 392 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
 393                                        DIType Ty, MDNode *File, unsigned LineNo,
 394                                        unsigned ColumnNo) {
 395   Value *Elts[] = {
 396     GetTagConstant(VMContext, dwarf::DW_TAG_template_type_parameter),
 397     getNonCompileUnitScope(Context),
 398     MDString::get(VMContext, Name),
 399     Ty,
 400     File,
 401     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
 402     ConstantInt::get(Type::getInt32Ty(VMContext), ColumnNo)
 403   };
 404   return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
 405 }
 406
 407 /// createTemplateValueParameter - Create debugging information for template
 408 /// value parameter.
 409 DITemplateValueParameter
 410 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
 411                                         DIType Ty, uint64_t Val,
 412                                         MDNode *File, unsigned LineNo,
 413                                         unsigned ColumnNo) {
 414   Value *Elts[] = {
 415     GetTagConstant(VMContext, dwarf::DW_TAG_template_value_parameter),
 416     getNonCompileUnitScope(Context),
 417     MDString::get(VMContext, Name),
 418     Ty,
 419     ConstantInt::get(Type::getInt64Ty(VMContext), Val),
 420     File,
 421     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
 422     ConstantInt::get(Type::getInt32Ty(VMContext), ColumnNo)
 423   };
 424   return DITemplateValueParameter(MDNode::get(VMContext, Elts));
 425 }
 426
 427 /// createStructType - Create debugging information entry for a struct.
 428 DIType DIBuilder::createStructType(DIDescriptor Context, StringRef Name,
 429                                    DIFile File, unsigned LineNumber,
 430                                    uint64_t SizeInBits, uint64_t AlignInBits,
 431                                    unsigned Flags, DIArray Elements,
 432                                    unsigned RunTimeLang) {
 433  // TAG_structure_type is encoded in DICompositeType format.
 434   Value *Elts[] = {
 435     GetTagConstant(VMContext, dwarf::DW_TAG_structure_type),
 436     getNonCompileUnitScope(Context),
 437     MDString::get(VMContext, Name),
 438     File,
 439     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 440     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 441     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 442     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 443     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 444     NULL,
 445     Elements,
 446     ConstantInt::get(Type::getInt32Ty(VMContext), RunTimeLang),
 447     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 448   };
 449   return DIType(MDNode::get(VMContext, Elts));
 450 }
 451
 452 /// createUnionType - Create debugging information entry for an union.
 453 DIType DIBuilder::createUnionType(DIDescriptor Scope, StringRef Name,
 454                                   DIFile File,
 455                                   unsigned LineNumber, uint64_t SizeInBits,
 456                                   uint64_t AlignInBits, unsigned Flags,
 457                                   DIArray Elements, unsigned RunTimeLang) {
 458   // TAG_union_type is encoded in DICompositeType format.
 459   Value *Elts[] = {
 460     GetTagConstant(VMContext, dwarf::DW_TAG_union_type),
 461     getNonCompileUnitScope(Scope),
 462     MDString::get(VMContext, Name),
 463     File,
 464     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 465     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 466     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 467     ConstantInt::get(Type::getInt64Ty(VMContext), 0),
 468     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 469     NULL,
 470     Elements,
 471     ConstantInt::get(Type::getInt32Ty(VMContext), RunTimeLang),
 472     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 473   };
 474   return DIType(MDNode::get(VMContext, Elts));
 475 }
 476
 477 /// createSubroutineType - Create subroutine type.
 478 DIType DIBuilder::createSubroutineType(DIFile File, DIArray ParameterTypes) {
 479   // TAG_subroutine_type is encoded in DICompositeType format.
 480   Value *Elts[] = {
 481     GetTagConstant(VMContext, dwarf::DW_TAG_subroutine_type),
 482     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 483     MDString::get(VMContext, ""),
 484     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 485     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 486     ConstantInt::get(Type::getInt64Ty(VMContext), 0),
 487     ConstantInt::get(Type::getInt64Ty(VMContext), 0),
 488     ConstantInt::get(Type::getInt64Ty(VMContext), 0),
 489     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 490     NULL,
 491     ParameterTypes,
 492     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 493     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 494   };
 495   return DIType(MDNode::get(VMContext, Elts));
 496 }
 497
 498 /// createEnumerationType - Create debugging information entry for an
 499 /// enumeration.
 500 DIType DIBuilder::createEnumerationType(DIDescriptor Scope, StringRef Name,
 501                                         DIFile File, unsigned LineNumber,
 502                                         uint64_t SizeInBits,
 503                                         uint64_t AlignInBits,
 504                                         DIArray Elements) {
 505   // TAG_enumeration_type is encoded in DICompositeType format.
 506   Value *Elts[] = {
 507     GetTagConstant(VMContext, dwarf::DW_TAG_enumeration_type),
 508     getNonCompileUnitScope(Scope),
 509     MDString::get(VMContext, Name),
 510     File,
 511     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 512     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 513     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 514     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 515     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 516     NULL,
 517     Elements,
 518     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 519     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 520   };
 521   MDNode *Node = MDNode::get(VMContext, Elts);
 522   AllEnumTypes.push_back(Node);
 523   return DIType(Node);
 524 }
 525
 526 /// createArrayType - Create debugging information entry for an array.
 527 DIType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
 528                                   DIType Ty, DIArray Subscripts) {
 529   // TAG_array_type is encoded in DICompositeType format.
 530   Value *Elts[] = {
 531     GetTagConstant(VMContext, dwarf::DW_TAG_array_type),
 532     NULL, //TheCU,
 533     MDString::get(VMContext, ""),
 534     NULL, //TheCU,
 535     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 536     ConstantInt::get(Type::getInt64Ty(VMContext), Size),
 537     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 538     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 539     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 540     Ty,
 541     Subscripts,
 542     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 543     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 544   };
 545   return DIType(MDNode::get(VMContext, Elts));
 546 }
 547
 548 /// createVectorType - Create debugging information entry for a vector.
 549 DIType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
 550                                    DIType Ty, DIArray Subscripts) {
 551   // TAG_vector_type is encoded in DICompositeType format.
 552   Value *Elts[] = {
 553     GetTagConstant(VMContext, dwarf::DW_TAG_vector_type),
 554     NULL, //TheCU,
 555     MDString::get(VMContext, ""),
 556     NULL, //TheCU,
 557     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 558     ConstantInt::get(Type::getInt64Ty(VMContext), Size),
 559     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 560     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 561     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 562     Ty,
 563     Subscripts,
 564     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 565     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 566   };
 567   return DIType(MDNode::get(VMContext, Elts));
 568 }
 569
 570 /// createArtificialType - Create a new DIType with "artificial" flag set.
 571 DIType DIBuilder::createArtificialType(DIType Ty) {
 572   if (Ty.isArtificial())
 573     return Ty;
 574
 575   SmallVector<Value *, 9> Elts;
 576   MDNode *N = Ty;
 577   assert (N && "Unexpected input DIType!");
 578   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
 579     if (Value *V = N->getOperand(i))
 580       Elts.push_back(V);
 581     else
 582       Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)));
 583   }
 584
 585   unsigned CurFlags = Ty.getFlags();
 586   CurFlags = CurFlags | DIType::FlagArtificial;
 587
 588   // Flags are stored at this slot.
 589   Elts[8] =  ConstantInt::get(Type::getInt32Ty(VMContext), CurFlags);
 590
 591   return DIType(MDNode::get(VMContext, Elts));
 592 }
 593
 594 /// retainType - Retain DIType in a module even if it is not referenced
 595 /// through debug info anchors.
 596 void DIBuilder::retainType(DIType T) {
 597   AllRetainTypes.push_back(T);
 598 }
 599
 600 /// createUnspecifiedParameter - Create unspeicified type descriptor
 601 /// for the subroutine type.
 602 DIDescriptor DIBuilder::createUnspecifiedParameter() {
 603   Value *Elts[] = {
 604     GetTagConstant(VMContext, dwarf::DW_TAG_unspecified_parameters)
 605   };
 606   return DIDescriptor(MDNode::get(VMContext, Elts));
 607 }
 608
 609 /// createTemporaryType - Create a temporary forward-declared type.
 610 DIType DIBuilder::createTemporaryType() {
 611   // Give the temporary MDNode a tag. It doesn't matter what tag we
 612   // use here as long as DIType accepts it.
 613   Value *Elts[] = { GetTagConstant(VMContext, DW_TAG_base_type) };
 614   MDNode *Node = MDNode::getTemporary(VMContext, Elts);
 615   return DIType(Node);
 616 }
 617
 618 /// createTemporaryType - Create a temporary forward-declared type.
 619 DIType DIBuilder::createTemporaryType(DIFile F) {
 620   // Give the temporary MDNode a tag. It doesn't matter what tag we
 621   // use here as long as DIType accepts it.
 622   Value *Elts[] = {
 623     GetTagConstant(VMContext, DW_TAG_base_type),
 624     TheCU,
 625     NULL,
 626     F
 627   };
 628   MDNode *Node = MDNode::getTemporary(VMContext, Elts);
 629   return DIType(Node);
 630 }
 631
 632 /// getOrCreateArray - Get a DIArray, create one if required.
 633 DIArray DIBuilder::getOrCreateArray(ArrayRef<Value *> Elements) {
 634   if (Elements.empty()) {
 635     Value *Null = llvm::Constant::getNullValue(Type::getInt32Ty(VMContext));
 636     return DIArray(MDNode::get(VMContext, Null));
 637   }
 638   return DIArray(MDNode::get(VMContext, Elements));
 639 }
 640
 641 /// getOrCreateSubrange - Create a descriptor for a value range.  This
 642 /// implicitly uniques the values returned.
 643 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Hi) {
 644   Value *Elts[] = {
 645     GetTagConstant(VMContext, dwarf::DW_TAG_subrange_type),
 646     ConstantInt::get(Type::getInt64Ty(VMContext), Lo),
 647     ConstantInt::get(Type::getInt64Ty(VMContext), Hi)
 648   };
 649
 650   return DISubrange(MDNode::get(VMContext, Elts));
 651 }
 652
 653 /// createGlobalVariable - Create a new descriptor for the specified global.
 654 DIGlobalVariable DIBuilder::
 655 createGlobalVariable(StringRef Name, DIFile F, unsigned LineNumber,
 656                      DIType Ty, bool isLocalToUnit, llvm::Value *Val) {
 657   Value *Elts[] = {
 658     GetTagConstant(VMContext, dwarf::DW_TAG_variable),
 659     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 660     NULL, // TheCU,
 661     MDString::get(VMContext, Name),
 662     MDString::get(VMContext, Name),
 663     MDString::get(VMContext, Name),
 664     F,
 665     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 666     Ty,
 667     ConstantInt::get(Type::getInt32Ty(VMContext), isLocalToUnit),
 668     ConstantInt::get(Type::getInt32Ty(VMContext), 1), /* isDefinition*/
 669     Val
 670   };
 671   MDNode *Node = MDNode::get(VMContext, Elts);
 672   AllGVs.push_back(Node);
 673   return DIGlobalVariable(Node);
 674 }
 675
 676 /// createStaticVariable - Create a new descriptor for the specified static
 677 /// variable.
 678 DIGlobalVariable DIBuilder::
 679 createStaticVariable(DIDescriptor Context, StringRef Name,
 680                      StringRef LinkageName, DIFile F, unsigned LineNumber,
 681                      DIType Ty, bool isLocalToUnit, llvm::Value *Val) {
 682   Value *Elts[] = {
 683     GetTagConstant(VMContext, dwarf::DW_TAG_variable),
 684     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 685     getNonCompileUnitScope(Context),
 686     MDString::get(VMContext, Name),
 687     MDString::get(VMContext, Name),
 688     MDString::get(VMContext, LinkageName),
 689     F,
 690     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 691     Ty,
 692     ConstantInt::get(Type::getInt32Ty(VMContext), isLocalToUnit),
 693     ConstantInt::get(Type::getInt32Ty(VMContext), 1), /* isDefinition*/
 694     Val
 695   };
 696   MDNode *Node = MDNode::get(VMContext, Elts);
 697   AllGVs.push_back(Node);
 698   return DIGlobalVariable(Node);
 699 }
 700
 701 /// createVariable - Create a new descriptor for the specified variable.
 702 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
 703                                           StringRef Name, DIFile File,
 704                                           unsigned LineNo, DIType Ty,
 705                                           bool AlwaysPreserve, unsigned Flags,
 706                                           unsigned ArgNo) {
 707   Value *Elts[] = {
 708     GetTagConstant(VMContext, Tag),
 709     getNonCompileUnitScope(Scope),
 710     MDString::get(VMContext, Name),
 711     File,
 712     ConstantInt::get(Type::getInt32Ty(VMContext), (LineNo | (ArgNo << 24))),
 713     Ty,
 714     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 715     Constant::getNullValue(Type::getInt32Ty(VMContext)),
 716   };
 717   MDNode *Node = MDNode::get(VMContext, Elts);
 718   if (AlwaysPreserve) {
 719     // The optimizer may remove local variable. If there is an interest
 720     // to preserve variable info in such situation then stash it in a
 721     // named mdnode.
 722     DISubprogram Fn(getDISubprogram(Scope));
 723     NamedMDNode *FnLocals = getOrInsertFnSpecificMDNode(M, Fn);
 724     FnLocals->addOperand(Node);
 725   }
 726   return DIVariable(Node);
 727 }
 728
 729 /// createComplexVariable - Create a new descriptor for the specified variable
 730 /// which has a complex address expression for its address.
 731 DIVariable DIBuilder::createComplexVariable(unsigned Tag, DIDescriptor Scope,
 732                                             StringRef Name, DIFile F,
 733                                             unsigned LineNo,
 734                                             DIType Ty, ArrayRef<Value *> Addr,
 735                                             unsigned ArgNo) {
 736   SmallVector<Value *, 15> Elts;
 737   Elts.push_back(GetTagConstant(VMContext, Tag));
 738   Elts.push_back(getNonCompileUnitScope(Scope)),
 739   Elts.push_back(MDString::get(VMContext, Name));
 740   Elts.push_back(F);
 741   Elts.push_back(ConstantInt::get(Type::getInt32Ty(VMContext),
 742                                   (LineNo | (ArgNo << 24))));
 743   Elts.push_back(Ty);
 744   Elts.push_back(llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)));
 745   Elts.push_back(llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)));
 746   Elts.append(Addr.begin(), Addr.end());
 747
 748   return DIVariable(MDNode::get(VMContext, Elts));
 749 }
 750
 751 /// createFunction - Create a new descriptor for the specified function.
 752 DISubprogram DIBuilder::createFunction(DIDescriptor Context,
 753                                        StringRef Name,
 754                                        StringRef LinkageName,
 755                                        DIFile File, unsigned LineNo,
 756                                        DIType Ty,
 757                                        bool isLocalToUnit, bool isDefinition,
 758                                        unsigned Flags, bool isOptimized,
 759                                        Function *Fn,
 760                                        MDNode *TParams,
 761                                        MDNode *Decl) {
 762   Value *TElts[] = { GetTagConstant(VMContext, DW_TAG_base_type) };
 763   MDNode *Temp = MDNode::getTemporary(VMContext, TElts);
 764   Value *TVElts[] = { Temp };
 765   MDNode *THolder = MDNode::get(VMContext, TVElts);
 766
 767   Value *Elts[] = {
 768     GetTagConstant(VMContext, dwarf::DW_TAG_subprogram),
 769     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 770     getNonCompileUnitScope(Context),
 771     MDString::get(VMContext, Name),
 772     MDString::get(VMContext, Name),
 773     MDString::get(VMContext, LinkageName),
 774     File,
 775     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
 776     Ty,
 777     ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
 778     ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
 779     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 780     ConstantInt::get(Type::getInt32Ty(VMContext), 0),
 781     NULL,
 782     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 783     ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
 784     Fn,
 785     TParams,
 786     Decl,
 787     THolder
 788   };
 789   MDNode *Node = MDNode::get(VMContext, Elts);
 790
 791   // Create a named metadata so that we do not lose this mdnode.
 792   AllSubprograms.push_back(Node);
 793   return DISubprogram(Node);
 794 }
 795
 796 /// createMethod - Create a new descriptor for the specified C++ method.
 797 DISubprogram DIBuilder::createMethod(DIDescriptor Context,
 798                                      StringRef Name,
 799                                      StringRef LinkageName,
 800                                      DIFile F,
 801                                      unsigned LineNo, DIType Ty,
 802                                      bool isLocalToUnit,
 803                                      bool isDefinition,
 804                                      unsigned VK, unsigned VIndex,
 805                                      MDNode *VTableHolder,
 806                                      unsigned Flags,
 807                                      bool isOptimized,
 808                                      Function *Fn,
 809                                      MDNode *TParam) {
 810   Value *TElts[] = { GetTagConstant(VMContext, DW_TAG_base_type) };
 811   MDNode *Temp = MDNode::getTemporary(VMContext, TElts);
 812   Value *TVElts[] = { Temp };
 813   MDNode *THolder = MDNode::get(VMContext, TVElts);
 814
 815   Value *Elts[] = {
 816     GetTagConstant(VMContext, dwarf::DW_TAG_subprogram),
 817     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 818     getNonCompileUnitScope(Context),
 819     MDString::get(VMContext, Name),
 820     MDString::get(VMContext, Name),
 821     MDString::get(VMContext, LinkageName),
 822     F,
 823     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
 824     Ty,
 825     ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
 826     ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
 827     ConstantInt::get(Type::getInt32Ty(VMContext), (unsigned)VK),
 828     ConstantInt::get(Type::getInt32Ty(VMContext), VIndex),
 829     VTableHolder,
 830     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 831     ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
 832     Fn,
 833     TParam,
 834     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 835     THolder
 836   };
 837   MDNode *Node = MDNode::get(VMContext, Elts);
 838   return DISubprogram(Node);
 839 }
 840
 841 /// createNameSpace - This creates new descriptor for a namespace
 842 /// with the specified parent scope.
 843 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
 844                                        DIFile File, unsigned LineNo) {
 845   Value *Elts[] = {
 846     GetTagConstant(VMContext, dwarf::DW_TAG_namespace),
 847     getNonCompileUnitScope(Scope),
 848     MDString::get(VMContext, Name),
 849     File,
 850     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo)
 851   };
 852   return DINameSpace(MDNode::get(VMContext, Elts));
 853 }
 854
 855 /// createLexicalBlockFile - This creates a new MDNode that encapsulates
 856 /// an existing scope with a new filename.
 857 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
 858                                                      DIFile File) {
 859   Value *Elts[] = {
 860     GetTagConstant(VMContext, dwarf::DW_TAG_lexical_block),
 861     Scope,
 862     File
 863   };
 864   return DILexicalBlockFile(MDNode::get(VMContext, Elts));
 865 }
 866
 867 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
 868                                              unsigned Line, unsigned Col) {
 869   // Defeat MDNode uniqing for lexical blocks by using unique id.
 870   static unsigned int unique_id = 0;
 871   Value *Elts[] = {
 872     GetTagConstant(VMContext, dwarf::DW_TAG_lexical_block),
 873     getNonCompileUnitScope(Scope),
 874     ConstantInt::get(Type::getInt32Ty(VMContext), Line),
 875     ConstantInt::get(Type::getInt32Ty(VMContext), Col),
 876     File,
 877     ConstantInt::get(Type::getInt32Ty(VMContext), unique_id++)
 878   };
 879   return DILexicalBlock(MDNode::get(VMContext, Elts));
 880 }
 881
 882 /// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
 883 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
 884                                       Instruction *InsertBefore) {
 885   assert(Storage && "no storage passed to dbg.declare");
 886   assert(VarInfo.Verify() && "empty DIVariable passed to dbg.declare");
 887   if (!DeclareFn)
 888     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
 889
 890   Value *Args[] = { MDNode::get(Storage->getContext(), Storage), VarInfo };
 891   return CallInst::Create(DeclareFn, Args, "", InsertBefore);
 892 }
 893
 894 /// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
 895 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
 896                                       BasicBlock *InsertAtEnd) {
 897   assert(Storage && "no storage passed to dbg.declare");
 898   assert(VarInfo.Verify() && "invalid DIVariable passed to dbg.declare");
 899   if (!DeclareFn)
 900     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
 901
 902   Value *Args[] = { MDNode::get(Storage->getContext(), Storage), VarInfo };
 903
 904   // If this block already has a terminator then insert this intrinsic
 905   // before the terminator.
 906   if (TerminatorInst *T = InsertAtEnd->getTerminator())
 907     return CallInst::Create(DeclareFn, Args, "", T);
 908   else
 909     return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
 910 }
 911
 912 /// insertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
 913 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
 914                                                 DIVariable VarInfo,
 915                                                 Instruction *InsertBefore) {
 916   assert(V && "no value passed to dbg.value");
 917   assert(VarInfo.Verify() && "invalid DIVariable passed to dbg.value");
 918   if (!ValueFn)
 919     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
 920
 921   Value *Args[] = { MDNode::get(V->getContext(), V),
 922                     ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
 923                     VarInfo };
 924   return CallInst::Create(ValueFn, Args, "", InsertBefore);
 925 }
 926
 927 /// insertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
 928 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
 929                                                 DIVariable VarInfo,
 930                                                 BasicBlock *InsertAtEnd) {
 931   assert(V && "no value passed to dbg.value");
 932   assert(VarInfo.Verify() && "invalid DIVariable passed to dbg.value");
 933   if (!ValueFn)
 934     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
 935
 936   Value *Args[] = { MDNode::get(V->getContext(), V),
 937                     ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
 938                     VarInfo };
 939   return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
 940 }