contrib/llvm/tools/lldb/source/Symbol/SymbolContext.cpp

   1 //===-- SymbolContext.cpp ---------------------------------------*- C++ -*-===//
   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 #include "lldb/Symbol/SymbolContext.h"
  11
  12 #include "lldb/Core/Log.h"
  13 #include "lldb/Core/Module.h"
  14 #include "lldb/Core/ModuleSpec.h"
  15 #include "lldb/Host/Host.h"
  16 #include "lldb/Interpreter/Args.h"
  17 #include "lldb/Symbol/Block.h"
  18 #include "lldb/Symbol/ClangASTContext.h"
  19 #include "lldb/Symbol/CompileUnit.h"
  20 #include "lldb/Symbol/ObjectFile.h"
  21 #include "lldb/Symbol/Symbol.h"
  22 #include "lldb/Symbol/SymbolFile.h"
  23 #include "lldb/Symbol/SymbolVendor.h"
  24 #include "lldb/Target/Target.h"
  25
  26 using namespace lldb;
  27 using namespace lldb_private;
  28
  29 SymbolContext::SymbolContext() :
  30     target_sp   (),
  31     module_sp   (),
  32     comp_unit   (NULL),
  33     function    (NULL),
  34     block       (NULL),
  35     line_entry  (),
  36     symbol      (NULL)
  37 {
  38 }
  39
  40 SymbolContext::SymbolContext(const ModuleSP& m, CompileUnit *cu, Function *f, Block *b, LineEntry *le, Symbol *s) :
  41     target_sp   (),
  42     module_sp   (m),
  43     comp_unit   (cu),
  44     function    (f),
  45     block       (b),
  46     line_entry  (),
  47     symbol      (s)
  48 {
  49     if (le)
  50         line_entry = *le;
  51 }
  52
  53 SymbolContext::SymbolContext(const TargetSP &t, const ModuleSP& m, CompileUnit *cu, Function *f, Block *b, LineEntry *le, Symbol *s) :
  54     target_sp   (t),
  55     module_sp   (m),
  56     comp_unit   (cu),
  57     function    (f),
  58     block       (b),
  59     line_entry  (),
  60     symbol      (s)
  61 {
  62     if (le)
  63         line_entry = *le;
  64 }
  65
  66 SymbolContext::SymbolContext(const SymbolContext& rhs) :
  67     target_sp   (rhs.target_sp),
  68     module_sp   (rhs.module_sp),
  69     comp_unit   (rhs.comp_unit),
  70     function    (rhs.function),
  71     block       (rhs.block),
  72     line_entry  (rhs.line_entry),
  73     symbol      (rhs.symbol)
  74 {
  75 }
  76
  77
  78 SymbolContext::SymbolContext (SymbolContextScope *sc_scope) :
  79     target_sp   (),
  80     module_sp   (),
  81     comp_unit   (NULL),
  82     function    (NULL),
  83     block       (NULL),
  84     line_entry  (),
  85     symbol      (NULL)
  86 {
  87     sc_scope->CalculateSymbolContext (this);
  88 }
  89
  90 SymbolContext::~SymbolContext ()
  91 {
  92 }
  93
  94 const SymbolContext&
  95 SymbolContext::operator= (const SymbolContext& rhs)
  96 {
  97     if (this != &rhs)
  98     {
  99         target_sp   = rhs.target_sp;
 100         module_sp   = rhs.module_sp;
 101         comp_unit   = rhs.comp_unit;
 102         function    = rhs.function;
 103         block       = rhs.block;
 104         line_entry  = rhs.line_entry;
 105         symbol      = rhs.symbol;
 106     }
 107     return *this;
 108 }
 109
 110 void
 111 SymbolContext::Clear(bool clear_target)
 112 {
 113     if (clear_target)
 114         target_sp.reset();
 115     module_sp.reset();
 116     comp_unit   = NULL;
 117     function    = NULL;
 118     block       = NULL;
 119     line_entry.Clear();
 120     symbol      = NULL;
 121 }
 122
 123 bool
 124 SymbolContext::DumpStopContext
 125 (
 126     Stream *s,
 127     ExecutionContextScope *exe_scope,
 128     const Address &addr,
 129     bool show_fullpaths,
 130     bool show_module,
 131     bool show_inlined_frames
 132 ) const
 133 {
 134     bool dumped_something = false;
 135     if (show_module && module_sp)
 136     {
 137         if (show_fullpaths)
 138             *s << module_sp->GetFileSpec();
 139         else
 140             *s << module_sp->GetFileSpec().GetFilename();
 141         s->PutChar('`');
 142         dumped_something = true;
 143     }
 144
 145     if (function != NULL)
 146     {
 147         SymbolContext inline_parent_sc;
 148         Address inline_parent_addr;
 149         if (function->GetMangled().GetName())
 150         {
 151             dumped_something = true;
 152             function->GetMangled().GetName().Dump(s);
 153         }
 154
 155         if (addr.IsValid())
 156         {
 157             const addr_t function_offset = addr.GetOffset() - function->GetAddressRange().GetBaseAddress().GetOffset();
 158             if (function_offset)
 159             {
 160                 dumped_something = true;
 161                 s->Printf(" + %" PRIu64, function_offset);
 162             }
 163         }
 164
 165         if (GetParentOfInlinedScope (addr, inline_parent_sc, inline_parent_addr))
 166         {
 167             dumped_something = true;
 168             Block *inlined_block = block->GetContainingInlinedBlock();
 169             const InlineFunctionInfo* inlined_block_info = inlined_block->GetInlinedFunctionInfo();
 170             s->Printf (" [inlined] %s", inlined_block_info->GetName().GetCString());
 171
 172             lldb_private::AddressRange block_range;
 173             if (inlined_block->GetRangeContainingAddress(addr, block_range))
 174             {
 175                 const addr_t inlined_function_offset = addr.GetOffset() - block_range.GetBaseAddress().GetOffset();
 176                 if (inlined_function_offset)
 177                 {
 178                     s->Printf(" + %" PRIu64, inlined_function_offset);
 179                 }
 180             }
 181             const Declaration &call_site = inlined_block_info->GetCallSite();
 182             if (call_site.IsValid())
 183             {
 184                 s->PutCString(" at ");
 185                 call_site.DumpStopContext (s, show_fullpaths);
 186             }
 187             if (show_inlined_frames)
 188             {
 189                 s->EOL();
 190                 s->Indent();
 191                 return inline_parent_sc.DumpStopContext (s, exe_scope, inline_parent_addr, show_fullpaths, show_module, show_inlined_frames);
 192             }
 193         }
 194         else
 195         {
 196             if (line_entry.IsValid())
 197             {
 198                 dumped_something = true;
 199                 s->PutCString(" at ");
 200                 if (line_entry.DumpStopContext(s, show_fullpaths))
 201                     dumped_something = true;
 202             }
 203         }
 204     }
 205     else if (symbol != NULL)
 206     {
 207         if (symbol->GetMangled().GetName())
 208         {
 209             dumped_something = true;
 210             if (symbol->GetType() == eSymbolTypeTrampoline)
 211                 s->PutCString("symbol stub for: ");
 212             symbol->GetMangled().GetName().Dump(s);
 213         }
 214
 215         if (addr.IsValid() && symbol->ValueIsAddress())
 216         {
 217             const addr_t symbol_offset = addr.GetOffset() - symbol->GetAddress().GetOffset();
 218             if (symbol_offset)
 219             {
 220                 dumped_something = true;
 221                 s->Printf(" + %" PRIu64, symbol_offset);
 222             }
 223         }
 224     }
 225     else if (addr.IsValid())
 226     {
 227         addr.Dump(s, exe_scope, Address::DumpStyleModuleWithFileAddress);
 228         dumped_something = true;
 229     }
 230     return dumped_something;
 231 }
 232
 233 void
 234 SymbolContext::GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target) const
 235 {
 236     if (module_sp)
 237     {
 238         s->Indent("     Module: file = \"");
 239         module_sp->GetFileSpec().Dump(s);
 240         *s << '"';
 241         if (module_sp->GetArchitecture().IsValid())
 242             s->Printf (", arch = \"%s\"", module_sp->GetArchitecture().GetArchitectureName());
 243         s->EOL();
 244     }
 245
 246     if (comp_unit != NULL)
 247     {
 248         s->Indent("CompileUnit: ");
 249         comp_unit->GetDescription (s, level);
 250         s->EOL();
 251     }
 252
 253     if (function != NULL)
 254     {
 255         s->Indent("   Function: ");
 256         function->GetDescription (s, level, target);
 257         s->EOL();
 258
 259         Type *func_type = function->GetType();
 260         if (func_type)
 261         {
 262             s->Indent("   FuncType: ");
 263             func_type->GetDescription (s, level, false);
 264             s->EOL();
 265         }
 266     }
 267
 268     if (block != NULL)
 269     {
 270         std::vector<Block *> blocks;
 271         blocks.push_back (block);
 272         Block *parent_block = block->GetParent();
 273
 274         while (parent_block)
 275         {
 276             blocks.push_back (parent_block);
 277             parent_block = parent_block->GetParent();
 278         }
 279         std::vector<Block *>::reverse_iterator pos;
 280         std::vector<Block *>::reverse_iterator begin = blocks.rbegin();
 281         std::vector<Block *>::reverse_iterator end = blocks.rend();
 282         for (pos = begin; pos != end; ++pos)
 283         {
 284             if (pos == begin)
 285                 s->Indent("     Blocks: ");
 286             else
 287                 s->Indent("             ");
 288             (*pos)->GetDescription(s, function, level, target);
 289             s->EOL();
 290         }
 291     }
 292
 293     if (line_entry.IsValid())
 294     {
 295         s->Indent("  LineEntry: ");
 296         line_entry.GetDescription (s, level, comp_unit, target, false);
 297         s->EOL();
 298     }
 299
 300     if (symbol != NULL)
 301     {
 302         s->Indent("     Symbol: ");
 303         symbol->GetDescription(s, level, target);
 304         s->EOL();
 305     }
 306 }
 307
 308 uint32_t
 309 SymbolContext::GetResolvedMask () const
 310 {
 311     uint32_t resolved_mask = 0;
 312     if (target_sp)              resolved_mask |= eSymbolContextTarget;
 313     if (module_sp)              resolved_mask |= eSymbolContextModule;
 314     if (comp_unit)              resolved_mask |= eSymbolContextCompUnit;
 315     if (function)               resolved_mask |= eSymbolContextFunction;
 316     if (block)                  resolved_mask |= eSymbolContextBlock;
 317     if (line_entry.IsValid())   resolved_mask |= eSymbolContextLineEntry;
 318     if (symbol)                 resolved_mask |= eSymbolContextSymbol;
 319     return resolved_mask;
 320 }
 321
 322 void
 323 SymbolContext::Dump(Stream *s, Target *target) const
 324 {
 325     *s << (void *)this << ": ";
 326     s->Indent();
 327     s->PutCString("SymbolContext");
 328     s->IndentMore();
 329     s->EOL();
 330     s->IndentMore();
 331     s->Indent();
 332     *s << "Module       = " << (void *)module_sp.get() << ' ';
 333     if (module_sp)
 334         module_sp->GetFileSpec().Dump(s);
 335     s->EOL();
 336     s->Indent();
 337     *s << "CompileUnit  = " << (void *)comp_unit;
 338     if (comp_unit != NULL)
 339         *s << " {0x" << comp_unit->GetID() << "} " << *(static_cast<FileSpec*> (comp_unit));
 340     s->EOL();
 341     s->Indent();
 342     *s << "Function     = " << (void *)function;
 343     if (function != NULL)
 344     {
 345         *s << " {0x" << function->GetID() << "} " << function->GetType()->GetName() << ", address-range = ";
 346         function->GetAddressRange().Dump(s, target, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress);
 347         s->EOL();
 348         s->Indent();
 349         Type* func_type = function->GetType();
 350         if (func_type)
 351         {
 352             *s << "        Type = ";
 353             func_type->Dump (s, false);
 354         }
 355     }
 356     s->EOL();
 357     s->Indent();
 358     *s << "Block        = " << (void *)block;
 359     if (block != NULL)
 360         *s << " {0x" << block->GetID() << '}';
 361     // Dump the block and pass it a negative depth to we print all the parent blocks
 362     //if (block != NULL)
 363     //  block->Dump(s, function->GetFileAddress(), INT_MIN);
 364     s->EOL();
 365     s->Indent();
 366     *s << "LineEntry    = ";
 367     line_entry.Dump (s, target, true, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress, true);
 368     s->EOL();
 369     s->Indent();
 370     *s << "Symbol       = " << (void *)symbol;
 371     if (symbol != NULL && symbol->GetMangled())
 372         *s << ' ' << symbol->GetMangled().GetName().AsCString();
 373     s->EOL();
 374     s->IndentLess();
 375     s->IndentLess();
 376 }
 377
 378 bool
 379 lldb_private::operator== (const SymbolContext& lhs, const SymbolContext& rhs)
 380 {
 381     return  lhs.function == rhs.function
 382             && lhs.symbol == rhs.symbol
 383             && lhs.module_sp.get() == rhs.module_sp.get()
 384             && lhs.comp_unit == rhs.comp_unit
 385             && lhs.target_sp.get() == rhs.target_sp.get()
 386             && LineEntry::Compare(lhs.line_entry, rhs.line_entry) == 0;
 387 }
 388
 389 bool
 390 lldb_private::operator!= (const SymbolContext& lhs, const SymbolContext& rhs)
 391 {
 392     return  lhs.function != rhs.function
 393             || lhs.symbol != rhs.symbol
 394             || lhs.module_sp.get() != rhs.module_sp.get()
 395             || lhs.comp_unit != rhs.comp_unit
 396             || lhs.target_sp.get() != rhs.target_sp.get()
 397             || LineEntry::Compare(lhs.line_entry, rhs.line_entry) != 0;
 398 }
 399
 400 bool
 401 SymbolContext::GetAddressRange (uint32_t scope,
 402                                 uint32_t range_idx,
 403                                 bool use_inline_block_range,
 404                                 AddressRange &range) const
 405 {
 406     if ((scope & eSymbolContextLineEntry) && line_entry.IsValid())
 407     {
 408         range = line_entry.range;
 409         return true;
 410     }
 411
 412     if ((scope & eSymbolContextBlock) && (block != NULL))
 413     {
 414         if (use_inline_block_range)
 415         {
 416             Block *inline_block = block->GetContainingInlinedBlock();
 417             if (inline_block)
 418                 return inline_block->GetRangeAtIndex (range_idx, range);
 419         }
 420         else
 421         {
 422             return block->GetRangeAtIndex (range_idx, range);
 423         }
 424     }
 425
 426     if ((scope & eSymbolContextFunction) && (function != NULL))
 427     {
 428         if (range_idx == 0)
 429         {
 430             range = function->GetAddressRange();
 431             return true;
 432         }
 433     }
 434
 435     if ((scope & eSymbolContextSymbol) && (symbol != NULL))
 436     {
 437         if (range_idx == 0)
 438         {
 439             if (symbol->ValueIsAddress())
 440             {
 441                 range.GetBaseAddress() = symbol->GetAddress();
 442                 range.SetByteSize (symbol->GetByteSize());
 443                 return true;
 444             }
 445         }
 446     }
 447     range.Clear();
 448     return false;
 449 }
 450
 451 bool
 452 SymbolContext::GetParentOfInlinedScope (const Address &curr_frame_pc,
 453                                         SymbolContext &next_frame_sc,
 454                                         Address &next_frame_pc) const
 455 {
 456     next_frame_sc.Clear(false);
 457     next_frame_pc.Clear();
 458
 459     if (block)
 460     {
 461         //const addr_t curr_frame_file_addr = curr_frame_pc.GetFileAddress();
 462
 463         // In order to get the parent of an inlined function we first need to
 464         // see if we are in an inlined block as "this->block" could be an
 465         // inlined block, or a parent of "block" could be. So lets check if
 466         // this block or one of this blocks parents is an inlined function.
 467         Block *curr_inlined_block = block->GetContainingInlinedBlock();
 468         if (curr_inlined_block)
 469         {
 470             // "this->block" is contained in an inline function block, so to
 471             // get the scope above the inlined block, we get the parent of the
 472             // inlined block itself
 473             Block *next_frame_block = curr_inlined_block->GetParent();
 474             // Now calculate the symbol context of the containing block
 475             next_frame_block->CalculateSymbolContext (&next_frame_sc);
 476
 477             // If we get here we weren't able to find the return line entry using the nesting of the blocks and
 478             // the line table.  So just use the call site info from our inlined block.
 479
 480             AddressRange range;
 481             if (curr_inlined_block->GetRangeContainingAddress (curr_frame_pc, range))
 482             {
 483                 // To see there this new frame block it, we need to look at the
 484                 // call site information from
 485                 const InlineFunctionInfo* curr_inlined_block_inlined_info = curr_inlined_block->GetInlinedFunctionInfo();
 486                 next_frame_pc = range.GetBaseAddress();
 487                 next_frame_sc.line_entry.range.GetBaseAddress() = next_frame_pc;
 488                 next_frame_sc.line_entry.file = curr_inlined_block_inlined_info->GetCallSite().GetFile();
 489                 next_frame_sc.line_entry.line = curr_inlined_block_inlined_info->GetCallSite().GetLine();
 490                 next_frame_sc.line_entry.column = curr_inlined_block_inlined_info->GetCallSite().GetColumn();
 491                 return true;
 492             }
 493             else
 494             {
 495                 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS));
 496
 497                 if (log)
 498                 {
 499                     log->Printf ("warning: inlined block 0x%8.8" PRIx64 " doesn't have a range that contains file address 0x%" PRIx64,
 500                                  curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress());
 501                 }
 502 #ifdef LLDB_CONFIGURATION_DEBUG
 503                 else
 504                 {
 505                     ObjectFile *objfile = NULL;
 506                     if (module_sp)
 507                     {
 508                         SymbolVendor *symbol_vendor = module_sp->GetSymbolVendor();
 509                         if (symbol_vendor)
 510                         {
 511                             SymbolFile *symbol_file = symbol_vendor->GetSymbolFile();
 512                             if (symbol_file)
 513                                 objfile = symbol_file->GetObjectFile();
 514                         }
 515                     }
 516                     if (objfile)
 517                     {
 518                         Host::SystemLog (Host::eSystemLogWarning,
 519                                          "warning: inlined block 0x%8.8" PRIx64 " doesn't have a range that contains file address 0x%" PRIx64 " in %s\n",
 520                                          curr_inlined_block->GetID(),
 521                                          curr_frame_pc.GetFileAddress(),
 522                                          objfile->GetFileSpec().GetPath().c_str());
 523                     }
 524                     else
 525                     {
 526                         Host::SystemLog (Host::eSystemLogWarning,
 527                                          "warning: inlined block 0x%8.8" PRIx64 " doesn't have a range that contains file address 0x%" PRIx64 "\n",
 528                                          curr_inlined_block->GetID(),
 529                                          curr_frame_pc.GetFileAddress());
 530                     }
 531                 }
 532 #endif
 533             }
 534         }
 535     }
 536
 537     return false;
 538 }
 539
 540 Block *
 541 SymbolContext::GetFunctionBlock ()
 542 {
 543     if (function)
 544     {
 545         if (block)
 546         {
 547             // If this symbol context has a block, check to see if this block
 548             // is itself, or is contained within a block with inlined function
 549             // information. If so, then the inlined block is the block that
 550             // defines the function.
 551             Block *inlined_block = block->GetContainingInlinedBlock();
 552             if (inlined_block)
 553                 return inlined_block;
 554
 555             // The block in this symbol context is not inside an inlined
 556             // block, so the block that defines the function is the function's
 557             // top level block, which is returned below.
 558         }
 559
 560         // There is no block information in this symbol context, so we must
 561         // assume that the block that is desired is the top level block of
 562         // the function itself.
 563         return &function->GetBlock(true);
 564     }
 565     return NULL;
 566 }
 567
 568 bool
 569 SymbolContext::GetFunctionMethodInfo (lldb::LanguageType &language,
 570                                       bool &is_instance_method,
 571                                       ConstString &language_object_name)
 572
 573
 574 {
 575     Block *function_block = GetFunctionBlock ();
 576     if (function_block)
 577     {
 578         clang::DeclContext *decl_context = function_block->GetClangDeclContext();
 579
 580         if (decl_context)
 581         {
 582             return ClangASTContext::GetClassMethodInfoForDeclContext (decl_context,
 583                                                                       language,
 584                                                                       is_instance_method,
 585                                                                       language_object_name);
 586         }
 587     }
 588     language = eLanguageTypeUnknown;
 589     is_instance_method = false;
 590     language_object_name.Clear();
 591     return false;
 592 }
 593
 594 ConstString
 595 SymbolContext::GetFunctionName (Mangled::NamePreference preference) const
 596 {
 597     if (function)
 598     {
 599         if (block)
 600         {
 601             Block *inlined_block = block->GetContainingInlinedBlock();
 602
 603             if (inlined_block)
 604             {
 605                 const InlineFunctionInfo *inline_info = inlined_block->GetInlinedFunctionInfo();
 606                 if (inline_info)
 607                     return inline_info->GetName();
 608             }
 609         }
 610         return function->GetMangled().GetName(preference);
 611     }
 612     else if (symbol && symbol->ValueIsAddress())
 613     {
 614         return symbol->GetMangled().GetName(preference);
 615     }
 616     else
 617     {
 618         // No function, return an empty string.
 619         return ConstString();
 620     }
 621 }
 622
 623 LineEntry
 624 SymbolContext::GetFunctionStartLineEntry () const
 625 {
 626     LineEntry line_entry;
 627     Address start_addr;
 628     if (block)
 629     {
 630         Block *inlined_block = block->GetContainingInlinedBlock();
 631         if (inlined_block)
 632         {
 633             if (inlined_block->GetStartAddress (start_addr))
 634             {
 635                 if (start_addr.CalculateSymbolContextLineEntry (line_entry))
 636                     return line_entry;
 637             }
 638             return LineEntry();
 639         }
 640     }
 641
 642     if (function)
 643     {
 644         if (function->GetAddressRange().GetBaseAddress().CalculateSymbolContextLineEntry(line_entry))
 645             return line_entry;
 646     }
 647     return LineEntry();
 648 }
 649
 650 //----------------------------------------------------------------------
 651 //
 652 //  SymbolContextSpecifier
 653 //
 654 //----------------------------------------------------------------------
 655
 656 SymbolContextSpecifier::SymbolContextSpecifier (const TargetSP &target_sp) :
 657     m_target_sp (target_sp),
 658     m_module_spec (),
 659     m_module_sp (),
 660     m_file_spec_ap (),
 661     m_start_line (0),
 662     m_end_line (0),
 663     m_function_spec (),
 664     m_class_name (),
 665     m_address_range_ap (),
 666     m_type (eNothingSpecified)
 667 {
 668 }
 669
 670 SymbolContextSpecifier::~SymbolContextSpecifier()
 671 {
 672 }
 673
 674 bool
 675 SymbolContextSpecifier::AddLineSpecification (uint32_t line_no, SpecificationType type)
 676 {
 677     bool return_value = true;
 678     switch (type)
 679     {
 680     case eNothingSpecified:
 681         Clear();
 682         break;
 683     case eLineStartSpecified:
 684         m_start_line = line_no;
 685         m_type |= eLineStartSpecified;
 686         break;
 687     case eLineEndSpecified:
 688         m_end_line = line_no;
 689         m_type |= eLineEndSpecified;
 690         break;
 691     default:
 692         return_value = false;
 693         break;
 694     }
 695     return return_value;
 696 }
 697
 698 bool
 699 SymbolContextSpecifier::AddSpecification (const char *spec_string, SpecificationType type)
 700 {
 701     bool return_value = true;
 702     switch (type)
 703     {
 704     case eNothingSpecified:
 705         Clear();
 706         break;
 707     case eModuleSpecified:
 708         {
 709             // See if we can find the Module, if so stick it in the SymbolContext.
 710             FileSpec module_file_spec(spec_string, false);
 711             ModuleSpec module_spec (module_file_spec);
 712             lldb::ModuleSP module_sp (m_target_sp->GetImages().FindFirstModule (module_spec));
 713             m_type |= eModuleSpecified;
 714             if (module_sp)
 715                 m_module_sp = module_sp;
 716             else
 717                 m_module_spec.assign (spec_string);
 718         }
 719         break;
 720     case eFileSpecified:
 721         // CompUnits can't necessarily be resolved here, since an inlined function might show up in
 722         // a number of CompUnits.  Instead we just convert to a FileSpec and store it away.
 723         m_file_spec_ap.reset (new FileSpec (spec_string, false));
 724         m_type |= eFileSpecified;
 725         break;
 726     case eLineStartSpecified:
 727         m_start_line = Args::StringToSInt32(spec_string, 0, 0, &return_value);
 728         if (return_value)
 729             m_type |= eLineStartSpecified;
 730         break;
 731     case eLineEndSpecified:
 732         m_end_line = Args::StringToSInt32(spec_string, 0, 0, &return_value);
 733         if (return_value)
 734             m_type |= eLineEndSpecified;
 735         break;
 736     case eFunctionSpecified:
 737         m_function_spec.assign(spec_string);
 738         m_type |= eFunctionSpecified;
 739         break;
 740     case eClassOrNamespaceSpecified:
 741         Clear();
 742         m_class_name.assign (spec_string);
 743         m_type = eClassOrNamespaceSpecified;
 744         break;
 745     case eAddressRangeSpecified:
 746         // Not specified yet...
 747         break;
 748     }
 749
 750     return return_value;
 751 }
 752
 753 void
 754 SymbolContextSpecifier::Clear()
 755 {
 756     m_module_spec.clear();
 757     m_file_spec_ap.reset();
 758     m_function_spec.clear();
 759     m_class_name.clear();
 760     m_start_line = 0;
 761     m_end_line = 0;
 762     m_address_range_ap.reset();
 763
 764     m_type = eNothingSpecified;
 765 }
 766
 767 bool
 768 SymbolContextSpecifier::SymbolContextMatches(SymbolContext &sc)
 769 {
 770     if (m_type == eNothingSpecified)
 771         return true;
 772
 773     if (m_target_sp.get() != sc.target_sp.get())
 774         return false;
 775
 776     if (m_type & eModuleSpecified)
 777     {
 778         if (sc.module_sp)
 779         {
 780             if (m_module_sp.get() != NULL)
 781             {
 782                 if (m_module_sp.get() != sc.module_sp.get())
 783                     return false;
 784             }
 785             else
 786             {
 787                 FileSpec module_file_spec (m_module_spec.c_str(), false);
 788                 if (!FileSpec::Equal (module_file_spec, sc.module_sp->GetFileSpec(), false))
 789                     return false;
 790             }
 791         }
 792     }
 793     if (m_type & eFileSpecified)
 794     {
 795         if (m_file_spec_ap.get())
 796         {
 797             // If we don't have a block or a comp_unit, then we aren't going to match a source file.
 798             if (sc.block == NULL && sc.comp_unit == NULL)
 799                 return false;
 800
 801             // Check if the block is present, and if so is it inlined:
 802             bool was_inlined = false;
 803             if (sc.block != NULL)
 804             {
 805                 const InlineFunctionInfo *inline_info = sc.block->GetInlinedFunctionInfo();
 806                 if (inline_info != NULL)
 807                 {
 808                     was_inlined = true;
 809                     if (!FileSpec::Equal (inline_info->GetDeclaration().GetFile(), *(m_file_spec_ap.get()), false))
 810                         return false;
 811                 }
 812             }
 813
 814             // Next check the comp unit, but only if the SymbolContext was not inlined.
 815             if (!was_inlined && sc.comp_unit != NULL)
 816             {
 817                 if (!FileSpec::Equal (*(sc.comp_unit), *(m_file_spec_ap.get()), false))
 818                     return false;
 819             }
 820         }
 821     }
 822     if (m_type & eLineStartSpecified
 823         || m_type & eLineEndSpecified)
 824     {
 825         if (sc.line_entry.line < m_start_line || sc.line_entry.line > m_end_line)
 826             return false;
 827     }
 828
 829     if (m_type & eFunctionSpecified)
 830     {
 831         // First check the current block, and if it is inlined, get the inlined function name:
 832         bool was_inlined = false;
 833         ConstString func_name(m_function_spec.c_str());
 834
 835         if (sc.block != NULL)
 836         {
 837             const InlineFunctionInfo *inline_info = sc.block->GetInlinedFunctionInfo();
 838             if (inline_info != NULL)
 839             {
 840                 was_inlined = true;
 841                 const Mangled &name = inline_info->GetMangled();
 842                 if (!name.NameMatches (func_name))
 843                     return false;
 844             }
 845         }
 846         //  If it wasn't inlined, check the name in the function or symbol:
 847         if (!was_inlined)
 848         {
 849             if (sc.function != NULL)
 850             {
 851                 if (!sc.function->GetMangled().NameMatches(func_name))
 852                     return false;
 853             }
 854             else if (sc.symbol != NULL)
 855             {
 856                 if (!sc.symbol->GetMangled().NameMatches(func_name))
 857                     return false;
 858             }
 859         }
 860
 861
 862     }
 863
 864     return true;
 865 }
 866
 867 bool
 868 SymbolContextSpecifier::AddressMatches(lldb::addr_t addr)
 869 {
 870     if (m_type & eAddressRangeSpecified)
 871     {
 872
 873     }
 874     else
 875     {
 876         Address match_address (addr, NULL);
 877         SymbolContext sc;
 878         m_target_sp->GetImages().ResolveSymbolContextForAddress(match_address, eSymbolContextEverything, sc);
 879         return SymbolContextMatches(sc);
 880     }
 881     return true;
 882 }
 883
 884 void
 885 SymbolContextSpecifier::GetDescription (Stream *s, lldb::DescriptionLevel level) const
 886 {
 887     char path_str[PATH_MAX + 1];
 888
 889     if (m_type == eNothingSpecified)
 890     {
 891         s->Printf ("Nothing specified.\n");
 892     }
 893
 894     if (m_type == eModuleSpecified)
 895     {
 896         s->Indent();
 897         if (m_module_sp)
 898         {
 899             m_module_sp->GetFileSpec().GetPath (path_str, PATH_MAX);
 900             s->Printf ("Module: %s\n", path_str);
 901         }
 902         else
 903             s->Printf ("Module: %s\n", m_module_spec.c_str());
 904     }
 905
 906     if (m_type == eFileSpecified  && m_file_spec_ap.get() != NULL)
 907     {
 908         m_file_spec_ap->GetPath (path_str, PATH_MAX);
 909         s->Indent();
 910         s->Printf ("File: %s", path_str);
 911         if (m_type == eLineStartSpecified)
 912         {
 913             s->Printf (" from line %zu", m_start_line);
 914             if (m_type == eLineEndSpecified)
 915                 s->Printf ("to line %zu", m_end_line);
 916             else
 917                 s->Printf ("to end");
 918         }
 919         else if (m_type == eLineEndSpecified)
 920         {
 921             s->Printf (" from start to line %zu", m_end_line);
 922         }
 923         s->Printf (".\n");
 924     }
 925
 926     if (m_type == eLineStartSpecified)
 927     {
 928         s->Indent();
 929         s->Printf ("From line %zu", m_start_line);
 930         if (m_type == eLineEndSpecified)
 931             s->Printf ("to line %zu", m_end_line);
 932         else
 933             s->Printf ("to end");
 934         s->Printf (".\n");
 935     }
 936     else if (m_type == eLineEndSpecified)
 937     {
 938         s->Printf ("From start to line %zu.\n", m_end_line);
 939     }
 940
 941     if (m_type == eFunctionSpecified)
 942     {
 943         s->Indent();
 944         s->Printf ("Function: %s.\n", m_function_spec.c_str());
 945     }
 946
 947     if (m_type == eClassOrNamespaceSpecified)
 948     {
 949         s->Indent();
 950         s->Printf ("Class name: %s.\n", m_class_name.c_str());
 951     }
 952
 953     if (m_type == eAddressRangeSpecified && m_address_range_ap.get() != NULL)
 954     {
 955         s->Indent();
 956         s->PutCString ("Address range: ");
 957         m_address_range_ap->Dump (s, m_target_sp.get(), Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress);
 958         s->PutCString ("\n");
 959     }
 960 }
 961
 962 //----------------------------------------------------------------------
 963 //
 964 //  SymbolContextList
 965 //
 966 //----------------------------------------------------------------------
 967
 968
 969 SymbolContextList::SymbolContextList() :
 970     m_symbol_contexts()
 971 {
 972 }
 973
 974 SymbolContextList::~SymbolContextList()
 975 {
 976 }
 977
 978 void
 979 SymbolContextList::Append(const SymbolContext& sc)
 980 {
 981     m_symbol_contexts.push_back(sc);
 982 }
 983
 984 void
 985 SymbolContextList::Append (const SymbolContextList& sc_list)
 986 {
 987     collection::const_iterator pos, end = sc_list.m_symbol_contexts.end();
 988     for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos)
 989         m_symbol_contexts.push_back (*pos);
 990 }
 991
 992
 993 uint32_t
 994 SymbolContextList::AppendIfUnique (const SymbolContextList& sc_list, bool merge_symbol_into_function)
 995 {
 996     uint32_t unique_sc_add_count = 0;
 997     collection::const_iterator pos, end = sc_list.m_symbol_contexts.end();
 998     for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos)
 999     {
1000         if (AppendIfUnique (*pos, merge_symbol_into_function))
1001             ++unique_sc_add_count;
1002     }
1003     return unique_sc_add_count;
1004 }
1005
1006 bool
1007 SymbolContextList::AppendIfUnique (const SymbolContext& sc, bool merge_symbol_into_function)
1008 {
1009     collection::iterator pos, end = m_symbol_contexts.end();
1010     for (pos = m_symbol_contexts.begin(); pos != end; ++pos)
1011     {
1012         if (*pos == sc)
1013             return false;
1014     }
1015     if (merge_symbol_into_function
1016         && sc.symbol    != NULL
1017         && sc.comp_unit == NULL
1018         && sc.function  == NULL
1019         && sc.block     == NULL
1020         && sc.line_entry.IsValid() == false)
1021     {
1022         if (sc.symbol->ValueIsAddress())
1023         {
1024             for (pos = m_symbol_contexts.begin(); pos != end; ++pos)
1025             {
1026                 // Don't merge symbols into inlined function symbol contexts
1027                 if (pos->block && pos->block->GetContainingInlinedBlock())
1028                     continue;
1029
1030                 if (pos->function)
1031                 {
1032                     if (pos->function->GetAddressRange().GetBaseAddress() == sc.symbol->GetAddress())
1033                     {
1034                         // Do we already have a function with this symbol?
1035                         if (pos->symbol == sc.symbol)
1036                             return false;
1037                         if (pos->symbol == NULL)
1038                         {
1039                             pos->symbol = sc.symbol;
1040                             return false;
1041                         }
1042                     }
1043                 }
1044             }
1045         }
1046     }
1047     m_symbol_contexts.push_back(sc);
1048     return true;
1049 }
1050
1051 bool
1052 SymbolContextList::MergeSymbolContextIntoFunctionContext (const SymbolContext& symbol_sc,
1053                                                           uint32_t start_idx,
1054                                                           uint32_t stop_idx)
1055 {
1056     if (symbol_sc.symbol    != NULL
1057         && symbol_sc.comp_unit == NULL
1058         && symbol_sc.function  == NULL
1059         && symbol_sc.block     == NULL
1060         && symbol_sc.line_entry.IsValid() == false)
1061     {
1062         if (symbol_sc.symbol->ValueIsAddress())
1063         {
1064             const size_t end = std::min<size_t>(m_symbol_contexts.size(), stop_idx);
1065             for (size_t i=start_idx; i<end; ++i)
1066             {
1067                 const SymbolContext &function_sc = m_symbol_contexts[i];
1068                 // Don't merge symbols into inlined function symbol contexts
1069                 if (function_sc.block && function_sc.block->GetContainingInlinedBlock())
1070                     continue;
1071
1072                 if (function_sc.function)
1073                 {
1074                     if (function_sc.function->GetAddressRange().GetBaseAddress() == symbol_sc.symbol->GetAddress())
1075                     {
1076                         // Do we already have a function with this symbol?
1077                         if (function_sc.symbol == symbol_sc.symbol)
1078                             return true; // Already have a symbol context with this symbol, return true
1079
1080                         if (function_sc.symbol == NULL)
1081                         {
1082                             // We successfully merged this symbol into an existing symbol context
1083                             m_symbol_contexts[i].symbol = symbol_sc.symbol;
1084                             return true;
1085                         }
1086                     }
1087                 }
1088             }
1089         }
1090     }
1091     return false;
1092 }
1093
1094 void
1095 SymbolContextList::Clear()
1096 {
1097     m_symbol_contexts.clear();
1098 }
1099
1100 void
1101 SymbolContextList::Dump(Stream *s, Target *target) const
1102 {
1103
1104     *s << (void *)this << ": ";
1105     s->Indent();
1106     s->PutCString("SymbolContextList");
1107     s->EOL();
1108     s->IndentMore();
1109
1110     collection::const_iterator pos, end = m_symbol_contexts.end();
1111     for (pos = m_symbol_contexts.begin(); pos != end; ++pos)
1112     {
1113         //pos->Dump(s, target);
1114         pos->GetDescription(s, eDescriptionLevelVerbose, target);
1115     }
1116     s->IndentLess();
1117 }
1118
1119 bool
1120 SymbolContextList::GetContextAtIndex(size_t idx, SymbolContext& sc) const
1121 {
1122     if (idx < m_symbol_contexts.size())
1123     {
1124         sc = m_symbol_contexts[idx];
1125         return true;
1126     }
1127     return false;
1128 }
1129
1130 bool
1131 SymbolContextList::GetLastContext(SymbolContext& sc) const
1132 {
1133     if (!m_symbol_contexts.empty())
1134     {
1135         sc = m_symbol_contexts.back();
1136         return true;
1137     }
1138     return false;
1139 }
1140
1141 bool
1142 SymbolContextList::RemoveContextAtIndex (size_t idx)
1143 {
1144     if (idx < m_symbol_contexts.size())
1145     {
1146         m_symbol_contexts.erase(m_symbol_contexts.begin() + idx);
1147         return true;
1148     }
1149     return false;
1150 }
1151
1152 uint32_t
1153 SymbolContextList::GetSize() const
1154 {
1155     return m_symbol_contexts.size();
1156 }
1157
1158 uint32_t
1159 SymbolContextList::NumLineEntriesWithLine (uint32_t line) const
1160 {
1161     uint32_t match_count = 0;
1162     const size_t size = m_symbol_contexts.size();
1163     for (size_t idx = 0; idx<size; ++idx)
1164     {
1165         if (m_symbol_contexts[idx].line_entry.line == line)
1166             ++match_count;
1167     }
1168     return match_count;
1169 }
1170
1171 void
1172 SymbolContextList::GetDescription(Stream *s,
1173                                   lldb::DescriptionLevel level,
1174                                   Target *target) const
1175 {
1176     const size_t size = m_symbol_contexts.size();
1177     for (size_t idx = 0; idx<size; ++idx)
1178         m_symbol_contexts[idx].GetDescription (s, level, target);
1179 }
1180
1181 bool
1182 lldb_private::operator== (const SymbolContextList& lhs, const SymbolContextList& rhs)
1183 {
1184     const uint32_t size = lhs.GetSize();
1185     if (size != rhs.GetSize())
1186         return false;
1187
1188     SymbolContext lhs_sc;
1189     SymbolContext rhs_sc;
1190     for (uint32_t i=0; i<size; ++i)
1191     {
1192         lhs.GetContextAtIndex(i, lhs_sc);
1193         rhs.GetContextAtIndex(i, rhs_sc);
1194         if (lhs_sc != rhs_sc)
1195             return false;
1196     }
1197     return true;
1198 }
1199
1200 bool
1201 lldb_private::operator!= (const SymbolContextList& lhs, const SymbolContextList& rhs)
1202 {
1203     return !(lhs == rhs);
1204 }
1205