PageRenderTime 89ms CodeModel.GetById 19ms app.highlight 53ms RepoModel.GetById 1ms app.codeStats 0ms

/3rd_party/llvm/lib/Analysis/DebugInfo.cpp

https://code.google.com/p/softart/
C++ | 1143 lines | 820 code | 179 blank | 144 comment | 311 complexity | d7c1847bec8e9b70312841480dfa88bf MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause, JSON, MPL-2.0-no-copyleft-exception, GPL-2.0, GPL-3.0, LGPL-3.0, BSD-2-Clause
   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/ADT/STLExtras.h"
  26#include "llvm/Support/Debug.h"
  27#include "llvm/Support/Dwarf.h"
  28#include "llvm/Support/raw_ostream.h"
  29using namespace llvm;
  30using namespace llvm::dwarf;
  31
  32//===----------------------------------------------------------------------===//
  33// DIDescriptor
  34//===----------------------------------------------------------------------===//
  35
  36DIDescriptor::DIDescriptor(const DIFile F) : DbgNode(F.DbgNode) {
  37}
  38
  39DIDescriptor::DIDescriptor(const DISubprogram F) : DbgNode(F.DbgNode) {
  40}
  41
  42DIDescriptor::DIDescriptor(const DILexicalBlockFile F) : DbgNode(F.DbgNode) {
  43}
  44
  45DIDescriptor::DIDescriptor(const DILexicalBlock F) : DbgNode(F.DbgNode) {
  46}
  47
  48DIDescriptor::DIDescriptor(const DIVariable F) : DbgNode(F.DbgNode) {
  49}
  50
  51DIDescriptor::DIDescriptor(const DIType F) : DbgNode(F.DbgNode) {
  52}
  53
  54StringRef
  55DIDescriptor::getStringField(unsigned Elt) const {
  56  if (DbgNode == 0)
  57    return StringRef();
  58
  59  if (Elt < DbgNode->getNumOperands())
  60    if (MDString *MDS = dyn_cast_or_null<MDString>(DbgNode->getOperand(Elt)))
  61      return MDS->getString();
  62
  63  return StringRef();
  64}
  65
  66uint64_t DIDescriptor::getUInt64Field(unsigned Elt) const {
  67  if (DbgNode == 0)
  68    return 0;
  69
  70  if (Elt < DbgNode->getNumOperands())
  71    if (ConstantInt *CI = dyn_cast<ConstantInt>(DbgNode->getOperand(Elt)))
  72      return CI->getZExtValue();
  73
  74  return 0;
  75}
  76
  77DIDescriptor DIDescriptor::getDescriptorField(unsigned Elt) const {
  78  if (DbgNode == 0)
  79    return DIDescriptor();
  80
  81  if (Elt < DbgNode->getNumOperands())
  82    return
  83      DIDescriptor(dyn_cast_or_null<const MDNode>(DbgNode->getOperand(Elt)));
  84  return DIDescriptor();
  85}
  86
  87GlobalVariable *DIDescriptor::getGlobalVariableField(unsigned Elt) const {
  88  if (DbgNode == 0)
  89    return 0;
  90
  91  if (Elt < DbgNode->getNumOperands())
  92      return dyn_cast_or_null<GlobalVariable>(DbgNode->getOperand(Elt));
  93  return 0;
  94}
  95
  96Constant *DIDescriptor::getConstantField(unsigned Elt) const {
  97  if (DbgNode == 0)
  98    return 0;
  99
 100  if (Elt < DbgNode->getNumOperands())
 101      return dyn_cast_or_null<Constant>(DbgNode->getOperand(Elt));
 102  return 0;
 103}
 104
 105Function *DIDescriptor::getFunctionField(unsigned Elt) const {
 106  if (DbgNode == 0)
 107    return 0;
 108
 109  if (Elt < DbgNode->getNumOperands())
 110      return dyn_cast_or_null<Function>(DbgNode->getOperand(Elt));
 111  return 0;
 112}
 113
 114unsigned DIVariable::getNumAddrElements() const {
 115  if (getVersion() <= llvm::LLVMDebugVersion8)
 116    return DbgNode->getNumOperands()-6;
 117  if (getVersion() == llvm::LLVMDebugVersion9)
 118    return DbgNode->getNumOperands()-7;
 119  return DbgNode->getNumOperands()-8;
 120}
 121
 122/// getInlinedAt - If this variable is inlined then return inline location.
 123MDNode *DIVariable::getInlinedAt() const {
 124  if (getVersion() <= llvm::LLVMDebugVersion9)
 125    return NULL;
 126  return dyn_cast_or_null<MDNode>(DbgNode->getOperand(7));
 127}
 128
 129//===----------------------------------------------------------------------===//
 130// Predicates
 131//===----------------------------------------------------------------------===//
 132
 133/// isBasicType - Return true if the specified tag is legal for
 134/// DIBasicType.
 135bool DIDescriptor::isBasicType() const {
 136  if (!DbgNode) return false;
 137  switch (getTag()) {
 138  case dwarf::DW_TAG_base_type:
 139  case dwarf::DW_TAG_unspecified_type:
 140    return true;
 141  default:
 142    return false;
 143  }
 144}
 145
 146/// isDerivedType - Return true if the specified tag is legal for DIDerivedType.
 147bool DIDescriptor::isDerivedType() const {
 148  if (!DbgNode) return false;
 149  switch (getTag()) {
 150  case dwarf::DW_TAG_typedef:
 151  case dwarf::DW_TAG_pointer_type:
 152  case dwarf::DW_TAG_reference_type:
 153  case dwarf::DW_TAG_const_type:
 154  case dwarf::DW_TAG_volatile_type:
 155  case dwarf::DW_TAG_restrict_type:
 156  case dwarf::DW_TAG_member:
 157  case dwarf::DW_TAG_inheritance:
 158  case dwarf::DW_TAG_friend:
 159    return true;
 160  default:
 161    // CompositeTypes are currently modelled as DerivedTypes.
 162    return isCompositeType();
 163  }
 164}
 165
 166/// isCompositeType - Return true if the specified tag is legal for
 167/// DICompositeType.
 168bool DIDescriptor::isCompositeType() const {
 169  if (!DbgNode) return false;
 170  switch (getTag()) {
 171  case dwarf::DW_TAG_array_type:
 172  case dwarf::DW_TAG_structure_type:
 173  case dwarf::DW_TAG_union_type:
 174  case dwarf::DW_TAG_enumeration_type:
 175  case dwarf::DW_TAG_vector_type:
 176  case dwarf::DW_TAG_subroutine_type:
 177  case dwarf::DW_TAG_class_type:
 178    return true;
 179  default:
 180    return false;
 181  }
 182}
 183
 184/// isVariable - Return true if the specified tag is legal for DIVariable.
 185bool DIDescriptor::isVariable() const {
 186  if (!DbgNode) return false;
 187  switch (getTag()) {
 188  case dwarf::DW_TAG_auto_variable:
 189  case dwarf::DW_TAG_arg_variable:
 190  case dwarf::DW_TAG_return_variable:
 191    return true;
 192  default:
 193    return false;
 194  }
 195}
 196
 197/// isType - Return true if the specified tag is legal for DIType.
 198bool DIDescriptor::isType() const {
 199  return isBasicType() || isCompositeType() || isDerivedType();
 200}
 201
 202/// isSubprogram - Return true if the specified tag is legal for
 203/// DISubprogram.
 204bool DIDescriptor::isSubprogram() const {
 205  return DbgNode && getTag() == dwarf::DW_TAG_subprogram;
 206}
 207
 208/// isGlobalVariable - Return true if the specified tag is legal for
 209/// DIGlobalVariable.
 210bool DIDescriptor::isGlobalVariable() const {
 211  return DbgNode && (getTag() == dwarf::DW_TAG_variable ||
 212                     getTag() == dwarf::DW_TAG_constant);
 213}
 214
 215/// isGlobal - Return true if the specified tag is legal for DIGlobal.
 216bool DIDescriptor::isGlobal() const {
 217  return isGlobalVariable();
 218}
 219
 220/// isUnspecifiedParmeter - Return true if the specified tag is
 221/// DW_TAG_unspecified_parameters.
 222bool DIDescriptor::isUnspecifiedParameter() const {
 223  return DbgNode && getTag() == dwarf::DW_TAG_unspecified_parameters;
 224}
 225
 226/// isScope - Return true if the specified tag is one of the scope
 227/// related tag.
 228bool DIDescriptor::isScope() const {
 229  if (!DbgNode) return false;
 230  switch (getTag()) {
 231  case dwarf::DW_TAG_compile_unit:
 232  case dwarf::DW_TAG_lexical_block:
 233  case dwarf::DW_TAG_subprogram:
 234  case dwarf::DW_TAG_namespace:
 235    return true;
 236  default:
 237    break;
 238  }
 239  return false;
 240}
 241
 242/// isTemplateTypeParameter - Return true if the specified tag is
 243/// DW_TAG_template_type_parameter.
 244bool DIDescriptor::isTemplateTypeParameter() const {
 245  return DbgNode && getTag() == dwarf::DW_TAG_template_type_parameter;
 246}
 247
 248/// isTemplateValueParameter - Return true if the specified tag is
 249/// DW_TAG_template_value_parameter.
 250bool DIDescriptor::isTemplateValueParameter() const {
 251  return DbgNode && getTag() == dwarf::DW_TAG_template_value_parameter;
 252}
 253
 254/// isCompileUnit - Return true if the specified tag is DW_TAG_compile_unit.
 255bool DIDescriptor::isCompileUnit() const {
 256  return DbgNode && getTag() == dwarf::DW_TAG_compile_unit;
 257}
 258
 259/// isFile - Return true if the specified tag is DW_TAG_file_type.
 260bool DIDescriptor::isFile() const {
 261  return DbgNode && getTag() == dwarf::DW_TAG_file_type;
 262}
 263
 264/// isNameSpace - Return true if the specified tag is DW_TAG_namespace.
 265bool DIDescriptor::isNameSpace() const {
 266  return DbgNode && getTag() == dwarf::DW_TAG_namespace;
 267}
 268
 269/// isLexicalBlockFile - Return true if the specified descriptor is a
 270/// lexical block with an extra file.
 271bool DIDescriptor::isLexicalBlockFile() const {
 272  return DbgNode && getTag() == dwarf::DW_TAG_lexical_block &&
 273    (DbgNode->getNumOperands() == 3);
 274}
 275
 276/// isLexicalBlock - Return true if the specified tag is DW_TAG_lexical_block.
 277bool DIDescriptor::isLexicalBlock() const {
 278  return DbgNode && getTag() == dwarf::DW_TAG_lexical_block &&
 279    (DbgNode->getNumOperands() > 3);
 280}
 281
 282/// isSubrange - Return true if the specified tag is DW_TAG_subrange_type.
 283bool DIDescriptor::isSubrange() const {
 284  return DbgNode && getTag() == dwarf::DW_TAG_subrange_type;
 285}
 286
 287/// isEnumerator - Return true if the specified tag is DW_TAG_enumerator.
 288bool DIDescriptor::isEnumerator() const {
 289  return DbgNode && getTag() == dwarf::DW_TAG_enumerator;
 290}
 291
 292//===----------------------------------------------------------------------===//
 293// Simple Descriptor Constructors and other Methods
 294//===----------------------------------------------------------------------===//
 295
 296DIType::DIType(const MDNode *N) : DIScope(N) {
 297  if (!N) return;
 298  if (!isBasicType() && !isDerivedType() && !isCompositeType()) {
 299    DbgNode = 0;
 300  }
 301}
 302
 303unsigned DIArray::getNumElements() const {
 304  if (!DbgNode)
 305    return 0;
 306  return DbgNode->getNumOperands();
 307}
 308
 309/// replaceAllUsesWith - Replace all uses of debug info referenced by
 310/// this descriptor.
 311void DIType::replaceAllUsesWith(DIDescriptor &D) {
 312  if (!DbgNode)
 313    return;
 314
 315  // Since we use a TrackingVH for the node, its easy for clients to manufacture
 316  // legitimate situations where they want to replaceAllUsesWith() on something
 317  // which, due to uniquing, has merged with the source. We shield clients from
 318  // this detail by allowing a value to be replaced with replaceAllUsesWith()
 319  // itself.
 320  if (DbgNode != D) {
 321    MDNode *Node = const_cast<MDNode*>(DbgNode);
 322    const MDNode *DN = D;
 323    const Value *V = cast_or_null<Value>(DN);
 324    Node->replaceAllUsesWith(const_cast<Value*>(V));
 325    MDNode::deleteTemporary(Node);
 326  }
 327}
 328
 329/// replaceAllUsesWith - Replace all uses of debug info referenced by
 330/// this descriptor.
 331void DIType::replaceAllUsesWith(MDNode *D) {
 332  if (!DbgNode)
 333    return;
 334
 335  // Since we use a TrackingVH for the node, its easy for clients to manufacture
 336  // legitimate situations where they want to replaceAllUsesWith() on something
 337  // which, due to uniquing, has merged with the source. We shield clients from
 338  // this detail by allowing a value to be replaced with replaceAllUsesWith()
 339  // itself.
 340  if (DbgNode != D) {
 341    MDNode *Node = const_cast<MDNode*>(DbgNode);
 342    const MDNode *DN = D;
 343    const Value *V = cast_or_null<Value>(DN);
 344    Node->replaceAllUsesWith(const_cast<Value*>(V));
 345    MDNode::deleteTemporary(Node);
 346  }
 347}
 348
 349/// isUnsignedDIType - Return true if type encoding is unsigned.
 350bool DIType::isUnsignedDIType() {
 351  DIDerivedType DTy(DbgNode);
 352  if (DTy.Verify())
 353    return DTy.getTypeDerivedFrom().isUnsignedDIType();
 354
 355  DIBasicType BTy(DbgNode);
 356  if (BTy.Verify()) {
 357    unsigned Encoding = BTy.getEncoding();
 358    if (Encoding == dwarf::DW_ATE_unsigned ||
 359        Encoding == dwarf::DW_ATE_unsigned_char)
 360      return true;
 361  }
 362  return false;
 363}
 364
 365/// Verify - Verify that a compile unit is well formed.
 366bool DICompileUnit::Verify() const {
 367  if (!DbgNode)
 368    return false;
 369  StringRef N = getFilename();
 370  if (N.empty())
 371    return false;
 372  // It is possible that directory and produce string is empty.
 373  return true;
 374}
 375
 376/// Verify - Verify that a type descriptor is well formed.
 377bool DIType::Verify() const {
 378  if (!DbgNode)
 379    return false;
 380  if (getContext() && !getContext().Verify())
 381    return false;
 382  unsigned Tag = getTag();
 383  if (!isBasicType() && Tag != dwarf::DW_TAG_const_type &&
 384      Tag != dwarf::DW_TAG_volatile_type && Tag != dwarf::DW_TAG_pointer_type &&
 385      Tag != dwarf::DW_TAG_reference_type && Tag != dwarf::DW_TAG_restrict_type 
 386      && Tag != dwarf::DW_TAG_vector_type && Tag != dwarf::DW_TAG_array_type
 387      && Tag != dwarf::DW_TAG_enumeration_type 
 388      && Tag != dwarf::DW_TAG_subroutine_type
 389      && getFilename().empty())
 390    return false;
 391  return true;
 392}
 393
 394/// Verify - Verify that a basic type descriptor is well formed.
 395bool DIBasicType::Verify() const {
 396  return isBasicType();
 397}
 398
 399/// Verify - Verify that a derived type descriptor is well formed.
 400bool DIDerivedType::Verify() const {
 401  return isDerivedType();
 402}
 403
 404/// Verify - Verify that a composite type descriptor is well formed.
 405bool DICompositeType::Verify() const {
 406  if (!DbgNode)
 407    return false;
 408  if (getContext() && !getContext().Verify())
 409    return false;
 410
 411  return true;
 412}
 413
 414/// Verify - Verify that a subprogram descriptor is well formed.
 415bool DISubprogram::Verify() const {
 416  if (!DbgNode)
 417    return false;
 418
 419  if (getContext() && !getContext().Verify())
 420    return false;
 421
 422  DICompositeType Ty = getType();
 423  if (!Ty.Verify())
 424    return false;
 425  return true;
 426}
 427
 428/// Verify - Verify that a global variable descriptor is well formed.
 429bool DIGlobalVariable::Verify() const {
 430  if (!DbgNode)
 431    return false;
 432
 433  if (getDisplayName().empty())
 434    return false;
 435
 436  if (getContext() && !getContext().Verify())
 437    return false;
 438
 439  DIType Ty = getType();
 440  if (!Ty.Verify())
 441    return false;
 442
 443  if (!getGlobal() && !getConstant())
 444    return false;
 445
 446  return true;
 447}
 448
 449/// Verify - Verify that a variable descriptor is well formed.
 450bool DIVariable::Verify() const {
 451  if (!DbgNode)
 452    return false;
 453
 454  if (getContext() && !getContext().Verify())
 455    return false;
 456
 457  DIType Ty = getType();
 458  if (!Ty.Verify())
 459    return false;
 460
 461  return true;
 462}
 463
 464/// Verify - Verify that a location descriptor is well formed.
 465bool DILocation::Verify() const {
 466  if (!DbgNode)
 467    return false;
 468
 469  return DbgNode->getNumOperands() == 4;
 470}
 471
 472/// Verify - Verify that a namespace descriptor is well formed.
 473bool DINameSpace::Verify() const {
 474  if (!DbgNode)
 475    return false;
 476  if (getName().empty())
 477    return false;
 478  return true;
 479}
 480
 481/// getOriginalTypeSize - If this type is derived from a base type then
 482/// return base type size.
 483uint64_t DIDerivedType::getOriginalTypeSize() const {
 484  unsigned Tag = getTag();
 485  if (Tag == dwarf::DW_TAG_member || Tag == dwarf::DW_TAG_typedef ||
 486      Tag == dwarf::DW_TAG_const_type || Tag == dwarf::DW_TAG_volatile_type ||
 487      Tag == dwarf::DW_TAG_restrict_type) {
 488    DIType BaseType = getTypeDerivedFrom();
 489    // If this type is not derived from any type then take conservative
 490    // approach.
 491    if (!BaseType.isValid())
 492      return getSizeInBits();
 493    if (BaseType.isDerivedType())
 494      return DIDerivedType(BaseType).getOriginalTypeSize();
 495    else
 496      return BaseType.getSizeInBits();
 497  }
 498
 499  return getSizeInBits();
 500}
 501
 502/// isInlinedFnArgument - Return true if this variable provides debugging
 503/// information for an inlined function arguments.
 504bool DIVariable::isInlinedFnArgument(const Function *CurFn) {
 505  assert(CurFn && "Invalid function");
 506  if (!getContext().isSubprogram())
 507    return false;
 508  // This variable is not inlined function argument if its scope
 509  // does not describe current function.
 510  return !(DISubprogram(getContext()).describes(CurFn));
 511}
 512
 513/// describes - Return true if this subprogram provides debugging
 514/// information for the function F.
 515bool DISubprogram::describes(const Function *F) {
 516  assert(F && "Invalid function");
 517  if (F == getFunction())
 518    return true;
 519  StringRef Name = getLinkageName();
 520  if (Name.empty())
 521    Name = getName();
 522  if (F->getName() == Name)
 523    return true;
 524  return false;
 525}
 526
 527unsigned DISubprogram::isOptimized() const {
 528  assert (DbgNode && "Invalid subprogram descriptor!");
 529  if (DbgNode->getNumOperands() == 16)
 530    return getUnsignedField(15);
 531  return 0;
 532}
 533
 534MDNode *DISubprogram::getVariablesNodes() const {
 535  if (!DbgNode || DbgNode->getNumOperands() <= 19)
 536    return NULL;
 537  if (MDNode *Temp = dyn_cast_or_null<MDNode>(DbgNode->getOperand(19)))
 538    return dyn_cast_or_null<MDNode>(Temp->getOperand(0));
 539  return NULL;
 540}
 541
 542DIArray DISubprogram::getVariables() const {
 543  if (!DbgNode || DbgNode->getNumOperands() <= 19)
 544    return DIArray();
 545  if (MDNode *T = dyn_cast_or_null<MDNode>(DbgNode->getOperand(19)))
 546    if (MDNode *A = dyn_cast_or_null<MDNode>(T->getOperand(0)))
 547      return DIArray(A);
 548  return DIArray();
 549}
 550
 551StringRef DIScope::getFilename() const {
 552  if (!DbgNode)
 553    return StringRef();
 554  if (isLexicalBlockFile())
 555    return DILexicalBlockFile(DbgNode).getFilename();
 556  if (isLexicalBlock())
 557    return DILexicalBlock(DbgNode).getFilename();
 558  if (isSubprogram())
 559    return DISubprogram(DbgNode).getFilename();
 560  if (isCompileUnit())
 561    return DICompileUnit(DbgNode).getFilename();
 562  if (isNameSpace())
 563    return DINameSpace(DbgNode).getFilename();
 564  if (isType())
 565    return DIType(DbgNode).getFilename();
 566  if (isFile())
 567    return DIFile(DbgNode).getFilename();
 568  assert(0 && "Invalid DIScope!");
 569  return StringRef();
 570}
 571
 572StringRef DIScope::getDirectory() const {
 573  if (!DbgNode)
 574    return StringRef();
 575  if (isLexicalBlockFile())
 576    return DILexicalBlockFile(DbgNode).getDirectory();
 577  if (isLexicalBlock())
 578    return DILexicalBlock(DbgNode).getDirectory();
 579  if (isSubprogram())
 580    return DISubprogram(DbgNode).getDirectory();
 581  if (isCompileUnit())
 582    return DICompileUnit(DbgNode).getDirectory();
 583  if (isNameSpace())
 584    return DINameSpace(DbgNode).getDirectory();
 585  if (isType())
 586    return DIType(DbgNode).getDirectory();
 587  if (isFile())
 588    return DIFile(DbgNode).getDirectory();
 589  assert(0 && "Invalid DIScope!");
 590  return StringRef();
 591}
 592
 593DIArray DICompileUnit::getEnumTypes() const {
 594  if (!DbgNode || DbgNode->getNumOperands() < 14)
 595    return DIArray();
 596
 597  if (MDNode *N = dyn_cast_or_null<MDNode>(DbgNode->getOperand(10)))
 598    if (MDNode *A = dyn_cast_or_null<MDNode>(N->getOperand(0)))
 599      return DIArray(A);
 600  return DIArray();
 601}
 602
 603DIArray DICompileUnit::getRetainedTypes() const {
 604  if (!DbgNode || DbgNode->getNumOperands() < 14)
 605    return DIArray();
 606
 607  if (MDNode *N = dyn_cast_or_null<MDNode>(DbgNode->getOperand(11)))
 608    if (MDNode *A = dyn_cast_or_null<MDNode>(N->getOperand(0)))
 609      return DIArray(A);
 610  return DIArray();
 611}
 612
 613DIArray DICompileUnit::getSubprograms() const {
 614  if (!DbgNode || DbgNode->getNumOperands() < 14)
 615    return DIArray();
 616
 617  if (MDNode *N = dyn_cast_or_null<MDNode>(DbgNode->getOperand(12)))
 618    if (MDNode *A = dyn_cast_or_null<MDNode>(N->getOperand(0)))
 619      return DIArray(A);
 620  return DIArray();
 621}
 622
 623
 624DIArray DICompileUnit::getGlobalVariables() const {
 625  if (!DbgNode || DbgNode->getNumOperands() < 14)
 626    return DIArray();
 627
 628  if (MDNode *N = dyn_cast_or_null<MDNode>(DbgNode->getOperand(13)))
 629    if (MDNode *A = dyn_cast_or_null<MDNode>(N->getOperand(0)))
 630      return DIArray(A);
 631  return DIArray();
 632}
 633
 634//===----------------------------------------------------------------------===//
 635// DIDescriptor: dump routines for all descriptors.
 636//===----------------------------------------------------------------------===//
 637
 638
 639/// print - Print descriptor.
 640void DIDescriptor::print(raw_ostream &OS) const {
 641  OS << "[" << dwarf::TagString(getTag()) << "] ";
 642  OS.write_hex((intptr_t) &*DbgNode) << ']';
 643}
 644
 645/// print - Print compile unit.
 646void DICompileUnit::print(raw_ostream &OS) const {
 647  if (getLanguage())
 648    OS << " [" << dwarf::LanguageString(getLanguage()) << "] ";
 649
 650  OS << " [" << getDirectory() << "/" << getFilename() << "]";
 651}
 652
 653/// print - Print type.
 654void DIType::print(raw_ostream &OS) const {
 655  if (!DbgNode) return;
 656
 657  StringRef Res = getName();
 658  if (!Res.empty())
 659    OS << " [" << Res << "] ";
 660
 661  unsigned Tag = getTag();
 662  OS << " [" << dwarf::TagString(Tag) << "] ";
 663
 664  // TODO : Print context
 665  OS << " ["
 666         << "line " << getLineNumber() << ", "
 667         << getSizeInBits() << " bits, "
 668         << getAlignInBits() << " bit alignment, "
 669         << getOffsetInBits() << " bit offset"
 670         << "] ";
 671
 672  if (isPrivate())
 673    OS << " [private] ";
 674  else if (isProtected())
 675    OS << " [protected] ";
 676
 677  if (isForwardDecl())
 678    OS << " [fwd] ";
 679
 680  if (isBasicType())
 681    DIBasicType(DbgNode).print(OS);
 682  else if (isDerivedType())
 683    DIDerivedType(DbgNode).print(OS);
 684  else if (isCompositeType())
 685    DICompositeType(DbgNode).print(OS);
 686  else {
 687    OS << "Invalid DIType\n";
 688    return;
 689  }
 690
 691  OS << "\n";
 692}
 693
 694/// print - Print basic type.
 695void DIBasicType::print(raw_ostream &OS) const {
 696  OS << " [" << dwarf::AttributeEncodingString(getEncoding()) << "] ";
 697}
 698
 699/// print - Print derived type.
 700void DIDerivedType::print(raw_ostream &OS) const {
 701  OS << "\n\t Derived From: "; getTypeDerivedFrom().print(OS);
 702}
 703
 704/// print - Print composite type.
 705void DICompositeType::print(raw_ostream &OS) const {
 706  DIArray A = getTypeArray();
 707  OS << " [" << A.getNumElements() << " elements]";
 708}
 709
 710/// print - Print subprogram.
 711void DISubprogram::print(raw_ostream &OS) const {
 712  StringRef Res = getName();
 713  if (!Res.empty())
 714    OS << " [" << Res << "] ";
 715
 716  unsigned Tag = getTag();
 717  OS << " [" << dwarf::TagString(Tag) << "] ";
 718
 719  // TODO : Print context
 720  OS << " [" << getLineNumber() << "] ";
 721
 722  if (isLocalToUnit())
 723    OS << " [local] ";
 724
 725  if (isDefinition())
 726    OS << " [def] ";
 727
 728  OS << "\n";
 729}
 730
 731/// print - Print global variable.
 732void DIGlobalVariable::print(raw_ostream &OS) const {
 733  OS << " [";
 734  StringRef Res = getName();
 735  if (!Res.empty())
 736    OS << " [" << Res << "] ";
 737
 738  unsigned Tag = getTag();
 739  OS << " [" << dwarf::TagString(Tag) << "] ";
 740
 741  // TODO : Print context
 742  OS << " [" << getLineNumber() << "] ";
 743
 744  if (isLocalToUnit())
 745    OS << " [local] ";
 746
 747  if (isDefinition())
 748    OS << " [def] ";
 749
 750  if (isGlobalVariable())
 751    DIGlobalVariable(DbgNode).print(OS);
 752  OS << "]\n";
 753}
 754
 755static void printDebugLoc(DebugLoc DL, raw_ostream &CommentOS,
 756                          const LLVMContext &Ctx) {
 757  if (!DL.isUnknown()) {          // Print source line info.
 758    DIScope Scope(DL.getScope(Ctx));
 759    // Omit the directory, because it's likely to be long and uninteresting.
 760    if (Scope.Verify())
 761      CommentOS << Scope.getFilename();
 762    else
 763      CommentOS << "<unknown>";
 764    CommentOS << ':' << DL.getLine();
 765    if (DL.getCol() != 0)
 766      CommentOS << ':' << DL.getCol();
 767    DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(DL.getInlinedAt(Ctx));
 768    if (!InlinedAtDL.isUnknown()) {
 769      CommentOS << " @[ ";
 770      printDebugLoc(InlinedAtDL, CommentOS, Ctx);
 771      CommentOS << " ]";
 772    }
 773  }
 774}
 775
 776void DIVariable::printExtendedName(raw_ostream &OS) const {
 777  const LLVMContext &Ctx = DbgNode->getContext();
 778  StringRef Res = getName();
 779  if (!Res.empty())
 780    OS << Res << "," << getLineNumber();
 781  if (MDNode *InlinedAt = getInlinedAt()) {
 782    DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(InlinedAt);
 783    if (!InlinedAtDL.isUnknown()) {
 784      OS << " @[";
 785      printDebugLoc(InlinedAtDL, OS, Ctx);
 786      OS << "]";
 787    }
 788  }
 789}
 790
 791/// print - Print variable.
 792void DIVariable::print(raw_ostream &OS) const {
 793  StringRef Res = getName();
 794  if (!Res.empty())
 795    OS << " [" << Res << "] ";
 796
 797  OS << " [" << getLineNumber() << "] ";
 798  getType().print(OS);
 799  OS << "\n";
 800
 801  // FIXME: Dump complex addresses
 802}
 803
 804/// dump - Print descriptor to dbgs() with a newline.
 805void DIDescriptor::dump() const {
 806  print(dbgs()); dbgs() << '\n';
 807}
 808
 809/// dump - Print compile unit to dbgs() with a newline.
 810void DICompileUnit::dump() const {
 811  print(dbgs()); dbgs() << '\n';
 812}
 813
 814/// dump - Print type to dbgs() with a newline.
 815void DIType::dump() const {
 816  print(dbgs()); dbgs() << '\n';
 817}
 818
 819/// dump - Print basic type to dbgs() with a newline.
 820void DIBasicType::dump() const {
 821  print(dbgs()); dbgs() << '\n';
 822}
 823
 824/// dump - Print derived type to dbgs() with a newline.
 825void DIDerivedType::dump() const {
 826  print(dbgs()); dbgs() << '\n';
 827}
 828
 829/// dump - Print composite type to dbgs() with a newline.
 830void DICompositeType::dump() const {
 831  print(dbgs()); dbgs() << '\n';
 832}
 833
 834/// dump - Print subprogram to dbgs() with a newline.
 835void DISubprogram::dump() const {
 836  print(dbgs()); dbgs() << '\n';
 837}
 838
 839/// dump - Print global variable.
 840void DIGlobalVariable::dump() const {
 841  print(dbgs()); dbgs() << '\n';
 842}
 843
 844/// dump - Print variable.
 845void DIVariable::dump() const {
 846  print(dbgs()); dbgs() << '\n';
 847}
 848
 849/// fixupObjcLikeName - Replace contains special characters used
 850/// in a typical Objective-C names with '.' in a given string.
 851static void fixupObjcLikeName(StringRef Str, SmallVectorImpl<char> &Out) {
 852  bool isObjCLike = false;
 853  for (size_t i = 0, e = Str.size(); i < e; ++i) {
 854    char C = Str[i];
 855    if (C == '[')
 856      isObjCLike = true;
 857
 858    if (isObjCLike && (C == '[' || C == ']' || C == ' ' || C == ':' ||
 859                       C == '+' || C == '(' || C == ')'))
 860      Out.push_back('.');
 861    else
 862      Out.push_back(C);
 863  }
 864}
 865
 866/// getFnSpecificMDNode - Return a NameMDNode, if available, that is 
 867/// suitable to hold function specific information.
 868NamedMDNode *llvm::getFnSpecificMDNode(const Module &M, DISubprogram Fn) {
 869  SmallString<32> Name = StringRef("llvm.dbg.lv.");
 870  StringRef FName = "fn";
 871  if (Fn.getFunction())
 872    FName = Fn.getFunction()->getName();
 873  else
 874    FName = Fn.getName();
 875  char One = '\1';
 876  if (FName.startswith(StringRef(&One, 1)))
 877    FName = FName.substr(1);
 878  fixupObjcLikeName(FName, Name);
 879  return M.getNamedMetadata(Name.str());
 880}
 881
 882/// getOrInsertFnSpecificMDNode - Return a NameMDNode that is suitable
 883/// to hold function specific information.
 884NamedMDNode *llvm::getOrInsertFnSpecificMDNode(Module &M, DISubprogram Fn) {
 885  SmallString<32> Name = StringRef("llvm.dbg.lv.");
 886  StringRef FName = "fn";
 887  if (Fn.getFunction())
 888    FName = Fn.getFunction()->getName();
 889  else
 890    FName = Fn.getName();
 891  char One = '\1';
 892  if (FName.startswith(StringRef(&One, 1)))
 893    FName = FName.substr(1);
 894  fixupObjcLikeName(FName, Name);
 895  
 896  return M.getOrInsertNamedMetadata(Name.str());
 897}
 898
 899/// createInlinedVariable - Create a new inlined variable based on current
 900/// variable.
 901/// @param DV            Current Variable.
 902/// @param InlinedScope  Location at current variable is inlined.
 903DIVariable llvm::createInlinedVariable(MDNode *DV, MDNode *InlinedScope,
 904                                       LLVMContext &VMContext) {
 905  SmallVector<Value *, 16> Elts;
 906  // Insert inlined scope as 7th element.
 907  for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i)
 908    i == 7 ? Elts.push_back(InlinedScope) :
 909             Elts.push_back(DV->getOperand(i));
 910  return DIVariable(MDNode::get(VMContext, Elts));
 911}
 912
 913/// cleanseInlinedVariable - Remove inlined scope from the variable.
 914DIVariable llvm::cleanseInlinedVariable(MDNode *DV, LLVMContext &VMContext) {
 915  SmallVector<Value *, 16> Elts;
 916  // Insert inlined scope as 7th element.
 917  for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i)
 918    i == 7 ? 
 919      Elts.push_back(llvm::Constant::getNullValue(Type::getInt32Ty(VMContext))):
 920      Elts.push_back(DV->getOperand(i));
 921  return DIVariable(MDNode::get(VMContext, Elts));
 922}
 923
 924//===----------------------------------------------------------------------===//
 925// DebugInfoFinder implementations.
 926//===----------------------------------------------------------------------===//
 927
 928/// processModule - Process entire module and collect debug info.
 929void DebugInfoFinder::processModule(Module &M) {
 930  if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu"))
 931    for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
 932      addCompileUnit(DICompileUnit(CU_Nodes->getOperand(i)));
 933
 934  for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
 935    for (Function::iterator FI = (*I).begin(), FE = (*I).end(); FI != FE; ++FI)
 936      for (BasicBlock::iterator BI = (*FI).begin(), BE = (*FI).end(); BI != BE;
 937           ++BI) {
 938        if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(BI))
 939          processDeclare(DDI);
 940
 941        DebugLoc Loc = BI->getDebugLoc();
 942        if (Loc.isUnknown())
 943          continue;
 944
 945        LLVMContext &Ctx = BI->getContext();
 946        DIDescriptor Scope(Loc.getScope(Ctx));
 947
 948        if (Scope.isCompileUnit())
 949          addCompileUnit(DICompileUnit(Scope));
 950        else if (Scope.isSubprogram())
 951          processSubprogram(DISubprogram(Scope));
 952        else if (Scope.isLexicalBlockFile()) {
 953          DILexicalBlockFile DBF = DILexicalBlockFile(Scope);
 954          processLexicalBlock(DILexicalBlock(DBF.getScope()));
 955        }
 956        else if (Scope.isLexicalBlock())
 957          processLexicalBlock(DILexicalBlock(Scope));
 958
 959        if (MDNode *IA = Loc.getInlinedAt(Ctx))
 960          processLocation(DILocation(IA));
 961      }
 962
 963  if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.gv")) {
 964    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
 965      DIGlobalVariable DIG(cast<MDNode>(NMD->getOperand(i)));
 966      if (addGlobalVariable(DIG)) {
 967        if (DIG.getVersion() <= LLVMDebugVersion10)
 968          addCompileUnit(DIG.getCompileUnit());
 969        processType(DIG.getType());
 970      }
 971    }
 972  }
 973
 974  if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp"))
 975    for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
 976      processSubprogram(DISubprogram(NMD->getOperand(i)));
 977}
 978
 979/// processLocation - Process DILocation.
 980void DebugInfoFinder::processLocation(DILocation Loc) {
 981  if (!Loc.Verify()) return;
 982  DIDescriptor S(Loc.getScope());
 983  if (S.isCompileUnit())
 984    addCompileUnit(DICompileUnit(S));
 985  else if (S.isSubprogram())
 986    processSubprogram(DISubprogram(S));
 987  else if (S.isLexicalBlock())
 988    processLexicalBlock(DILexicalBlock(S));
 989  else if (S.isLexicalBlockFile()) {
 990    DILexicalBlockFile DBF = DILexicalBlockFile(S);
 991    processLexicalBlock(DILexicalBlock(DBF.getScope()));
 992  }
 993  processLocation(Loc.getOrigLocation());
 994}
 995
 996/// processType - Process DIType.
 997void DebugInfoFinder::processType(DIType DT) {
 998  if (!addType(DT))
 999    return;
1000  if (DT.getVersion() <= LLVMDebugVersion10)
1001    addCompileUnit(DT.getCompileUnit());
1002  if (DT.isCompositeType()) {
1003    DICompositeType DCT(DT);
1004    processType(DCT.getTypeDerivedFrom());
1005    DIArray DA = DCT.getTypeArray();
1006    for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) {
1007      DIDescriptor D = DA.getElement(i);
1008      if (D.isType())
1009        processType(DIType(D));
1010      else if (D.isSubprogram())
1011        processSubprogram(DISubprogram(D));
1012    }
1013  } else if (DT.isDerivedType()) {
1014    DIDerivedType DDT(DT);
1015    processType(DDT.getTypeDerivedFrom());
1016  }
1017}
1018
1019/// processLexicalBlock
1020void DebugInfoFinder::processLexicalBlock(DILexicalBlock LB) {
1021  DIScope Context = LB.getContext();
1022  if (Context.isLexicalBlock())
1023    return processLexicalBlock(DILexicalBlock(Context));
1024  else if (Context.isLexicalBlockFile()) {
1025    DILexicalBlockFile DBF = DILexicalBlockFile(Context);
1026    return processLexicalBlock(DILexicalBlock(DBF.getScope()));
1027  }
1028  else
1029    return processSubprogram(DISubprogram(Context));
1030}
1031
1032/// processSubprogram - Process DISubprogram.
1033void DebugInfoFinder::processSubprogram(DISubprogram SP) {
1034  if (!addSubprogram(SP))
1035    return;
1036  if (SP.getVersion() <= LLVMDebugVersion10)
1037    addCompileUnit(SP.getCompileUnit());
1038  processType(SP.getType());
1039}
1040
1041/// processDeclare - Process DbgDeclareInst.
1042void DebugInfoFinder::processDeclare(DbgDeclareInst *DDI) {
1043  MDNode *N = dyn_cast<MDNode>(DDI->getVariable());
1044  if (!N) return;
1045
1046  DIDescriptor DV(N);
1047  if (!DV.isVariable())
1048    return;
1049
1050  if (!NodesSeen.insert(DV))
1051    return;
1052  if (DIVariable(N).getVersion() <= LLVMDebugVersion10)
1053    addCompileUnit(DIVariable(N).getCompileUnit());
1054  processType(DIVariable(N).getType());
1055}
1056
1057/// addType - Add type into Tys.
1058bool DebugInfoFinder::addType(DIType DT) {
1059  if (!DT.isValid())
1060    return false;
1061
1062  if (!NodesSeen.insert(DT))
1063    return false;
1064
1065  TYs.push_back(DT);
1066  return true;
1067}
1068
1069/// addCompileUnit - Add compile unit into CUs.
1070bool DebugInfoFinder::addCompileUnit(DICompileUnit CU) {
1071  if (!CU.Verify())
1072    return false;
1073
1074  if (!NodesSeen.insert(CU))
1075    return false;
1076
1077  CUs.push_back(CU);
1078  return true;
1079}
1080
1081/// addGlobalVariable - Add global variable into GVs.
1082bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable DIG) {
1083  if (!DIDescriptor(DIG).isGlobalVariable())
1084    return false;
1085
1086  if (!NodesSeen.insert(DIG))
1087    return false;
1088
1089  GVs.push_back(DIG);
1090  return true;
1091}
1092
1093// addSubprogram - Add subprgoram into SPs.
1094bool DebugInfoFinder::addSubprogram(DISubprogram SP) {
1095  if (!DIDescriptor(SP).isSubprogram())
1096    return false;
1097
1098  if (!NodesSeen.insert(SP))
1099    return false;
1100
1101  SPs.push_back(SP);
1102  return true;
1103}
1104
1105/// getDISubprogram - Find subprogram that is enclosing this scope.
1106DISubprogram llvm::getDISubprogram(const MDNode *Scope) {
1107  DIDescriptor D(Scope);
1108  if (D.isSubprogram())
1109    return DISubprogram(Scope);
1110
1111  if (D.isLexicalBlockFile())
1112    return getDISubprogram(DILexicalBlockFile(Scope).getContext());
1113  
1114  if (D.isLexicalBlock())
1115    return getDISubprogram(DILexicalBlock(Scope).getContext());
1116
1117  return DISubprogram();
1118}
1119
1120/// getDICompositeType - Find underlying composite type.
1121DICompositeType llvm::getDICompositeType(DIType T) {
1122  if (T.isCompositeType())
1123    return DICompositeType(T);
1124
1125  if (T.isDerivedType())
1126    return getDICompositeType(DIDerivedType(T).getTypeDerivedFrom());
1127
1128  return DICompositeType();
1129}
1130
1131/// isSubprogramContext - Return true if Context is either a subprogram
1132/// or another context nested inside a subprogram.
1133bool llvm::isSubprogramContext(const MDNode *Context) {
1134  if (!Context)
1135    return false;
1136  DIDescriptor D(Context);
1137  if (D.isSubprogram())
1138    return true;
1139  if (D.isType())
1140    return isSubprogramContext(DIType(Context).getContext());
1141  return false;
1142}
1143