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