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