lib/Analysis/DebugInfo.cpp

   1 //===--- DebugInfo.cpp - Debug Information Helper Classes -----------------===//
   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 helper classes used to build and interpret debug
  11 // information in LLVM IR form.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/Analysis/DebugInfo.h"
  16 #include "llvm/Constants.h"
  17 #include "llvm/DerivedTypes.h"
  18 #include "llvm/Intrinsics.h"
  19 #include "llvm/IntrinsicInst.h"
  20 #include "llvm/Instructions.h"
  21 #include "llvm/Module.h"
  22 #include "llvm/Analysis/ValueTracking.h"
  23 #include "llvm/ADT/SmallPtrSet.h"
  24 #include "llvm/Support/Debug.h"
  25 #include "llvm/Support/Dwarf.h"
  26 #include "llvm/Support/DebugLoc.h"
  27 #include "llvm/Support/raw_ostream.h"
  28 using namespace llvm;
  29 using namespace llvm::dwarf;
  30
  31 //===----------------------------------------------------------------------===//
  32 // DIDescriptor
  33 //===----------------------------------------------------------------------===//
  34
  35 /// ValidDebugInfo - Return true if V represents valid debug info value.
  36 /// FIXME : Add DIDescriptor.isValid()
  37 bool DIDescriptor::ValidDebugInfo(MDNode *N, CodeGenOpt::Level OptLevel) {
  38   if (!N)
  39     return false;
  40
  41   DIDescriptor DI(N);
  42
  43   // Check current version. Allow Version6 for now.
  44   unsigned Version = DI.getVersion();
  45   if (Version != LLVMDebugVersion && Version != LLVMDebugVersion6)
  46     return false;
  47
  48   unsigned Tag = DI.getTag();
  49   switch (Tag) {
  50   case DW_TAG_variable:
  51     assert(DIVariable(N).Verify() && "Invalid DebugInfo value");
  52     break;
  53   case DW_TAG_compile_unit:
  54     assert(DICompileUnit(N).Verify() && "Invalid DebugInfo value");
  55     break;
  56   case DW_TAG_subprogram:
  57     assert(DISubprogram(N).Verify() && "Invalid DebugInfo value");
  58     break;
  59   case DW_TAG_lexical_block:
  60     // FIXME: This interfers with the quality of generated code during
  61     // optimization.
  62     if (OptLevel != CodeGenOpt::None)
  63       return false;
  64     // FALLTHROUGH
  65   default:
  66     break;
  67   }
  68
  69   return true;
  70 }
  71
  72 DIDescriptor::DIDescriptor(MDNode *N, unsigned RequiredTag) {
  73   DbgNode = N;
  74
  75   // If this is non-null, check to see if the Tag matches. If not, set to null.
  76   if (N && getTag() != RequiredTag) {
  77     DbgNode = 0;
  78   }
  79 }
  80
  81 StringRef
  82 DIDescriptor::getStringField(unsigned Elt) const {
  83   if (DbgNode == 0)
  84     return StringRef();
  85
  86   if (Elt < DbgNode->getNumElements())
  87     if (MDString *MDS = dyn_cast_or_null<MDString>(DbgNode->getElement(Elt)))
  88       return MDS->getString();
  89
  90   return StringRef();
  91 }
  92
  93 uint64_t DIDescriptor::getUInt64Field(unsigned Elt) const {
  94   if (DbgNode == 0)
  95     return 0;
  96
  97   if (Elt < DbgNode->getNumElements())
  98     if (ConstantInt *CI = dyn_cast<ConstantInt>(DbgNode->getElement(Elt)))
  99       return CI->getZExtValue();
 100
 101   return 0;
 102 }
 103
 104 DIDescriptor DIDescriptor::getDescriptorField(unsigned Elt) const {
 105   if (DbgNode == 0)
 106     return DIDescriptor();
 107
 108   if (Elt < DbgNode->getNumElements() && DbgNode->getElement(Elt))
 109     return DIDescriptor(dyn_cast<MDNode>(DbgNode->getElement(Elt)));
 110
 111   return DIDescriptor();
 112 }
 113
 114 GlobalVariable *DIDescriptor::getGlobalVariableField(unsigned Elt) const {
 115   if (DbgNode == 0)
 116     return 0;
 117
 118   if (Elt < DbgNode->getNumElements())
 119       return dyn_cast_or_null<GlobalVariable>(DbgNode->getElement(Elt));
 120   return 0;
 121 }
 122
 123 //===----------------------------------------------------------------------===//
 124 // Predicates
 125 //===----------------------------------------------------------------------===//
 126
 127 /// isBasicType - Return true if the specified tag is legal for
 128 /// DIBasicType.
 129 bool DIDescriptor::isBasicType() const {
 130   assert (!isNull() && "Invalid descriptor!");
 131   unsigned Tag = getTag();
 132
 133   return Tag == dwarf::DW_TAG_base_type;
 134 }
 135
 136 /// isDerivedType - Return true if the specified tag is legal for DIDerivedType.
 137 bool DIDescriptor::isDerivedType() const {
 138   assert (!isNull() && "Invalid descriptor!");
 139   unsigned Tag = getTag();
 140
 141   switch (Tag) {
 142   case dwarf::DW_TAG_typedef:
 143   case dwarf::DW_TAG_pointer_type:
 144   case dwarf::DW_TAG_reference_type:
 145   case dwarf::DW_TAG_const_type:
 146   case dwarf::DW_TAG_volatile_type:
 147   case dwarf::DW_TAG_restrict_type:
 148   case dwarf::DW_TAG_member:
 149   case dwarf::DW_TAG_inheritance:
 150     return true;
 151   default:
 152     // CompositeTypes are currently modelled as DerivedTypes.
 153     return isCompositeType();
 154   }
 155 }
 156
 157 /// isCompositeType - Return true if the specified tag is legal for
 158 /// DICompositeType.
 159 bool DIDescriptor::isCompositeType() const {
 160   assert (!isNull() && "Invalid descriptor!");
 161   unsigned Tag = getTag();
 162
 163   switch (Tag) {
 164   case dwarf::DW_TAG_array_type:
 165   case dwarf::DW_TAG_structure_type:
 166   case dwarf::DW_TAG_union_type:
 167   case dwarf::DW_TAG_enumeration_type:
 168   case dwarf::DW_TAG_vector_type:
 169   case dwarf::DW_TAG_subroutine_type:
 170   case dwarf::DW_TAG_class_type:
 171     return true;
 172   default:
 173     return false;
 174   }
 175 }
 176
 177 /// isVariable - Return true if the specified tag is legal for DIVariable.
 178 bool DIDescriptor::isVariable() const {
 179   assert (!isNull() && "Invalid descriptor!");
 180   unsigned Tag = getTag();
 181
 182   switch (Tag) {
 183   case dwarf::DW_TAG_auto_variable:
 184   case dwarf::DW_TAG_arg_variable:
 185   case dwarf::DW_TAG_return_variable:
 186     return true;
 187   default:
 188     return false;
 189   }
 190 }
 191
 192 /// isType - Return true if the specified tag is legal for DIType.
 193 bool DIDescriptor::isType() const {
 194   return isBasicType() || isCompositeType() || isDerivedType();
 195 }
 196
 197 /// isSubprogram - Return true if the specified tag is legal for
 198 /// DISubprogram.
 199 bool DIDescriptor::isSubprogram() const {
 200   assert (!isNull() && "Invalid descriptor!");
 201   unsigned Tag = getTag();
 202
 203   return Tag == dwarf::DW_TAG_subprogram;
 204 }
 205
 206 /// isGlobalVariable - Return true if the specified tag is legal for
 207 /// DIGlobalVariable.
 208 bool DIDescriptor::isGlobalVariable() const {
 209   assert (!isNull() && "Invalid descriptor!");
 210   unsigned Tag = getTag();
 211
 212   return Tag == dwarf::DW_TAG_variable;
 213 }
 214
 215 /// isGlobal - Return true if the specified tag is legal for DIGlobal.
 216 bool DIDescriptor::isGlobal() const {
 217   return isGlobalVariable();
 218 }
 219
 220 /// isScope - Return true if the specified tag is one of the scope
 221 /// related tag.
 222 bool DIDescriptor::isScope() const {
 223   assert (!isNull() && "Invalid descriptor!");
 224   unsigned Tag = getTag();
 225
 226   switch (Tag) {
 227     case dwarf::DW_TAG_compile_unit:
 228     case dwarf::DW_TAG_lexical_block:
 229     case dwarf::DW_TAG_subprogram:
 230     case dwarf::DW_TAG_namespace:
 231       return true;
 232     default:
 233       break;
 234   }
 235   return false;
 236 }
 237
 238 /// isCompileUnit - Return true if the specified tag is DW_TAG_compile_unit.
 239 bool DIDescriptor::isCompileUnit() const {
 240   assert (!isNull() && "Invalid descriptor!");
 241   unsigned Tag = getTag();
 242
 243   return Tag == dwarf::DW_TAG_compile_unit;
 244 }
 245
 246 /// isNameSpace - Return true if the specified tag is DW_TAG_namespace.
 247 bool DIDescriptor::isNameSpace() const {
 248   assert (!isNull() && "Invalid descriptor!");
 249   unsigned Tag = getTag();
 250
 251   return Tag == dwarf::DW_TAG_namespace;
 252 }
 253
 254 /// isLexicalBlock - Return true if the specified tag is DW_TAG_lexical_block.
 255 bool DIDescriptor::isLexicalBlock() const {
 256   assert (!isNull() && "Invalid descriptor!");
 257   unsigned Tag = getTag();
 258
 259   return Tag == dwarf::DW_TAG_lexical_block;
 260 }
 261
 262 /// isSubrange - Return true if the specified tag is DW_TAG_subrange_type.
 263 bool DIDescriptor::isSubrange() const {
 264   assert (!isNull() && "Invalid descriptor!");
 265   unsigned Tag = getTag();
 266
 267   return Tag == dwarf::DW_TAG_subrange_type;
 268 }
 269
 270 /// isEnumerator - Return true if the specified tag is DW_TAG_enumerator.
 271 bool DIDescriptor::isEnumerator() const {
 272   assert (!isNull() && "Invalid descriptor!");
 273   unsigned Tag = getTag();
 274
 275   return Tag == dwarf::DW_TAG_enumerator;
 276 }
 277
 278 //===----------------------------------------------------------------------===//
 279 // Simple Descriptor Constructors and other Methods
 280 //===----------------------------------------------------------------------===//
 281
 282 DIType::DIType(MDNode *N) : DIDescriptor(N) {
 283   if (!N) return;
 284   if (!isBasicType() && !isDerivedType() && !isCompositeType()) {
 285     DbgNode = 0;
 286   }
 287 }
 288
 289 unsigned DIArray::getNumElements() const {
 290   assert (DbgNode && "Invalid DIArray");
 291   return DbgNode->getNumElements();
 292 }
 293
 294 /// replaceAllUsesWith - Replace all uses of debug info referenced by
 295 /// this descriptor. After this completes, the current debug info value
 296 /// is erased.
 297 void DIDerivedType::replaceAllUsesWith(DIDescriptor &D) {
 298   if (isNull())
 299     return;
 300
 301   assert (!D.isNull() && "Can not replace with null");
 302
 303   // Since we use a TrackingVH for the node, its easy for clients to manufacture
 304   // legitimate situations where they want to replaceAllUsesWith() on something
 305   // which, due to uniquing, has merged with the source. We shield clients from
 306   // this detail by allowing a value to be replaced with replaceAllUsesWith()
 307   // itself.
 308   if (getNode() != D.getNode()) {
 309     MDNode *Node = DbgNode;
 310     Node->replaceAllUsesWith(D.getNode());
 311     delete Node;
 312   }
 313 }
 314
 315 /// Verify - Verify that a compile unit is well formed.
 316 bool DICompileUnit::Verify() const {
 317   if (isNull())
 318     return false;
 319   StringRef N = getFilename();
 320   if (N.empty())
 321     return false;
 322   // It is possible that directory and produce string is empty.
 323   return true;
 324 }
 325
 326 /// Verify - Verify that a type descriptor is well formed.
 327 bool DIType::Verify() const {
 328   if (isNull())
 329     return false;
 330   if (getContext().isNull())
 331     return false;
 332
 333   DICompileUnit CU = getCompileUnit();
 334   if (!CU.isNull() && !CU.Verify())
 335     return false;
 336   return true;
 337 }
 338
 339 /// Verify - Verify that a composite type descriptor is well formed.
 340 bool DICompositeType::Verify() const {
 341   if (isNull())
 342     return false;
 343   if (getContext().isNull())
 344     return false;
 345
 346   DICompileUnit CU = getCompileUnit();
 347   if (!CU.isNull() && !CU.Verify())
 348     return false;
 349   return true;
 350 }
 351
 352 /// Verify - Verify that a subprogram descriptor is well formed.
 353 bool DISubprogram::Verify() const {
 354   if (isNull())
 355     return false;
 356
 357   if (getContext().isNull())
 358     return false;
 359
 360   DICompileUnit CU = getCompileUnit();
 361   if (!CU.Verify())
 362     return false;
 363
 364   DICompositeType Ty = getType();
 365   if (!Ty.isNull() && !Ty.Verify())
 366     return false;
 367   return true;
 368 }
 369
 370 /// Verify - Verify that a global variable descriptor is well formed.
 371 bool DIGlobalVariable::Verify() const {
 372   if (isNull())
 373     return false;
 374
 375   if (getDisplayName().empty())
 376     return false;
 377
 378   if (getContext().isNull())
 379     return false;
 380
 381   DICompileUnit CU = getCompileUnit();
 382   if (!CU.isNull() && !CU.Verify())
 383     return false;
 384
 385   DIType Ty = getType();
 386   if (!Ty.Verify())
 387     return false;
 388
 389   if (!getGlobal())
 390     return false;
 391
 392   return true;
 393 }
 394
 395 /// Verify - Verify that a variable descriptor is well formed.
 396 bool DIVariable::Verify() const {
 397   if (isNull())
 398     return false;
 399
 400   if (getContext().isNull())
 401     return false;
 402
 403   DIType Ty = getType();
 404   if (!Ty.Verify())
 405     return false;
 406
 407   return true;
 408 }
 409
 410 /// getOriginalTypeSize - If this type is derived from a base type then
 411 /// return base type size.
 412 uint64_t DIDerivedType::getOriginalTypeSize() const {
 413   unsigned Tag = getTag();
 414   if (Tag == dwarf::DW_TAG_member || Tag == dwarf::DW_TAG_typedef ||
 415       Tag == dwarf::DW_TAG_const_type || Tag == dwarf::DW_TAG_volatile_type ||
 416       Tag == dwarf::DW_TAG_restrict_type) {
 417     DIType BaseType = getTypeDerivedFrom();
 418     // If this type is not derived from any type then take conservative
 419     // approach.
 420     if (BaseType.isNull())
 421       return getSizeInBits();
 422     if (BaseType.isDerivedType())
 423       return DIDerivedType(BaseType.getNode()).getOriginalTypeSize();
 424     else
 425       return BaseType.getSizeInBits();
 426   }
 427
 428   return getSizeInBits();
 429 }
 430
 431 /// describes - Return true if this subprogram provides debugging
 432 /// information for the function F.
 433 bool DISubprogram::describes(const Function *F) {
 434   assert (F && "Invalid function");
 435   StringRef Name = getLinkageName();
 436   if (Name.empty())
 437     Name = getName();
 438   if (F->getName() == Name)
 439     return true;
 440   return false;
 441 }
 442
 443 StringRef DIScope::getFilename() const {
 444   if (isLexicalBlock())
 445     return DILexicalBlock(DbgNode).getFilename();
 446   else if (isSubprogram())
 447     return DISubprogram(DbgNode).getFilename();
 448   else if (isCompileUnit())
 449     return DICompileUnit(DbgNode).getFilename();
 450   else if (isNameSpace())
 451     return DINameSpace(DbgNode).getFilename();
 452   else
 453     assert (0 && "Invalid DIScope!");
 454   return StringRef();
 455 }
 456
 457 StringRef DIScope::getDirectory() const {
 458   if (isLexicalBlock())
 459     return DILexicalBlock(DbgNode).getDirectory();
 460   else if (isSubprogram())
 461     return DISubprogram(DbgNode).getDirectory();
 462   else if (isCompileUnit())
 463     return DICompileUnit(DbgNode).getDirectory();
 464   else if (isNameSpace())
 465     return DINameSpace(DbgNode).getDirectory();
 466   else
 467     assert (0 && "Invalid DIScope!");
 468   return StringRef();
 469 }
 470
 471 //===----------------------------------------------------------------------===//
 472 // DIDescriptor: dump routines for all descriptors.
 473 //===----------------------------------------------------------------------===//
 474
 475
 476 /// dump - Print descriptor.
 477 void DIDescriptor::dump() const {
 478   dbgs() << "[" << dwarf::TagString(getTag()) << "] ";
 479   dbgs().write_hex((intptr_t) &*DbgNode) << ']';
 480 }
 481
 482 /// dump - Print compile unit.
 483 void DICompileUnit::dump() const {
 484   if (getLanguage())
 485     dbgs() << " [" << dwarf::LanguageString(getLanguage()) << "] ";
 486
 487   dbgs() << " [" << getDirectory() << "/" << getFilename() << " ]";
 488 }
 489
 490 /// dump - Print type.
 491 void DIType::dump() const {
 492   if (isNull()) return;
 493
 494   StringRef Res = getName();
 495   if (!Res.empty())
 496     dbgs() << " [" << Res << "] ";
 497
 498   unsigned Tag = getTag();
 499   dbgs() << " [" << dwarf::TagString(Tag) << "] ";
 500
 501   // TODO : Print context
 502   getCompileUnit().dump();
 503   dbgs() << " ["
 504          << getLineNumber() << ", "
 505          << getSizeInBits() << ", "
 506          << getAlignInBits() << ", "
 507          << getOffsetInBits()
 508          << "] ";
 509
 510   if (isPrivate())
 511     dbgs() << " [private] ";
 512   else if (isProtected())
 513     dbgs() << " [protected] ";
 514
 515   if (isForwardDecl())
 516     dbgs() << " [fwd] ";
 517
 518   if (isBasicType())
 519     DIBasicType(DbgNode).dump();
 520   else if (isDerivedType())
 521     DIDerivedType(DbgNode).dump();
 522   else if (isCompositeType())
 523     DICompositeType(DbgNode).dump();
 524   else {
 525     dbgs() << "Invalid DIType\n";
 526     return;
 527   }
 528
 529   dbgs() << "\n";
 530 }
 531
 532 /// dump - Print basic type.
 533 void DIBasicType::dump() const {
 534   dbgs() << " [" << dwarf::AttributeEncodingString(getEncoding()) << "] ";
 535 }
 536
 537 /// dump - Print derived type.
 538 void DIDerivedType::dump() const {
 539   dbgs() << "\n\t Derived From: "; getTypeDerivedFrom().dump();
 540 }
 541
 542 /// dump - Print composite type.
 543 void DICompositeType::dump() const {
 544   DIArray A = getTypeArray();
 545   if (A.isNull())
 546     return;
 547   dbgs() << " [" << A.getNumElements() << " elements]";
 548 }
 549
 550 /// dump - Print global.
 551 void DIGlobal::dump() const {
 552   StringRef Res = getName();
 553   if (!Res.empty())
 554     dbgs() << " [" << Res << "] ";
 555
 556   unsigned Tag = getTag();
 557   dbgs() << " [" << dwarf::TagString(Tag) << "] ";
 558
 559   // TODO : Print context
 560   getCompileUnit().dump();
 561   dbgs() << " [" << getLineNumber() << "] ";
 562
 563   if (isLocalToUnit())
 564     dbgs() << " [local] ";
 565
 566   if (isDefinition())
 567     dbgs() << " [def] ";
 568
 569   if (isGlobalVariable())
 570     DIGlobalVariable(DbgNode).dump();
 571
 572   dbgs() << "\n";
 573 }
 574
 575 /// dump - Print subprogram.
 576 void DISubprogram::dump() const {
 577   StringRef Res = getName();
 578   if (!Res.empty())
 579     dbgs() << " [" << Res << "] ";
 580
 581   unsigned Tag = getTag();
 582   dbgs() << " [" << dwarf::TagString(Tag) << "] ";
 583
 584   // TODO : Print context
 585   getCompileUnit().dump();
 586   dbgs() << " [" << getLineNumber() << "] ";
 587
 588   if (isLocalToUnit())
 589     dbgs() << " [local] ";
 590
 591   if (isDefinition())
 592     dbgs() << " [def] ";
 593
 594   dbgs() << "\n";
 595 }
 596
 597 /// dump - Print global variable.
 598 void DIGlobalVariable::dump() const {
 599   dbgs() << " [";
 600   getGlobal()->dump();
 601   dbgs() << "] ";
 602 }
 603
 604 /// dump - Print variable.
 605 void DIVariable::dump() const {
 606   StringRef Res = getName();
 607   if (!Res.empty())
 608     dbgs() << " [" << Res << "] ";
 609
 610   getCompileUnit().dump();
 611   dbgs() << " [" << getLineNumber() << "] ";
 612   getType().dump();
 613   dbgs() << "\n";
 614
 615   // FIXME: Dump complex addresses
 616 }
 617
 618 //===----------------------------------------------------------------------===//
 619 // DIFactory: Basic Helpers
 620 //===----------------------------------------------------------------------===//
 621
 622 DIFactory::DIFactory(Module &m)
 623   : M(m), VMContext(M.getContext()), DeclareFn(0) {
 624   EmptyStructPtr = PointerType::getUnqual(StructType::get(VMContext));
 625 }
 626
 627 Constant *DIFactory::GetTagConstant(unsigned TAG) {
 628   assert((TAG & LLVMDebugVersionMask) == 0 &&
 629          "Tag too large for debug encoding!");
 630   return ConstantInt::get(Type::getInt32Ty(VMContext), TAG | LLVMDebugVersion);
 631 }
 632
 633 //===----------------------------------------------------------------------===//
 634 // DIFactory: Primary Constructors
 635 //===----------------------------------------------------------------------===//
 636
 637 /// GetOrCreateArray - Create an descriptor for an array of descriptors.
 638 /// This implicitly uniques the arrays created.
 639 DIArray DIFactory::GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys) {
 640   SmallVector<Value*, 16> Elts;
 641
 642   if (NumTys == 0)
 643     Elts.push_back(llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)));
 644   else
 645     for (unsigned i = 0; i != NumTys; ++i)
 646       Elts.push_back(Tys[i].getNode());
 647
 648   return DIArray(MDNode::get(VMContext,Elts.data(), Elts.size()));
 649 }
 650
 651 /// GetOrCreateSubrange - Create a descriptor for a value range.  This
 652 /// implicitly uniques the values returned.
 653 DISubrange DIFactory::GetOrCreateSubrange(int64_t Lo, int64_t Hi) {
 654   Value *Elts[] = {
 655     GetTagConstant(dwarf::DW_TAG_subrange_type),
 656     ConstantInt::get(Type::getInt64Ty(VMContext), Lo),
 657     ConstantInt::get(Type::getInt64Ty(VMContext), Hi)
 658   };
 659
 660   return DISubrange(MDNode::get(VMContext, &Elts[0], 3));
 661 }
 662
 663
 664
 665 /// CreateCompileUnit - Create a new descriptor for the specified compile
 666 /// unit.  Note that this does not unique compile units within the module.
 667 DICompileUnit DIFactory::CreateCompileUnit(unsigned LangID,
 668                                            StringRef Filename,
 669                                            StringRef Directory,
 670                                            StringRef Producer,
 671                                            bool isMain,
 672                                            bool isOptimized,
 673                                            StringRef Flags,
 674                                            unsigned RunTimeVer) {
 675   Value *Elts[] = {
 676     GetTagConstant(dwarf::DW_TAG_compile_unit),
 677     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 678     ConstantInt::get(Type::getInt32Ty(VMContext), LangID),
 679     MDString::get(VMContext, Filename),
 680     MDString::get(VMContext, Directory),
 681     MDString::get(VMContext, Producer),
 682     ConstantInt::get(Type::getInt1Ty(VMContext), isMain),
 683     ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
 684     MDString::get(VMContext, Flags),
 685     ConstantInt::get(Type::getInt32Ty(VMContext), RunTimeVer)
 686   };
 687
 688   return DICompileUnit(MDNode::get(VMContext, &Elts[0], 10));
 689 }
 690
 691 /// CreateEnumerator - Create a single enumerator value.
 692 DIEnumerator DIFactory::CreateEnumerator(StringRef Name, uint64_t Val){
 693   Value *Elts[] = {
 694     GetTagConstant(dwarf::DW_TAG_enumerator),
 695     MDString::get(VMContext, Name),
 696     ConstantInt::get(Type::getInt64Ty(VMContext), Val)
 697   };
 698   return DIEnumerator(MDNode::get(VMContext, &Elts[0], 3));
 699 }
 700
 701
 702 /// CreateBasicType - Create a basic type like int, float, etc.
 703 DIBasicType DIFactory::CreateBasicType(DIDescriptor Context,
 704                                        StringRef Name,
 705                                        DICompileUnit CompileUnit,
 706                                        unsigned LineNumber,
 707                                        uint64_t SizeInBits,
 708                                        uint64_t AlignInBits,
 709                                        uint64_t OffsetInBits, unsigned Flags,
 710                                        unsigned Encoding) {
 711   Value *Elts[] = {
 712     GetTagConstant(dwarf::DW_TAG_base_type),
 713     Context.getNode(),
 714     MDString::get(VMContext, Name),
 715     CompileUnit.getNode(),
 716     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 717     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 718     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 719     ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
 720     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 721     ConstantInt::get(Type::getInt32Ty(VMContext), Encoding)
 722   };
 723   return DIBasicType(MDNode::get(VMContext, &Elts[0], 10));
 724 }
 725
 726
 727 /// CreateBasicType - Create a basic type like int, float, etc.
 728 DIBasicType DIFactory::CreateBasicTypeEx(DIDescriptor Context,
 729                                          StringRef Name,
 730                                          DICompileUnit CompileUnit,
 731                                          unsigned LineNumber,
 732                                          Constant *SizeInBits,
 733                                          Constant *AlignInBits,
 734                                          Constant *OffsetInBits, unsigned Flags,
 735                                          unsigned Encoding) {
 736   Value *Elts[] = {
 737     GetTagConstant(dwarf::DW_TAG_base_type),
 738     Context.getNode(),
 739     MDString::get(VMContext, Name),
 740     CompileUnit.getNode(),
 741     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 742     SizeInBits,
 743     AlignInBits,
 744     OffsetInBits,
 745     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 746     ConstantInt::get(Type::getInt32Ty(VMContext), Encoding)
 747   };
 748   return DIBasicType(MDNode::get(VMContext, &Elts[0], 10));
 749 }
 750
 751
 752 /// CreateDerivedType - Create a derived type like const qualified type,
 753 /// pointer, typedef, etc.
 754 DIDerivedType DIFactory::CreateDerivedType(unsigned Tag,
 755                                            DIDescriptor Context,
 756                                            StringRef Name,
 757                                            DICompileUnit CompileUnit,
 758                                            unsigned LineNumber,
 759                                            uint64_t SizeInBits,
 760                                            uint64_t AlignInBits,
 761                                            uint64_t OffsetInBits,
 762                                            unsigned Flags,
 763                                            DIType DerivedFrom) {
 764   Value *Elts[] = {
 765     GetTagConstant(Tag),
 766     Context.getNode(),
 767     MDString::get(VMContext, Name),
 768     CompileUnit.getNode(),
 769     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 770     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 771     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 772     ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
 773     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 774     DerivedFrom.getNode(),
 775   };
 776   return DIDerivedType(MDNode::get(VMContext, &Elts[0], 10));
 777 }
 778
 779
 780 /// CreateDerivedType - Create a derived type like const qualified type,
 781 /// pointer, typedef, etc.
 782 DIDerivedType DIFactory::CreateDerivedTypeEx(unsigned Tag,
 783                                              DIDescriptor Context,
 784                                              StringRef Name,
 785                                              DICompileUnit CompileUnit,
 786                                              unsigned LineNumber,
 787                                              Constant *SizeInBits,
 788                                              Constant *AlignInBits,
 789                                              Constant *OffsetInBits,
 790                                              unsigned Flags,
 791                                              DIType DerivedFrom) {
 792   Value *Elts[] = {
 793     GetTagConstant(Tag),
 794     Context.getNode(),
 795     MDString::get(VMContext, Name),
 796     CompileUnit.getNode(),
 797     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 798     SizeInBits,
 799     AlignInBits,
 800     OffsetInBits,
 801     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 802     DerivedFrom.getNode(),
 803   };
 804   return DIDerivedType(MDNode::get(VMContext, &Elts[0], 10));
 805 }
 806
 807
 808 /// CreateCompositeType - Create a composite type like array, struct, etc.
 809 DICompositeType DIFactory::CreateCompositeType(unsigned Tag,
 810                                                DIDescriptor Context,
 811                                                StringRef Name,
 812                                                DICompileUnit CompileUnit,
 813                                                unsigned LineNumber,
 814                                                uint64_t SizeInBits,
 815                                                uint64_t AlignInBits,
 816                                                uint64_t OffsetInBits,
 817                                                unsigned Flags,
 818                                                DIType DerivedFrom,
 819                                                DIArray Elements,
 820                                                unsigned RuntimeLang) {
 821
 822   Value *Elts[] = {
 823     GetTagConstant(Tag),
 824     Context.getNode(),
 825     MDString::get(VMContext, Name),
 826     CompileUnit.getNode(),
 827     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 828     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 829     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 830     ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
 831     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 832     DerivedFrom.getNode(),
 833     Elements.getNode(),
 834     ConstantInt::get(Type::getInt32Ty(VMContext), RuntimeLang)
 835   };
 836   return DICompositeType(MDNode::get(VMContext, &Elts[0], 12));
 837 }
 838
 839
 840 /// CreateCompositeType - Create a composite type like array, struct, etc.
 841 DICompositeType DIFactory::CreateCompositeTypeEx(unsigned Tag,
 842                                                  DIDescriptor Context,
 843                                                  StringRef Name,
 844                                                  DICompileUnit CompileUnit,
 845                                                  unsigned LineNumber,
 846                                                  Constant *SizeInBits,
 847                                                  Constant *AlignInBits,
 848                                                  Constant *OffsetInBits,
 849                                                  unsigned Flags,
 850                                                  DIType DerivedFrom,
 851                                                  DIArray Elements,
 852                                                  unsigned RuntimeLang) {
 853
 854   Value *Elts[] = {
 855     GetTagConstant(Tag),
 856     Context.getNode(),
 857     MDString::get(VMContext, Name),
 858     CompileUnit.getNode(),
 859     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 860     SizeInBits,
 861     AlignInBits,
 862     OffsetInBits,
 863     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 864     DerivedFrom.getNode(),
 865     Elements.getNode(),
 866     ConstantInt::get(Type::getInt32Ty(VMContext), RuntimeLang)
 867   };
 868   return DICompositeType(MDNode::get(VMContext, &Elts[0], 12));
 869 }
 870
 871
 872 /// CreateSubprogram - Create a new descriptor for the specified subprogram.
 873 /// See comments in DISubprogram for descriptions of these fields.  This
 874 /// method does not unique the generated descriptors.
 875 DISubprogram DIFactory::CreateSubprogram(DIDescriptor Context,
 876                                          StringRef Name,
 877                                          StringRef DisplayName,
 878                                          StringRef LinkageName,
 879                                          DICompileUnit CompileUnit,
 880                                          unsigned LineNo, DIType Type,
 881                                          bool isLocalToUnit,
 882                                          bool isDefinition,
 883                                          unsigned VK, unsigned VIndex,
 884                                          DIType ContainingType) {
 885
 886   Value *Elts[] = {
 887     GetTagConstant(dwarf::DW_TAG_subprogram),
 888     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 889     Context.getNode(),
 890     MDString::get(VMContext, Name),
 891     MDString::get(VMContext, DisplayName),
 892     MDString::get(VMContext, LinkageName),
 893     CompileUnit.getNode(),
 894     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
 895     Type.getNode(),
 896     ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
 897     ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
 898     ConstantInt::get(Type::getInt32Ty(VMContext), (unsigned)VK),
 899     ConstantInt::get(Type::getInt32Ty(VMContext), VIndex),
 900     ContainingType.getNode()
 901   };
 902   return DISubprogram(MDNode::get(VMContext, &Elts[0], 14));
 903 }
 904
 905 /// CreateSubprogramDefinition - Create new subprogram descriptor for the
 906 /// given declaration.
 907 DISubprogram DIFactory::CreateSubprogramDefinition(DISubprogram &SPDeclaration) {
 908   if (SPDeclaration.isDefinition())
 909     return DISubprogram(SPDeclaration.getNode());
 910
 911   MDNode *DeclNode = SPDeclaration.getNode();
 912   Value *Elts[] = {
 913     GetTagConstant(dwarf::DW_TAG_subprogram),
 914     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 915     DeclNode->getElement(2), // Context
 916     DeclNode->getElement(3), // Name
 917     DeclNode->getElement(4), // DisplayName
 918     DeclNode->getElement(5), // LinkageName
 919     DeclNode->getElement(6), // CompileUnit
 920     DeclNode->getElement(7), // LineNo
 921     DeclNode->getElement(8), // Type
 922     DeclNode->getElement(9), // isLocalToUnit
 923     ConstantInt::get(Type::getInt1Ty(VMContext), true),
 924     DeclNode->getElement(11), // Virtuality
 925     DeclNode->getElement(12), // VIndex
 926     DeclNode->getElement(13)  // Containting Type
 927   };
 928   return DISubprogram(MDNode::get(VMContext, &Elts[0], 14));
 929 }
 930
 931 /// CreateGlobalVariable - Create a new descriptor for the specified global.
 932 DIGlobalVariable
 933 DIFactory::CreateGlobalVariable(DIDescriptor Context, StringRef Name,
 934                                 StringRef DisplayName,
 935                                 StringRef LinkageName,
 936                                 DICompileUnit CompileUnit,
 937                                 unsigned LineNo, DIType Type,bool isLocalToUnit,
 938                                 bool isDefinition, llvm::GlobalVariable *Val) {
 939   Value *Elts[] = {
 940     GetTagConstant(dwarf::DW_TAG_variable),
 941     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 942     Context.getNode(),
 943     MDString::get(VMContext, Name),
 944     MDString::get(VMContext, DisplayName),
 945     MDString::get(VMContext, LinkageName),
 946     CompileUnit.getNode(),
 947     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
 948     Type.getNode(),
 949     ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
 950     ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
 951     Val
 952   };
 953
 954   Value *const *Vs = &Elts[0];
 955   MDNode *Node = MDNode::get(VMContext,Vs, 12);
 956
 957   // Create a named metadata so that we do not lose this mdnode.
 958   NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.gv");
 959   NMD->addElement(Node);
 960
 961   return DIGlobalVariable(Node);
 962 }
 963
 964
 965 /// CreateVariable - Create a new descriptor for the specified variable.
 966 DIVariable DIFactory::CreateVariable(unsigned Tag, DIDescriptor Context,
 967                                      StringRef Name,
 968                                      DICompileUnit CompileUnit, unsigned LineNo,
 969                                      DIType Type) {
 970   Value *Elts[] = {
 971     GetTagConstant(Tag),
 972     Context.getNode(),
 973     MDString::get(VMContext, Name),
 974     CompileUnit.getNode(),
 975     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
 976     Type.getNode(),
 977   };
 978   return DIVariable(MDNode::get(VMContext, &Elts[0], 6));
 979 }
 980
 981
 982 /// CreateComplexVariable - Create a new descriptor for the specified variable
 983 /// which has a complex address expression for its address.
 984 DIVariable DIFactory::CreateComplexVariable(unsigned Tag, DIDescriptor Context,
 985                                             const std::string &Name,
 986                                             DICompileUnit CompileUnit,
 987                                             unsigned LineNo,
 988                                    DIType Type, SmallVector<Value *, 9> &addr) {
 989   SmallVector<Value *, 9> Elts;
 990   Elts.push_back(GetTagConstant(Tag));
 991   Elts.push_back(Context.getNode());
 992   Elts.push_back(MDString::get(VMContext, Name));
 993   Elts.push_back(CompileUnit.getNode());
 994   Elts.push_back(ConstantInt::get(Type::getInt32Ty(VMContext), LineNo));
 995   Elts.push_back(Type.getNode());
 996   Elts.insert(Elts.end(), addr.begin(), addr.end());
 997
 998   return DIVariable(MDNode::get(VMContext, &Elts[0], 6+addr.size()));
 999 }
1000
1001
1002 /// CreateBlock - This creates a descriptor for a lexical block with the
1003 /// specified parent VMContext.
1004 DILexicalBlock DIFactory::CreateLexicalBlock(DIDescriptor Context) {
1005   Value *Elts[] = {
1006     GetTagConstant(dwarf::DW_TAG_lexical_block),
1007     Context.getNode()
1008   };
1009   return DILexicalBlock(MDNode::get(VMContext, &Elts[0], 2));
1010 }
1011
1012 /// CreateNameSpace - This creates new descriptor for a namespace
1013 /// with the specified parent context.
1014 DINameSpace DIFactory::CreateNameSpace(DIDescriptor Context, StringRef Name,
1015                                        DICompileUnit CompileUnit,
1016                                        unsigned LineNo) {
1017   Value *Elts[] = {
1018     GetTagConstant(dwarf::DW_TAG_namespace),
1019     Context.getNode(),
1020     MDString::get(VMContext, Name),
1021     CompileUnit.getNode(),
1022     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo)
1023   };
1024   return DINameSpace(MDNode::get(VMContext, &Elts[0], 5));
1025 }
1026
1027 /// CreateLocation - Creates a debug info location.
1028 DILocation DIFactory::CreateLocation(unsigned LineNo, unsigned ColumnNo,
1029                                      DIScope S, DILocation OrigLoc) {
1030   Value *Elts[] = {
1031     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
1032     ConstantInt::get(Type::getInt32Ty(VMContext), ColumnNo),
1033     S.getNode(),
1034     OrigLoc.getNode(),
1035   };
1036   return DILocation(MDNode::get(VMContext, &Elts[0], 4));
1037 }
1038
1039 /// CreateLocation - Creates a debug info location.
1040 DILocation DIFactory::CreateLocation(unsigned LineNo, unsigned ColumnNo,
1041                                      DIScope S, MDNode *OrigLoc) {
1042  Value *Elts[] = {
1043     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
1044     ConstantInt::get(Type::getInt32Ty(VMContext), ColumnNo),
1045     S.getNode(),
1046     OrigLoc
1047   };
1048   return DILocation(MDNode::get(VMContext, &Elts[0], 4));
1049 }
1050
1051 //===----------------------------------------------------------------------===//
1052 // DIFactory: Routines for inserting code into a function
1053 //===----------------------------------------------------------------------===//
1054
1055 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
1056 Instruction *DIFactory::InsertDeclare(Value *Storage, DIVariable D,
1057                               Instruction *InsertBefore) {
1058   // Cast the storage to a {}* for the call to llvm.dbg.declare.
1059   Storage = new BitCastInst(Storage, EmptyStructPtr, "", InsertBefore);
1060
1061   if (!DeclareFn)
1062     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1063
1064   Value *Args[] = { Storage, D.getNode() };
1065   return CallInst::Create(DeclareFn, Args, Args+2, "", InsertBefore);
1066 }
1067
1068 /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
1069 Instruction *DIFactory::InsertDeclare(Value *Storage, DIVariable D,
1070                               BasicBlock *InsertAtEnd) {
1071   // Cast the storage to a {}* for the call to llvm.dbg.declare.
1072   Storage = new BitCastInst(Storage, EmptyStructPtr, "", InsertAtEnd);
1073
1074   if (!DeclareFn)
1075     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1076
1077   Value *Args[] = { Storage, D.getNode() };
1078   return CallInst::Create(DeclareFn, Args, Args+2, "", InsertAtEnd);
1079 }
1080
1081 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
1082 Instruction *DIFactory::InsertDbgValueIntrinsic(Value *V, Value *Offset,
1083                                                 DIVariable D,
1084                                                 Instruction *InsertBefore) {
1085   assert(V && "no value passed to dbg.value");
1086   assert(Offset->getType() == Type::getInt64Ty(V->getContext()) &&
1087          "offset must be i64");
1088   if (!ValueFn)
1089     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1090
1091   Value *Elts[] = { V };
1092   Value *Args[] = { MDNode::get(V->getContext(), Elts, 1), Offset,
1093                     D.getNode() };
1094   return CallInst::Create(ValueFn, Args, Args+3, "", InsertBefore);
1095 }
1096
1097 /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
1098 Instruction *DIFactory::InsertDbgValueIntrinsic(Value *V, Value *Offset,
1099                                                 DIVariable D,
1100                                                 BasicBlock *InsertAtEnd) {
1101   assert(V && "no value passed to dbg.value");
1102   assert(Offset->getType() == Type::getInt64Ty(V->getContext()) &&
1103          "offset must be i64");
1104   if (!ValueFn)
1105     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1106
1107   Value *Elts[] = { V };
1108   Value *Args[] = { MDNode::get(V->getContext(), Elts, 1), Offset,
1109                     D.getNode() };
1110   return CallInst::Create(ValueFn, Args, Args+3, "", InsertAtEnd);
1111 }
1112
1113 //===----------------------------------------------------------------------===//
1114 // DebugInfoFinder implementations.
1115 //===----------------------------------------------------------------------===//
1116
1117 /// processModule - Process entire module and collect debug info.
1118 void DebugInfoFinder::processModule(Module &M) {
1119   unsigned MDDbgKind = M.getMDKindID("dbg");
1120
1121   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
1122     for (Function::iterator FI = (*I).begin(), FE = (*I).end(); FI != FE; ++FI)
1123       for (BasicBlock::iterator BI = (*FI).begin(), BE = (*FI).end(); BI != BE;
1124            ++BI) {
1125         if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(BI))
1126           processDeclare(DDI);
1127         else if (MDNode *L = BI->getMetadata(MDDbgKind))
1128           processLocation(DILocation(L));
1129       }
1130
1131   NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.gv");
1132   if (!NMD)
1133     return;
1134
1135   for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) {
1136     DIGlobalVariable DIG(cast<MDNode>(NMD->getElement(i)));
1137     if (addGlobalVariable(DIG)) {
1138       addCompileUnit(DIG.getCompileUnit());
1139       processType(DIG.getType());
1140     }
1141   }
1142 }
1143
1144 /// processLocation - Process DILocation.
1145 void DebugInfoFinder::processLocation(DILocation Loc) {
1146   if (Loc.isNull()) return;
1147   DIScope S(Loc.getScope().getNode());
1148   if (S.isNull()) return;
1149   if (S.isCompileUnit())
1150     addCompileUnit(DICompileUnit(S.getNode()));
1151   else if (S.isSubprogram())
1152     processSubprogram(DISubprogram(S.getNode()));
1153   else if (S.isLexicalBlock())
1154     processLexicalBlock(DILexicalBlock(S.getNode()));
1155   processLocation(Loc.getOrigLocation());
1156 }
1157
1158 /// processType - Process DIType.
1159 void DebugInfoFinder::processType(DIType DT) {
1160   if (!addType(DT))
1161     return;
1162
1163   addCompileUnit(DT.getCompileUnit());
1164   if (DT.isCompositeType()) {
1165     DICompositeType DCT(DT.getNode());
1166     processType(DCT.getTypeDerivedFrom());
1167     DIArray DA = DCT.getTypeArray();
1168     if (!DA.isNull())
1169       for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) {
1170         DIDescriptor D = DA.getElement(i);
1171         DIType TypeE = DIType(D.getNode());
1172         if (!TypeE.isNull())
1173           processType(TypeE);
1174         else
1175           processSubprogram(DISubprogram(D.getNode()));
1176       }
1177   } else if (DT.isDerivedType()) {
1178     DIDerivedType DDT(DT.getNode());
1179     if (!DDT.isNull())
1180       processType(DDT.getTypeDerivedFrom());
1181   }
1182 }
1183
1184 /// processLexicalBlock
1185 void DebugInfoFinder::processLexicalBlock(DILexicalBlock LB) {
1186   if (LB.isNull())
1187     return;
1188   DIScope Context = LB.getContext();
1189   if (Context.isLexicalBlock())
1190     return processLexicalBlock(DILexicalBlock(Context.getNode()));
1191   else
1192     return processSubprogram(DISubprogram(Context.getNode()));
1193 }
1194
1195 /// processSubprogram - Process DISubprogram.
1196 void DebugInfoFinder::processSubprogram(DISubprogram SP) {
1197   if (SP.isNull())
1198     return;
1199   if (!addSubprogram(SP))
1200     return;
1201   addCompileUnit(SP.getCompileUnit());
1202   processType(SP.getType());
1203 }
1204
1205 /// processDeclare - Process DbgDeclareInst.
1206 void DebugInfoFinder::processDeclare(DbgDeclareInst *DDI) {
1207   DIVariable DV(cast<MDNode>(DDI->getVariable()));
1208   if (DV.isNull())
1209     return;
1210
1211   if (!NodesSeen.insert(DV.getNode()))
1212     return;
1213
1214   addCompileUnit(DV.getCompileUnit());
1215   processType(DV.getType());
1216 }
1217
1218 /// addType - Add type into Tys.
1219 bool DebugInfoFinder::addType(DIType DT) {
1220   if (DT.isNull())
1221     return false;
1222
1223   if (!NodesSeen.insert(DT.getNode()))
1224     return false;
1225
1226   TYs.push_back(DT.getNode());
1227   return true;
1228 }
1229
1230 /// addCompileUnit - Add compile unit into CUs.
1231 bool DebugInfoFinder::addCompileUnit(DICompileUnit CU) {
1232   if (CU.isNull())
1233     return false;
1234
1235   if (!NodesSeen.insert(CU.getNode()))
1236     return false;
1237
1238   CUs.push_back(CU.getNode());
1239   return true;
1240 }
1241
1242 /// addGlobalVariable - Add global variable into GVs.
1243 bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable DIG) {
1244   if (DIG.isNull())
1245     return false;
1246
1247   if (!NodesSeen.insert(DIG.getNode()))
1248     return false;
1249
1250   GVs.push_back(DIG.getNode());
1251   return true;
1252 }
1253
1254 // addSubprogram - Add subprgoram into SPs.
1255 bool DebugInfoFinder::addSubprogram(DISubprogram SP) {
1256   if (SP.isNull())
1257     return false;
1258
1259   if (!NodesSeen.insert(SP.getNode()))
1260     return false;
1261
1262   SPs.push_back(SP.getNode());
1263   return true;
1264 }
1265
1266 namespace llvm {
1267   /// findStopPoint - Find the stoppoint coressponding to this instruction, that
1268   /// is the stoppoint that dominates this instruction.
1269   const DbgStopPointInst *findStopPoint(const Instruction *Inst) {
1270     if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(Inst))
1271       return DSI;
1272
1273     const BasicBlock *BB = Inst->getParent();
1274     BasicBlock::const_iterator I = Inst, B;
1275     while (BB) {
1276       B = BB->begin();
1277
1278       // A BB consisting only of a terminator can't have a stoppoint.
1279       while (I != B) {
1280         --I;
1281         if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(I))
1282           return DSI;
1283       }
1284
1285       // This BB didn't have a stoppoint: if there is only one predecessor, look
1286       // for a stoppoint there. We could use getIDom(), but that would require
1287       // dominator info.
1288       BB = I->getParent()->getUniquePredecessor();
1289       if (BB)
1290         I = BB->getTerminator();
1291     }
1292
1293     return 0;
1294   }
1295
1296   /// findBBStopPoint - Find the stoppoint corresponding to first real
1297   /// (non-debug intrinsic) instruction in this Basic Block, and return the
1298   /// stoppoint for it.
1299   const DbgStopPointInst *findBBStopPoint(const BasicBlock *BB) {
1300     for(BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I)
1301       if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(I))
1302         return DSI;
1303
1304     // Fallback to looking for stoppoint of unique predecessor. Useful if this
1305     // BB contains no stoppoints, but unique predecessor does.
1306     BB = BB->getUniquePredecessor();
1307     if (BB)
1308       return findStopPoint(BB->getTerminator());
1309
1310     return 0;
1311   }
1312
1313   Value *findDbgGlobalDeclare(GlobalVariable *V) {
1314     const Module *M = V->getParent();
1315     NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv");
1316     if (!NMD)
1317       return 0;
1318
1319     for (unsigned i = 0, e = NMD->getNumElements(); i != e; ++i) {
1320       DIGlobalVariable DIG(cast_or_null<MDNode>(NMD->getElement(i)));
1321       if (DIG.isNull())
1322         continue;
1323       if (DIG.getGlobal() == V)
1324         return DIG.getNode();
1325     }
1326     return 0;
1327   }
1328
1329   /// Finds the llvm.dbg.declare intrinsic corresponding to this value if any.
1330   /// It looks through pointer casts too.
1331   const DbgDeclareInst *findDbgDeclare(const Value *V, bool stripCasts) {
1332     if (stripCasts) {
1333       V = V->stripPointerCasts();
1334
1335       // Look for the bitcast.
1336       for (Value::use_const_iterator I = V->use_begin(), E =V->use_end();
1337             I != E; ++I)
1338         if (isa<BitCastInst>(I)) {
1339           const DbgDeclareInst *DDI = findDbgDeclare(*I, false);
1340           if (DDI) return DDI;
1341         }
1342       return 0;
1343     }
1344
1345     // Find llvm.dbg.declare among uses of the instruction.
1346     for (Value::use_const_iterator I = V->use_begin(), E =V->use_end();
1347           I != E; ++I)
1348       if (const DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(I))
1349         return DDI;
1350
1351     return 0;
1352   }
1353
1354 bool getLocationInfo(const Value *V, std::string &DisplayName,
1355                      std::string &Type, unsigned &LineNo, std::string &File,
1356                        std::string &Dir) {
1357     DICompileUnit Unit;
1358     DIType TypeD;
1359
1360     if (GlobalVariable *GV = dyn_cast<GlobalVariable>(const_cast<Value*>(V))) {
1361       Value *DIGV = findDbgGlobalDeclare(GV);
1362       if (!DIGV) return false;
1363       DIGlobalVariable Var(cast<MDNode>(DIGV));
1364
1365       StringRef D = Var.getDisplayName();
1366       if (!D.empty())
1367         DisplayName = D;
1368       LineNo = Var.getLineNumber();
1369       Unit = Var.getCompileUnit();
1370       TypeD = Var.getType();
1371     } else {
1372       const DbgDeclareInst *DDI = findDbgDeclare(V);
1373       if (!DDI) return false;
1374       DIVariable Var(cast<MDNode>(DDI->getVariable()));
1375
1376       StringRef D = Var.getName();
1377       if (!D.empty())
1378         DisplayName = D;
1379       LineNo = Var.getLineNumber();
1380       Unit = Var.getCompileUnit();
1381       TypeD = Var.getType();
1382     }
1383
1384     StringRef T = TypeD.getName();
1385     if (!T.empty())
1386       Type = T;
1387     StringRef F = Unit.getFilename();
1388     if (!F.empty())
1389       File = F;
1390     StringRef D = Unit.getDirectory();
1391     if (!D.empty())
1392       Dir = D;
1393     return true;
1394   }
1395
1396   /// isValidDebugInfoIntrinsic - Return true if SPI is a valid debug
1397   /// info intrinsic.
1398   bool isValidDebugInfoIntrinsic(DbgStopPointInst &SPI,
1399                                  CodeGenOpt::Level OptLev) {
1400     return DIDescriptor::ValidDebugInfo(SPI.getContext(), OptLev);
1401   }
1402
1403   /// isValidDebugInfoIntrinsic - Return true if FSI is a valid debug
1404   /// info intrinsic.
1405   bool isValidDebugInfoIntrinsic(DbgFuncStartInst &FSI,
1406                                  CodeGenOpt::Level OptLev) {
1407     return DIDescriptor::ValidDebugInfo(FSI.getSubprogram(), OptLev);
1408   }
1409
1410   /// isValidDebugInfoIntrinsic - Return true if RSI is a valid debug
1411   /// info intrinsic.
1412   bool isValidDebugInfoIntrinsic(DbgRegionStartInst &RSI,
1413                                  CodeGenOpt::Level OptLev) {
1414     return DIDescriptor::ValidDebugInfo(RSI.getContext(), OptLev);
1415   }
1416
1417   /// isValidDebugInfoIntrinsic - Return true if REI is a valid debug
1418   /// info intrinsic.
1419   bool isValidDebugInfoIntrinsic(DbgRegionEndInst &REI,
1420                                  CodeGenOpt::Level OptLev) {
1421     return DIDescriptor::ValidDebugInfo(REI.getContext(), OptLev);
1422   }
1423
1424
1425   /// isValidDebugInfoIntrinsic - Return true if DI is a valid debug
1426   /// info intrinsic.
1427   bool isValidDebugInfoIntrinsic(DbgDeclareInst &DI,
1428                                  CodeGenOpt::Level OptLev) {
1429     return DIDescriptor::ValidDebugInfo(DI.getVariable(), OptLev);
1430   }
1431
1432   /// ExtractDebugLocation - Extract debug location information
1433   /// from llvm.dbg.stoppoint intrinsic.
1434   DebugLoc ExtractDebugLocation(DbgStopPointInst &SPI,
1435                                 DebugLocTracker &DebugLocInfo) {
1436     DebugLoc DL;
1437     Value *Context = SPI.getContext();
1438
1439     // If this location is already tracked then use it.
1440     DebugLocTuple Tuple(cast<MDNode>(Context), NULL, SPI.getLine(),
1441                         SPI.getColumn());
1442     DenseMap<DebugLocTuple, unsigned>::iterator II
1443       = DebugLocInfo.DebugIdMap.find(Tuple);
1444     if (II != DebugLocInfo.DebugIdMap.end())
1445       return DebugLoc::get(II->second);
1446
1447     // Add a new location entry.
1448     unsigned Id = DebugLocInfo.DebugLocations.size();
1449     DebugLocInfo.DebugLocations.push_back(Tuple);
1450     DebugLocInfo.DebugIdMap[Tuple] = Id;
1451
1452     return DebugLoc::get(Id);
1453   }
1454
1455   /// ExtractDebugLocation - Extract debug location information
1456   /// from DILocation.
1457   DebugLoc ExtractDebugLocation(DILocation &Loc,
1458                                 DebugLocTracker &DebugLocInfo) {
1459     DebugLoc DL;
1460     MDNode *Context = Loc.getScope().getNode();
1461     MDNode *InlinedLoc = NULL;
1462     if (!Loc.getOrigLocation().isNull())
1463       InlinedLoc = Loc.getOrigLocation().getNode();
1464     // If this location is already tracked then use it.
1465     DebugLocTuple Tuple(Context, InlinedLoc, Loc.getLineNumber(),
1466                         Loc.getColumnNumber());
1467     DenseMap<DebugLocTuple, unsigned>::iterator II
1468       = DebugLocInfo.DebugIdMap.find(Tuple);
1469     if (II != DebugLocInfo.DebugIdMap.end())
1470       return DebugLoc::get(II->second);
1471
1472     // Add a new location entry.
1473     unsigned Id = DebugLocInfo.DebugLocations.size();
1474     DebugLocInfo.DebugLocations.push_back(Tuple);
1475     DebugLocInfo.DebugIdMap[Tuple] = Id;
1476
1477     return DebugLoc::get(Id);
1478   }
1479
1480   /// ExtractDebugLocation - Extract debug location information
1481   /// from llvm.dbg.func_start intrinsic.
1482   DebugLoc ExtractDebugLocation(DbgFuncStartInst &FSI,
1483                                 DebugLocTracker &DebugLocInfo) {
1484     DebugLoc DL;
1485     Value *SP = FSI.getSubprogram();
1486
1487     DISubprogram Subprogram(cast<MDNode>(SP));
1488     unsigned Line = Subprogram.getLineNumber();
1489     DICompileUnit CU(Subprogram.getCompileUnit());
1490
1491     // If this location is already tracked then use it.
1492     DebugLocTuple Tuple(CU.getNode(), NULL, Line, /* Column */ 0);
1493     DenseMap<DebugLocTuple, unsigned>::iterator II
1494       = DebugLocInfo.DebugIdMap.find(Tuple);
1495     if (II != DebugLocInfo.DebugIdMap.end())
1496       return DebugLoc::get(II->second);
1497
1498     // Add a new location entry.
1499     unsigned Id = DebugLocInfo.DebugLocations.size();
1500     DebugLocInfo.DebugLocations.push_back(Tuple);
1501     DebugLocInfo.DebugIdMap[Tuple] = Id;
1502
1503     return DebugLoc::get(Id);
1504   }
1505
1506   /// getDISubprogram - Find subprogram that is enclosing this scope.
1507   DISubprogram getDISubprogram(MDNode *Scope) {
1508     DIDescriptor D(Scope);
1509     if (D.isNull())
1510       return DISubprogram();
1511
1512     if (D.isCompileUnit())
1513       return DISubprogram();
1514
1515     if (D.isSubprogram())
1516       return DISubprogram(Scope);
1517
1518     if (D.isLexicalBlock())
1519       return getDISubprogram(DILexicalBlock(Scope).getContext().getNode());
1520
1521     return DISubprogram();
1522   }
1523
1524   /// getDICompositeType - Find underlying composite type.
1525   DICompositeType getDICompositeType(DIType T) {
1526     if (T.isNull())
1527       return DICompositeType();
1528
1529     if (T.isCompositeType())
1530       return DICompositeType(T.getNode());
1531
1532     if (T.isDerivedType())
1533       return getDICompositeType(DIDerivedType(T.getNode()).getTypeDerivedFrom());
1534
1535     return DICompositeType();
1536   }
1537 }