lib/Analysis/DebugInfo.cpp

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