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