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