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