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   StringRef Name = getLinkageName();
 410   if (Name.empty())
 411     Name = getName();
 412   if (F->getName() == Name)
 413     return true;
 414   return false;
 415 }
 416
 417 unsigned DISubprogram::isOptimized() const     {
 418   assert (DbgNode && "Invalid subprogram descriptor!");
 419   if (DbgNode->getNumOperands() == 16)
 420     return getUnsignedField(15);
 421   return 0;
 422 }
 423
 424 StringRef DIScope::getFilename() const {
 425   if (!DbgNode)
 426     return StringRef();
 427   if (isLexicalBlock())
 428     return DILexicalBlock(DbgNode).getFilename();
 429   if (isSubprogram())
 430     return DISubprogram(DbgNode).getFilename();
 431   if (isCompileUnit())
 432     return DICompileUnit(DbgNode).getFilename();
 433   if (isNameSpace())
 434     return DINameSpace(DbgNode).getFilename();
 435   if (isType())
 436     return DIType(DbgNode).getFilename();
 437   if (isFile())
 438     return DIFile(DbgNode).getFilename();
 439   assert(0 && "Invalid DIScope!");
 440   return StringRef();
 441 }
 442
 443 StringRef DIScope::getDirectory() const {
 444   if (!DbgNode)
 445     return StringRef();
 446   if (isLexicalBlock())
 447     return DILexicalBlock(DbgNode).getDirectory();
 448   if (isSubprogram())
 449     return DISubprogram(DbgNode).getDirectory();
 450   if (isCompileUnit())
 451     return DICompileUnit(DbgNode).getDirectory();
 452   if (isNameSpace())
 453     return DINameSpace(DbgNode).getDirectory();
 454   if (isType())
 455     return DIType(DbgNode).getDirectory();
 456   if (isFile())
 457     return DIFile(DbgNode).getDirectory();
 458   assert(0 && "Invalid DIScope!");
 459   return StringRef();
 460 }
 461
 462 //===----------------------------------------------------------------------===//
 463 // DIDescriptor: dump routines for all descriptors.
 464 //===----------------------------------------------------------------------===//
 465
 466
 467 /// print - Print descriptor.
 468 void DIDescriptor::print(raw_ostream &OS) const {
 469   OS << "[" << dwarf::TagString(getTag()) << "] ";
 470   OS.write_hex((intptr_t) &*DbgNode) << ']';
 471 }
 472
 473 /// print - Print compile unit.
 474 void DICompileUnit::print(raw_ostream &OS) const {
 475   if (getLanguage())
 476     OS << " [" << dwarf::LanguageString(getLanguage()) << "] ";
 477
 478   OS << " [" << getDirectory() << "/" << getFilename() << "]";
 479 }
 480
 481 /// print - Print type.
 482 void DIType::print(raw_ostream &OS) const {
 483   if (!DbgNode) return;
 484
 485   StringRef Res = getName();
 486   if (!Res.empty())
 487     OS << " [" << Res << "] ";
 488
 489   unsigned Tag = getTag();
 490   OS << " [" << dwarf::TagString(Tag) << "] ";
 491
 492   // TODO : Print context
 493   getCompileUnit().print(OS);
 494   OS << " ["
 495          << "line " << getLineNumber() << ", "
 496          << getSizeInBits() << " bits, "
 497          << getAlignInBits() << " bit alignment, "
 498          << getOffsetInBits() << " bit offset"
 499          << "] ";
 500
 501   if (isPrivate())
 502     OS << " [private] ";
 503   else if (isProtected())
 504     OS << " [protected] ";
 505
 506   if (isForwardDecl())
 507     OS << " [fwd] ";
 508
 509   if (isBasicType())
 510     DIBasicType(DbgNode).print(OS);
 511   else if (isDerivedType())
 512     DIDerivedType(DbgNode).print(OS);
 513   else if (isCompositeType())
 514     DICompositeType(DbgNode).print(OS);
 515   else {
 516     OS << "Invalid DIType\n";
 517     return;
 518   }
 519
 520   OS << "\n";
 521 }
 522
 523 /// print - Print basic type.
 524 void DIBasicType::print(raw_ostream &OS) const {
 525   OS << " [" << dwarf::AttributeEncodingString(getEncoding()) << "] ";
 526 }
 527
 528 /// print - Print derived type.
 529 void DIDerivedType::print(raw_ostream &OS) const {
 530   OS << "\n\t Derived From: "; getTypeDerivedFrom().print(OS);
 531 }
 532
 533 /// print - Print composite type.
 534 void DICompositeType::print(raw_ostream &OS) const {
 535   DIArray A = getTypeArray();
 536   OS << " [" << A.getNumElements() << " elements]";
 537 }
 538
 539 /// print - Print subprogram.
 540 void DISubprogram::print(raw_ostream &OS) const {
 541   StringRef Res = getName();
 542   if (!Res.empty())
 543     OS << " [" << Res << "] ";
 544
 545   unsigned Tag = getTag();
 546   OS << " [" << dwarf::TagString(Tag) << "] ";
 547
 548   // TODO : Print context
 549   getCompileUnit().print(OS);
 550   OS << " [" << getLineNumber() << "] ";
 551
 552   if (isLocalToUnit())
 553     OS << " [local] ";
 554
 555   if (isDefinition())
 556     OS << " [def] ";
 557
 558   OS << "\n";
 559 }
 560
 561 /// print - Print global variable.
 562 void DIGlobalVariable::print(raw_ostream &OS) const {
 563   OS << " [";
 564   StringRef Res = getName();
 565   if (!Res.empty())
 566     OS << " [" << Res << "] ";
 567
 568   unsigned Tag = getTag();
 569   OS << " [" << dwarf::TagString(Tag) << "] ";
 570
 571   // TODO : Print context
 572   getCompileUnit().print(OS);
 573   OS << " [" << getLineNumber() << "] ";
 574
 575   if (isLocalToUnit())
 576     OS << " [local] ";
 577
 578   if (isDefinition())
 579     OS << " [def] ";
 580
 581   if (isGlobalVariable())
 582     DIGlobalVariable(DbgNode).print(OS);
 583   OS << "]\n";
 584 }
 585
 586 /// print - Print variable.
 587 void DIVariable::print(raw_ostream &OS) const {
 588   StringRef Res = getName();
 589   if (!Res.empty())
 590     OS << " [" << Res << "] ";
 591
 592   getCompileUnit().print(OS);
 593   OS << " [" << getLineNumber() << "] ";
 594   getType().print(OS);
 595   OS << "\n";
 596
 597   // FIXME: Dump complex addresses
 598 }
 599
 600 /// dump - Print descriptor to dbgs() with a newline.
 601 void DIDescriptor::dump() const {
 602   print(dbgs()); dbgs() << '\n';
 603 }
 604
 605 /// dump - Print compile unit to dbgs() with a newline.
 606 void DICompileUnit::dump() const {
 607   print(dbgs()); dbgs() << '\n';
 608 }
 609
 610 /// dump - Print type to dbgs() with a newline.
 611 void DIType::dump() const {
 612   print(dbgs()); dbgs() << '\n';
 613 }
 614
 615 /// dump - Print basic type to dbgs() with a newline.
 616 void DIBasicType::dump() const {
 617   print(dbgs()); dbgs() << '\n';
 618 }
 619
 620 /// dump - Print derived type to dbgs() with a newline.
 621 void DIDerivedType::dump() const {
 622   print(dbgs()); dbgs() << '\n';
 623 }
 624
 625 /// dump - Print composite type to dbgs() with a newline.
 626 void DICompositeType::dump() const {
 627   print(dbgs()); dbgs() << '\n';
 628 }
 629
 630 /// dump - Print subprogram to dbgs() with a newline.
 631 void DISubprogram::dump() const {
 632   print(dbgs()); dbgs() << '\n';
 633 }
 634
 635 /// dump - Print global variable.
 636 void DIGlobalVariable::dump() const {
 637   print(dbgs()); dbgs() << '\n';
 638 }
 639
 640 /// dump - Print variable.
 641 void DIVariable::dump() const {
 642   print(dbgs()); dbgs() << '\n';
 643 }
 644
 645 //===----------------------------------------------------------------------===//
 646 // DIFactory: Basic Helpers
 647 //===----------------------------------------------------------------------===//
 648
 649 DIFactory::DIFactory(Module &m)
 650   : M(m), VMContext(M.getContext()), DeclareFn(0), ValueFn(0) {}
 651
 652 Constant *DIFactory::GetTagConstant(unsigned TAG) {
 653   assert((TAG & LLVMDebugVersionMask) == 0 &&
 654          "Tag too large for debug encoding!");
 655   return ConstantInt::get(Type::getInt32Ty(VMContext), TAG | LLVMDebugVersion);
 656 }
 657
 658 //===----------------------------------------------------------------------===//
 659 // DIFactory: Primary Constructors
 660 //===----------------------------------------------------------------------===//
 661
 662 /// GetOrCreateArray - Create an descriptor for an array of descriptors.
 663 /// This implicitly uniques the arrays created.
 664 DIArray DIFactory::GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys) {
 665   SmallVector<Value*, 16> Elts;
 666
 667   if (NumTys == 0)
 668     Elts.push_back(llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)));
 669   else
 670     for (unsigned i = 0; i != NumTys; ++i)
 671       Elts.push_back(Tys[i]);
 672
 673   return DIArray(MDNode::get(VMContext,Elts.data(), Elts.size()));
 674 }
 675
 676 /// GetOrCreateSubrange - Create a descriptor for a value range.  This
 677 /// implicitly uniques the values returned.
 678 DISubrange DIFactory::GetOrCreateSubrange(int64_t Lo, int64_t Hi) {
 679   Value *Elts[] = {
 680     GetTagConstant(dwarf::DW_TAG_subrange_type),
 681     ConstantInt::get(Type::getInt64Ty(VMContext), Lo),
 682     ConstantInt::get(Type::getInt64Ty(VMContext), Hi)
 683   };
 684
 685   return DISubrange(MDNode::get(VMContext, &Elts[0], 3));
 686 }
 687
 688
 689
 690 /// CreateCompileUnit - Create a new descriptor for the specified compile
 691 /// unit.  Note that this does not unique compile units within the module.
 692 DICompileUnit DIFactory::CreateCompileUnit(unsigned LangID,
 693                                            StringRef Filename,
 694                                            StringRef Directory,
 695                                            StringRef Producer,
 696                                            bool isMain,
 697                                            bool isOptimized,
 698                                            StringRef Flags,
 699                                            unsigned RunTimeVer) {
 700   Value *Elts[] = {
 701     GetTagConstant(dwarf::DW_TAG_compile_unit),
 702     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 703     ConstantInt::get(Type::getInt32Ty(VMContext), LangID),
 704     MDString::get(VMContext, Filename),
 705     MDString::get(VMContext, Directory),
 706     MDString::get(VMContext, Producer),
 707     ConstantInt::get(Type::getInt1Ty(VMContext), isMain),
 708     ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
 709     MDString::get(VMContext, Flags),
 710     ConstantInt::get(Type::getInt32Ty(VMContext), RunTimeVer)
 711   };
 712
 713   return DICompileUnit(MDNode::get(VMContext, &Elts[0], 10));
 714 }
 715
 716 /// CreateFile -  Create a new descriptor for the specified file.
 717 DIFile DIFactory::CreateFile(StringRef Filename,
 718                              StringRef Directory,
 719                              DICompileUnit CU) {
 720   Value *Elts[] = {
 721     GetTagConstant(dwarf::DW_TAG_file_type),
 722     MDString::get(VMContext, Filename),
 723     MDString::get(VMContext, Directory),
 724     CU
 725   };
 726
 727   return DIFile(MDNode::get(VMContext, &Elts[0], 4));
 728 }
 729
 730 /// CreateEnumerator - Create a single enumerator value.
 731 DIEnumerator DIFactory::CreateEnumerator(StringRef Name, uint64_t Val){
 732   Value *Elts[] = {
 733     GetTagConstant(dwarf::DW_TAG_enumerator),
 734     MDString::get(VMContext, Name),
 735     ConstantInt::get(Type::getInt64Ty(VMContext), Val)
 736   };
 737   return DIEnumerator(MDNode::get(VMContext, &Elts[0], 3));
 738 }
 739
 740
 741 /// CreateBasicType - Create a basic type like int, float, etc.
 742 DIBasicType DIFactory::CreateBasicType(DIDescriptor Context,
 743                                        StringRef Name,
 744                                        DIFile F,
 745                                        unsigned LineNumber,
 746                                        uint64_t SizeInBits,
 747                                        uint64_t AlignInBits,
 748                                        uint64_t OffsetInBits, unsigned Flags,
 749                                        unsigned Encoding) {
 750   Value *Elts[] = {
 751     GetTagConstant(dwarf::DW_TAG_base_type),
 752     Context,
 753     MDString::get(VMContext, Name),
 754     F,
 755     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 756     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 757     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 758     ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
 759     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 760     ConstantInt::get(Type::getInt32Ty(VMContext), Encoding)
 761   };
 762   return DIBasicType(MDNode::get(VMContext, &Elts[0], 10));
 763 }
 764
 765
 766 /// CreateBasicType - Create a basic type like int, float, etc.
 767 DIBasicType DIFactory::CreateBasicTypeEx(DIDescriptor Context,
 768                                          StringRef Name,
 769                                          DIFile F,
 770                                          unsigned LineNumber,
 771                                          Constant *SizeInBits,
 772                                          Constant *AlignInBits,
 773                                          Constant *OffsetInBits, unsigned Flags,
 774                                          unsigned Encoding) {
 775   Value *Elts[] = {
 776     GetTagConstant(dwarf::DW_TAG_base_type),
 777     Context,
 778     MDString::get(VMContext, Name),
 779     F,
 780     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 781     SizeInBits,
 782     AlignInBits,
 783     OffsetInBits,
 784     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 785     ConstantInt::get(Type::getInt32Ty(VMContext), Encoding)
 786   };
 787   return DIBasicType(MDNode::get(VMContext, &Elts[0], 10));
 788 }
 789
 790 /// CreateArtificialType - Create a new DIType with "artificial" flag set.
 791 DIType DIFactory::CreateArtificialType(DIType Ty) {
 792   if (Ty.isArtificial())
 793     return Ty;
 794
 795   SmallVector<Value *, 9> Elts;
 796   MDNode *N = Ty;
 797   assert (N && "Unexpected input DIType!");
 798   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
 799     if (Value *V = N->getOperand(i))
 800       Elts.push_back(V);
 801     else
 802       Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)));
 803   }
 804
 805   unsigned CurFlags = Ty.getFlags();
 806   CurFlags = CurFlags | DIType::FlagArtificial;
 807
 808   // Flags are stored at this slot.
 809   Elts[8] =  ConstantInt::get(Type::getInt32Ty(VMContext), CurFlags);
 810
 811   return DIType(MDNode::get(VMContext, Elts.data(), Elts.size()));
 812 }
 813
 814 /// CreateDerivedType - Create a derived type like const qualified type,
 815 /// pointer, typedef, etc.
 816 DIDerivedType DIFactory::CreateDerivedType(unsigned Tag,
 817                                            DIDescriptor Context,
 818                                            StringRef Name,
 819                                            DIFile F,
 820                                            unsigned LineNumber,
 821                                            uint64_t SizeInBits,
 822                                            uint64_t AlignInBits,
 823                                            uint64_t OffsetInBits,
 824                                            unsigned Flags,
 825                                            DIType DerivedFrom) {
 826   Value *Elts[] = {
 827     GetTagConstant(Tag),
 828     Context,
 829     MDString::get(VMContext, Name),
 830     F,
 831     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 832     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 833     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 834     ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
 835     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 836     DerivedFrom,
 837   };
 838   return DIDerivedType(MDNode::get(VMContext, &Elts[0], 10));
 839 }
 840
 841
 842 /// CreateDerivedType - Create a derived type like const qualified type,
 843 /// pointer, typedef, etc.
 844 DIDerivedType DIFactory::CreateDerivedTypeEx(unsigned Tag,
 845                                              DIDescriptor Context,
 846                                              StringRef Name,
 847                                              DIFile F,
 848                                              unsigned LineNumber,
 849                                              Constant *SizeInBits,
 850                                              Constant *AlignInBits,
 851                                              Constant *OffsetInBits,
 852                                              unsigned Flags,
 853                                              DIType DerivedFrom) {
 854   Value *Elts[] = {
 855     GetTagConstant(Tag),
 856     Context,
 857     MDString::get(VMContext, Name),
 858     F,
 859     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 860     SizeInBits,
 861     AlignInBits,
 862     OffsetInBits,
 863     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 864     DerivedFrom,
 865   };
 866   return DIDerivedType(MDNode::get(VMContext, &Elts[0], 10));
 867 }
 868
 869
 870 /// CreateCompositeType - Create a composite type like array, struct, etc.
 871 DICompositeType DIFactory::CreateCompositeType(unsigned Tag,
 872                                                DIDescriptor Context,
 873                                                StringRef Name,
 874                                                DIFile F,
 875                                                unsigned LineNumber,
 876                                                uint64_t SizeInBits,
 877                                                uint64_t AlignInBits,
 878                                                uint64_t OffsetInBits,
 879                                                unsigned Flags,
 880                                                DIType DerivedFrom,
 881                                                DIArray Elements,
 882                                                unsigned RuntimeLang,
 883                                                MDNode *ContainingType) {
 884
 885   Value *Elts[] = {
 886     GetTagConstant(Tag),
 887     Context,
 888     MDString::get(VMContext, Name),
 889     F,
 890     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 891     ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
 892     ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
 893     ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
 894     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 895     DerivedFrom,
 896     Elements,
 897     ConstantInt::get(Type::getInt32Ty(VMContext), RuntimeLang),
 898     ContainingType
 899   };
 900   return DICompositeType(MDNode::get(VMContext, &Elts[0], 13));
 901 }
 902
 903
 904 /// CreateCompositeType - Create a composite type like array, struct, etc.
 905 DICompositeType DIFactory::CreateCompositeTypeEx(unsigned Tag,
 906                                                  DIDescriptor Context,
 907                                                  StringRef Name,
 908                                                  DIFile F,
 909                                                  unsigned LineNumber,
 910                                                  Constant *SizeInBits,
 911                                                  Constant *AlignInBits,
 912                                                  Constant *OffsetInBits,
 913                                                  unsigned Flags,
 914                                                  DIType DerivedFrom,
 915                                                  DIArray Elements,
 916                                                  unsigned RuntimeLang) {
 917
 918   Value *Elts[] = {
 919     GetTagConstant(Tag),
 920     Context,
 921     MDString::get(VMContext, Name),
 922     F,
 923     ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
 924     SizeInBits,
 925     AlignInBits,
 926     OffsetInBits,
 927     ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
 928     DerivedFrom,
 929     Elements,
 930     ConstantInt::get(Type::getInt32Ty(VMContext), RuntimeLang)
 931   };
 932   return DICompositeType(MDNode::get(VMContext, &Elts[0], 12));
 933 }
 934
 935
 936 /// CreateSubprogram - Create a new descriptor for the specified subprogram.
 937 /// See comments in DISubprogram for descriptions of these fields.  This
 938 /// method does not unique the generated descriptors.
 939 DISubprogram DIFactory::CreateSubprogram(DIDescriptor Context,
 940                                          StringRef Name,
 941                                          StringRef DisplayName,
 942                                          StringRef LinkageName,
 943                                          DIFile F,
 944                                          unsigned LineNo, DIType Ty,
 945                                          bool isLocalToUnit,
 946                                          bool isDefinition,
 947                                          unsigned VK, unsigned VIndex,
 948                                          DIType ContainingType,
 949                                          bool isArtificial,
 950                                          bool isOptimized,
 951                                          Function *Fn) {
 952
 953   Value *Elts[] = {
 954     GetTagConstant(dwarf::DW_TAG_subprogram),
 955     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 956     Context,
 957     MDString::get(VMContext, Name),
 958     MDString::get(VMContext, DisplayName),
 959     MDString::get(VMContext, LinkageName),
 960     F,
 961     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
 962     Ty,
 963     ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
 964     ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
 965     ConstantInt::get(Type::getInt32Ty(VMContext), (unsigned)VK),
 966     ConstantInt::get(Type::getInt32Ty(VMContext), VIndex),
 967     ContainingType,
 968     ConstantInt::get(Type::getInt1Ty(VMContext), isArtificial),
 969     ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
 970     Fn
 971   };
 972   return DISubprogram(MDNode::get(VMContext, &Elts[0], 17));
 973 }
 974
 975 /// CreateSubprogramDefinition - Create new subprogram descriptor for the
 976 /// given declaration.
 977 DISubprogram DIFactory::CreateSubprogramDefinition(DISubprogram &SPDeclaration) {
 978   if (SPDeclaration.isDefinition())
 979     return DISubprogram(SPDeclaration);
 980
 981   MDNode *DeclNode = SPDeclaration;
 982   Value *Elts[] = {
 983     GetTagConstant(dwarf::DW_TAG_subprogram),
 984     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
 985     DeclNode->getOperand(2), // Context
 986     DeclNode->getOperand(3), // Name
 987     DeclNode->getOperand(4), // DisplayName
 988     DeclNode->getOperand(5), // LinkageName
 989     DeclNode->getOperand(6), // CompileUnit
 990     DeclNode->getOperand(7), // LineNo
 991     DeclNode->getOperand(8), // Type
 992     DeclNode->getOperand(9), // isLocalToUnit
 993     ConstantInt::get(Type::getInt1Ty(VMContext), true), // isDefinition
 994     DeclNode->getOperand(11), // Virtuality
 995     DeclNode->getOperand(12), // VIndex
 996     DeclNode->getOperand(13), // Containting Type
 997     DeclNode->getOperand(14), // isArtificial
 998     DeclNode->getOperand(15), // isOptimized
 999     DeclNode->getOperand(16)  // Function*
1000   };
1001   return DISubprogram(MDNode::get(VMContext, &Elts[0], 17));
1002 }
1003
1004 /// CreateGlobalVariable - Create a new descriptor for the specified global.
1005 DIGlobalVariable
1006 DIFactory::CreateGlobalVariable(DIDescriptor Context, StringRef Name,
1007                                 StringRef DisplayName,
1008                                 StringRef LinkageName,
1009                                 DIFile F,
1010                                 unsigned LineNo, DIType Ty,bool isLocalToUnit,
1011                                 bool isDefinition, llvm::GlobalVariable *Val) {
1012   Value *Elts[] = {
1013     GetTagConstant(dwarf::DW_TAG_variable),
1014     llvm::Constant::getNullValue(Type::getInt32Ty(VMContext)),
1015     Context,
1016     MDString::get(VMContext, Name),
1017     MDString::get(VMContext, DisplayName),
1018     MDString::get(VMContext, LinkageName),
1019     F,
1020     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
1021     Ty,
1022     ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
1023     ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
1024     Val
1025   };
1026
1027   Value *const *Vs = &Elts[0];
1028   MDNode *Node = MDNode::get(VMContext,Vs, 12);
1029
1030   // Create a named metadata so that we do not lose this mdnode.
1031   NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.gv");
1032   NMD->addOperand(Node);
1033
1034   return DIGlobalVariable(Node);
1035 }
1036
1037
1038 /// CreateVariable - Create a new descriptor for the specified variable.
1039 DIVariable DIFactory::CreateVariable(unsigned Tag, DIDescriptor Context,
1040                                      StringRef Name,
1041                                      DIFile F,
1042                                      unsigned LineNo,
1043                                      DIType Ty, bool AlwaysPreserve) {
1044   Value *Elts[] = {
1045     GetTagConstant(Tag),
1046     Context,
1047     MDString::get(VMContext, Name),
1048     F,
1049     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
1050     Ty,
1051   };
1052   MDNode *Node = MDNode::get(VMContext, &Elts[0], 6);
1053   if (AlwaysPreserve) {
1054     // The optimizer may remove local variable. If there is an interest
1055     // to preserve variable info in such situation then stash it in a
1056     // named mdnode.
1057     NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.lv");
1058     NMD->addOperand(Node);
1059   }
1060   return DIVariable(Node);
1061 }
1062
1063
1064 /// CreateComplexVariable - Create a new descriptor for the specified variable
1065 /// which has a complex address expression for its address.
1066 DIVariable DIFactory::CreateComplexVariable(unsigned Tag, DIDescriptor Context,
1067                                             const std::string &Name,
1068                                             DIFile F,
1069                                             unsigned LineNo,
1070                                             DIType Ty,
1071                                             SmallVector<Value *, 9> &addr) {
1072   SmallVector<Value *, 9> Elts;
1073   Elts.push_back(GetTagConstant(Tag));
1074   Elts.push_back(Context);
1075   Elts.push_back(MDString::get(VMContext, Name));
1076   Elts.push_back(F);
1077   Elts.push_back(ConstantInt::get(Type::getInt32Ty(VMContext), LineNo));
1078   Elts.push_back(Ty);
1079   Elts.insert(Elts.end(), addr.begin(), addr.end());
1080
1081   return DIVariable(MDNode::get(VMContext, &Elts[0], 6+addr.size()));
1082 }
1083
1084
1085 /// CreateBlock - This creates a descriptor for a lexical block with the
1086 /// specified parent VMContext.
1087 DILexicalBlock DIFactory::CreateLexicalBlock(DIDescriptor Context,
1088                                              unsigned LineNo, unsigned Col) {
1089   Value *Elts[] = {
1090     GetTagConstant(dwarf::DW_TAG_lexical_block),
1091     Context,
1092     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
1093     ConstantInt::get(Type::getInt32Ty(VMContext), Col)
1094   };
1095   return DILexicalBlock(MDNode::get(VMContext, &Elts[0], 4));
1096 }
1097
1098 /// CreateNameSpace - This creates new descriptor for a namespace
1099 /// with the specified parent context.
1100 DINameSpace DIFactory::CreateNameSpace(DIDescriptor Context, StringRef Name,
1101                                        DIFile F,
1102                                        unsigned LineNo) {
1103   Value *Elts[] = {
1104     GetTagConstant(dwarf::DW_TAG_namespace),
1105     Context,
1106     MDString::get(VMContext, Name),
1107     F,
1108     ConstantInt::get(Type::getInt32Ty(VMContext), LineNo)
1109   };
1110   return DINameSpace(MDNode::get(VMContext, &Elts[0], 5));
1111 }
1112
1113 /// CreateLocation - Creates a debug info location.
1114 DILocation DIFactory::CreateLocation(unsigned LineNo, unsigned ColumnNo,
1115                                      DIScope S, DILocation 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 }