lldb/source/Symbol/SymbolContext.cpp

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