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