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 == false) {
 109       s->Printf("<");
 110       dumped_something = true;
 111     } else {
 112       ConstString name;
 113       if (show_function_arguments == false)
 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 == false) {
 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 == false) {
 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 == false) {
 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
 363   // if (block != NULL)
 364   //  block->Dump(s, function->GetFileAddress(), INT_MIN);
 365   s->EOL();
 366   s->Indent();
 367   *s << "LineEntry    = ";
 368   line_entry.Dump(s, target, true, Address::DumpStyleLoadAddress,
 369                   Address::DumpStyleModuleWithFileAddress, true);
 370   s->EOL();
 371   s->Indent();
 372   *s << "Symbol       = " << symbol;
 373   if (symbol != nullptr && symbol->GetMangled())
 374     *s << ' ' << symbol->GetName().AsCString();
 375   s->EOL();
 376   *s << "Variable     = " << variable;
 377   if (variable != nullptr) {
 378     *s << " {0x" << variable->GetID() << "} " << variable->GetType()->GetName();
 379     s->EOL();
 380   }
 381   s->IndentLess();
 382   s->IndentLess();
 383 }
 384
 385 bool lldb_private::operator==(const SymbolContext &lhs,
 386                               const SymbolContext &rhs) {
 387   return lhs.function == rhs.function && lhs.symbol == rhs.symbol &&
 388          lhs.module_sp.get() == rhs.module_sp.get() &&
 389          lhs.comp_unit == rhs.comp_unit &&
 390          lhs.target_sp.get() == rhs.target_sp.get() &&
 391          LineEntry::Compare(lhs.line_entry, rhs.line_entry) == 0 &&
 392          lhs.variable == rhs.variable;
 393 }
 394
 395 bool lldb_private::operator!=(const SymbolContext &lhs,
 396                               const SymbolContext &rhs) {
 397   return lhs.function != rhs.function || lhs.symbol != rhs.symbol ||
 398          lhs.module_sp.get() != rhs.module_sp.get() ||
 399          lhs.comp_unit != rhs.comp_unit ||
 400          lhs.target_sp.get() != rhs.target_sp.get() ||
 401          LineEntry::Compare(lhs.line_entry, rhs.line_entry) != 0 ||
 402          lhs.variable != rhs.variable;
 403 }
 404
 405 bool SymbolContext::GetAddressRange(uint32_t scope, uint32_t range_idx,
 406                                     bool use_inline_block_range,
 407                                     AddressRange &range) const {
 408   if ((scope & eSymbolContextLineEntry) && line_entry.IsValid()) {
 409     range = line_entry.range;
 410     return true;
 411   }
 412
 413   if ((scope & eSymbolContextBlock) && (block != nullptr)) {
 414     if (use_inline_block_range) {
 415       Block *inline_block = block->GetContainingInlinedBlock();
 416       if (inline_block)
 417         return inline_block->GetRangeAtIndex(range_idx, range);
 418     } else {
 419       return block->GetRangeAtIndex(range_idx, range);
 420     }
 421   }
 422
 423   if ((scope & eSymbolContextFunction) && (function != nullptr)) {
 424     if (range_idx == 0) {
 425       range = function->GetAddressRange();
 426       return true;
 427     }
 428   }
 429
 430   if ((scope & eSymbolContextSymbol) && (symbol != nullptr)) {
 431     if (range_idx == 0) {
 432       if (symbol->ValueIsAddress()) {
 433         range.GetBaseAddress() = symbol->GetAddressRef();
 434         range.SetByteSize(symbol->GetByteSize());
 435         return true;
 436       }
 437     }
 438   }
 439   range.Clear();
 440   return false;
 441 }
 442
 443 LanguageType SymbolContext::GetLanguage() const {
 444   LanguageType lang;
 445   if (function && (lang = function->GetLanguage()) != eLanguageTypeUnknown) {
 446     return lang;
 447   } else if (variable &&
 448              (lang = variable->GetLanguage()) != eLanguageTypeUnknown) {
 449     return lang;
 450   } else if (symbol && (lang = symbol->GetLanguage()) != eLanguageTypeUnknown) {
 451     return lang;
 452   } else if (comp_unit &&
 453              (lang = comp_unit->GetLanguage()) != eLanguageTypeUnknown) {
 454     return lang;
 455   } else if (symbol) {
 456     // If all else fails, try to guess the language from the name.
 457     return symbol->GetMangled().GuessLanguage();
 458   }
 459   return eLanguageTypeUnknown;
 460 }
 461
 462 bool SymbolContext::GetParentOfInlinedScope(const Address &curr_frame_pc,
 463                                             SymbolContext &next_frame_sc,
 464                                             Address &next_frame_pc) const {
 465   next_frame_sc.Clear(false);
 466   next_frame_pc.Clear();
 467
 468   if (block) {
 469     // const addr_t curr_frame_file_addr = curr_frame_pc.GetFileAddress();
 470
 471     // In order to get the parent of an inlined function we first need to
 472     // see if we are in an inlined block as "this->block" could be an
 473     // inlined block, or a parent of "block" could be. So lets check if
 474     // this block or one of this blocks parents is an inlined function.
 475     Block *curr_inlined_block = block->GetContainingInlinedBlock();
 476     if (curr_inlined_block) {
 477       // "this->block" is contained in an inline function block, so to
 478       // get the scope above the inlined block, we get the parent of the
 479       // inlined block itself
 480       Block *next_frame_block = curr_inlined_block->GetParent();
 481       // Now calculate the symbol context of the containing block
 482       next_frame_block->CalculateSymbolContext(&next_frame_sc);
 483
 484       // If we get here we weren't able to find the return line entry using the
 485       // nesting of the blocks and
 486       // the line table.  So just use the call site info from our inlined block.
 487
 488       AddressRange range;
 489       if (curr_inlined_block->GetRangeContainingAddress(curr_frame_pc, range)) {
 490         // To see there this new frame block it, we need to look at the
 491         // call site information from
 492         const InlineFunctionInfo *curr_inlined_block_inlined_info =
 493             curr_inlined_block->GetInlinedFunctionInfo();
 494         next_frame_pc = range.GetBaseAddress();
 495         next_frame_sc.line_entry.range.GetBaseAddress() = next_frame_pc;
 496         next_frame_sc.line_entry.file =
 497             curr_inlined_block_inlined_info->GetCallSite().GetFile();
 498         next_frame_sc.line_entry.original_file =
 499             curr_inlined_block_inlined_info->GetCallSite().GetFile();
 500         next_frame_sc.line_entry.line =
 501             curr_inlined_block_inlined_info->GetCallSite().GetLine();
 502         next_frame_sc.line_entry.column =
 503             curr_inlined_block_inlined_info->GetCallSite().GetColumn();
 504         return true;
 505       } else {
 506         Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS));
 507
 508         if (log) {
 509           log->Printf(
 510               "warning: inlined block 0x%8.8" PRIx64
 511               " doesn't have a range that contains file address 0x%" PRIx64,
 512               curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress());
 513         }
 514 #ifdef LLDB_CONFIGURATION_DEBUG
 515         else {
 516           ObjectFile *objfile = NULL;
 517           if (module_sp) {
 518             SymbolVendor *symbol_vendor = module_sp->GetSymbolVendor();
 519             if (symbol_vendor) {
 520               SymbolFile *symbol_file = symbol_vendor->GetSymbolFile();
 521               if (symbol_file)
 522                 objfile = symbol_file->GetObjectFile();
 523             }
 524           }
 525           if (objfile) {
 526             Host::SystemLog(
 527                 Host::eSystemLogWarning,
 528                 "warning: inlined block 0x%8.8" PRIx64
 529                 " doesn't have a range that contains file address 0x%" PRIx64
 530                 " in %s\n",
 531                 curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress(),
 532                 objfile->GetFileSpec().GetPath().c_str());
 533           } else {
 534             Host::SystemLog(
 535                 Host::eSystemLogWarning,
 536                 "warning: inlined block 0x%8.8" PRIx64
 537                 " doesn't have a range that contains file address 0x%" PRIx64
 538                 "\n",
 539                 curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress());
 540           }
 541         }
 542 #endif
 543       }
 544     }
 545   }
 546
 547   return false;
 548 }
 549
 550 Block *SymbolContext::GetFunctionBlock() {
 551   if (function) {
 552     if (block) {
 553       // If this symbol context has a block, check to see if this block
 554       // is itself, or is contained within a block with inlined function
 555       // information. If so, then the inlined block is the block that
 556       // defines the function.
 557       Block *inlined_block = block->GetContainingInlinedBlock();
 558       if (inlined_block)
 559         return inlined_block;
 560
 561       // The block in this symbol context is not inside an inlined
 562       // block, so the block that defines the function is the function's
 563       // top level block, which is returned below.
 564     }
 565
 566     // There is no block information in this symbol context, so we must
 567     // assume that the block that is desired is the top level block of
 568     // the function itself.
 569     return &function->GetBlock(true);
 570   }
 571   return nullptr;
 572 }
 573
 574 bool SymbolContext::GetFunctionMethodInfo(lldb::LanguageType &language,
 575                                           bool &is_instance_method,
 576                                           ConstString &language_object_name)
 577
 578 {
 579   Block *function_block = GetFunctionBlock();
 580   if (function_block) {
 581     CompilerDeclContext decl_ctx = function_block->GetDeclContext();
 582     if (decl_ctx)
 583       return decl_ctx.IsClassMethod(&language, &is_instance_method,
 584                                     &language_object_name);
 585   }
 586   return false;
 587 }
 588
 589 void SymbolContext::SortTypeList(TypeMap &type_map, TypeList &type_list) const {
 590   Block *curr_block = block;
 591   bool isInlinedblock = false;
 592   if (curr_block != nullptr &&
 593       curr_block->GetContainingInlinedBlock() != nullptr)
 594     isInlinedblock = true;
 595
 596   //----------------------------------------------------------------------
 597   // Find all types that match the current block if we have one and put
 598   // them first in the list. Keep iterating up through all blocks.
 599   //----------------------------------------------------------------------
 600   while (curr_block != nullptr && !isInlinedblock) {
 601     type_map.ForEach(
 602         [curr_block, &type_list](const lldb::TypeSP &type_sp) -> bool {
 603           SymbolContextScope *scs = type_sp->GetSymbolContextScope();
 604           if (scs && curr_block == scs->CalculateSymbolContextBlock())
 605             type_list.Insert(type_sp);
 606           return true; // Keep iterating
 607         });
 608
 609     // Remove any entries that are now in "type_list" from "type_map"
 610     // since we can't remove from type_map while iterating
 611     type_list.ForEach([&type_map](const lldb::TypeSP &type_sp) -> bool {
 612       type_map.Remove(type_sp);
 613       return true; // Keep iterating
 614     });
 615     curr_block = curr_block->GetParent();
 616   }
 617   //----------------------------------------------------------------------
 618   // Find all types that match the current function, if we have onem, and
 619   // put them next in the list.
 620   //----------------------------------------------------------------------
 621   if (function != nullptr && !type_map.Empty()) {
 622     const size_t old_type_list_size = type_list.GetSize();
 623     type_map.ForEach([this, &type_list](const lldb::TypeSP &type_sp) -> bool {
 624       SymbolContextScope *scs = type_sp->GetSymbolContextScope();
 625       if (scs && function == scs->CalculateSymbolContextFunction())
 626         type_list.Insert(type_sp);
 627       return true; // Keep iterating
 628     });
 629
 630     // Remove any entries that are now in "type_list" from "type_map"
 631     // since we can't remove from type_map while iterating
 632     const size_t new_type_list_size = type_list.GetSize();
 633     if (new_type_list_size > old_type_list_size) {
 634       for (size_t i = old_type_list_size; i < new_type_list_size; ++i)
 635         type_map.Remove(type_list.GetTypeAtIndex(i));
 636     }
 637   }
 638   //----------------------------------------------------------------------
 639   // Find all types that match the current compile unit, if we have one,
 640   // and put them next in the list.
 641   //----------------------------------------------------------------------
 642   if (comp_unit != nullptr && !type_map.Empty()) {
 643     const size_t old_type_list_size = type_list.GetSize();
 644
 645     type_map.ForEach([this, &type_list](const lldb::TypeSP &type_sp) -> bool {
 646       SymbolContextScope *scs = type_sp->GetSymbolContextScope();
 647       if (scs && comp_unit == scs->CalculateSymbolContextCompileUnit())
 648         type_list.Insert(type_sp);
 649       return true; // Keep iterating
 650     });
 651
 652     // Remove any entries that are now in "type_list" from "type_map"
 653     // since we can't remove from type_map while iterating
 654     const size_t new_type_list_size = type_list.GetSize();
 655     if (new_type_list_size > old_type_list_size) {
 656       for (size_t i = old_type_list_size; i < new_type_list_size; ++i)
 657         type_map.Remove(type_list.GetTypeAtIndex(i));
 658     }
 659   }
 660   //----------------------------------------------------------------------
 661   // Find all types that match the current module, if we have one, and put
 662   // them next in the list.
 663   //----------------------------------------------------------------------
 664   if (module_sp && !type_map.Empty()) {
 665     const size_t old_type_list_size = type_list.GetSize();
 666     type_map.ForEach([this, &type_list](const lldb::TypeSP &type_sp) -> bool {
 667       SymbolContextScope *scs = type_sp->GetSymbolContextScope();
 668       if (scs && module_sp == scs->CalculateSymbolContextModule())
 669         type_list.Insert(type_sp);
 670       return true; // Keep iterating
 671     });
 672     // Remove any entries that are now in "type_list" from "type_map"
 673     // since we can't remove from type_map while iterating
 674     const size_t new_type_list_size = type_list.GetSize();
 675     if (new_type_list_size > old_type_list_size) {
 676       for (size_t i = old_type_list_size; i < new_type_list_size; ++i)
 677         type_map.Remove(type_list.GetTypeAtIndex(i));
 678     }
 679   }
 680   //----------------------------------------------------------------------
 681   // Any types that are left get copied into the list an any order.
 682   //----------------------------------------------------------------------
 683   if (!type_map.Empty()) {
 684     type_map.ForEach([&type_list](const lldb::TypeSP &type_sp) -> bool {
 685       type_list.Insert(type_sp);
 686       return true; // Keep iterating
 687     });
 688   }
 689 }
 690
 691 ConstString
 692 SymbolContext::GetFunctionName(Mangled::NamePreference preference) const {
 693   if (function) {
 694     if (block) {
 695       Block *inlined_block = block->GetContainingInlinedBlock();
 696
 697       if (inlined_block) {
 698         const InlineFunctionInfo *inline_info =
 699             inlined_block->GetInlinedFunctionInfo();
 700         if (inline_info)
 701           return inline_info->GetName(function->GetLanguage());
 702       }
 703     }
 704     return function->GetMangled().GetName(function->GetLanguage(), preference);
 705   } else if (symbol && symbol->ValueIsAddress()) {
 706     return symbol->GetMangled().GetName(symbol->GetLanguage(), preference);
 707   } else {
 708     // No function, return an empty string.
 709     return ConstString();
 710   }
 711 }
 712
 713 LineEntry SymbolContext::GetFunctionStartLineEntry() const {
 714   LineEntry line_entry;
 715   Address start_addr;
 716   if (block) {
 717     Block *inlined_block = block->GetContainingInlinedBlock();
 718     if (inlined_block) {
 719       if (inlined_block->GetStartAddress(start_addr)) {
 720         if (start_addr.CalculateSymbolContextLineEntry(line_entry))
 721           return line_entry;
 722       }
 723       return LineEntry();
 724     }
 725   }
 726
 727   if (function) {
 728     if (function->GetAddressRange()
 729             .GetBaseAddress()
 730             .CalculateSymbolContextLineEntry(line_entry))
 731       return line_entry;
 732   }
 733   return LineEntry();
 734 }
 735
 736 bool SymbolContext::GetAddressRangeFromHereToEndLine(uint32_t end_line,
 737                                                      AddressRange &range,
 738                                                      Status &error) {
 739   if (!line_entry.IsValid()) {
 740     error.SetErrorString("Symbol context has no line table.");
 741     return false;
 742   }
 743
 744   range = line_entry.range;
 745   if (line_entry.line > end_line) {
 746     error.SetErrorStringWithFormat(
 747         "end line option %d must be after the current line: %d", end_line,
 748         line_entry.line);
 749     return false;
 750   }
 751
 752   uint32_t line_index = 0;
 753   bool found = false;
 754   while (1) {
 755     LineEntry this_line;
 756     line_index = comp_unit->FindLineEntry(line_index, line_entry.line, nullptr,
 757                                           false, &this_line);
 758     if (line_index == UINT32_MAX)
 759       break;
 760     if (LineEntry::Compare(this_line, line_entry) == 0) {
 761       found = true;
 762       break;
 763     }
 764   }
 765
 766   LineEntry end_entry;
 767   if (!found) {
 768     // Can't find the index of the SymbolContext's line entry in the
 769     // SymbolContext's CompUnit.
 770     error.SetErrorString(
 771         "Can't find the current line entry in the CompUnit - can't process "
 772         "the end-line option");
 773     return false;
 774   }
 775
 776   line_index = comp_unit->FindLineEntry(line_index, end_line, nullptr, false,
 777                                         &end_entry);
 778   if (line_index == UINT32_MAX) {
 779     error.SetErrorStringWithFormat(
 780         "could not find a line table entry corresponding "
 781         "to end line number %d",
 782         end_line);
 783     return false;
 784   }
 785
 786   Block *func_block = GetFunctionBlock();
 787   if (func_block &&
 788       func_block->GetRangeIndexContainingAddress(
 789           end_entry.range.GetBaseAddress()) == UINT32_MAX) {
 790     error.SetErrorStringWithFormat(
 791         "end line number %d is not contained within the current function.",
 792         end_line);
 793     return false;
 794   }
 795
 796   lldb::addr_t range_size = end_entry.range.GetBaseAddress().GetFileAddress() -
 797                             range.GetBaseAddress().GetFileAddress();
 798   range.SetByteSize(range_size);
 799   return true;
 800 }
 801
 802 const Symbol *
 803 SymbolContext::FindBestGlobalDataSymbol(const ConstString &name, Status &error) {
 804   error.Clear();
 805
 806   if (!target_sp) {
 807     return nullptr;
 808   }
 809
 810   Target &target = *target_sp;
 811   Module *module = module_sp.get();
 812
 813   auto ProcessMatches = [this, &name, &target, module]
 814   (SymbolContextList &sc_list, Status &error) -> const Symbol* {
 815     llvm::SmallVector<const Symbol *, 1> external_symbols;
 816     llvm::SmallVector<const Symbol *, 1> internal_symbols;
 817     const uint32_t matches = sc_list.GetSize();
 818     for (uint32_t i = 0; i < matches; ++i) {
 819       SymbolContext sym_ctx;
 820       sc_list.GetContextAtIndex(i, sym_ctx);
 821       if (sym_ctx.symbol) {
 822         const Symbol *symbol = sym_ctx.symbol;
 823         const Address sym_address = symbol->GetAddress();
 824
 825         if (sym_address.IsValid()) {
 826           switch (symbol->GetType()) {
 827             case eSymbolTypeData:
 828             case eSymbolTypeRuntime:
 829             case eSymbolTypeAbsolute:
 830             case eSymbolTypeObjCClass:
 831             case eSymbolTypeObjCMetaClass:
 832             case eSymbolTypeObjCIVar:
 833               if (symbol->GetDemangledNameIsSynthesized()) {
 834                 // If the demangled name was synthesized, then don't use it
 835                 // for expressions. Only let the symbol match if the mangled
 836                 // named matches for these symbols.
 837                 if (symbol->GetMangled().GetMangledName() != name)
 838                   break;
 839               }
 840               if (symbol->IsExternal()) {
 841                 external_symbols.push_back(symbol);
 842               } else {
 843                 internal_symbols.push_back(symbol);
 844               }
 845               break;
 846             case eSymbolTypeReExported: {
 847               ConstString reexport_name = symbol->GetReExportedSymbolName();
 848               if (reexport_name) {
 849                 ModuleSP reexport_module_sp;
 850                 ModuleSpec reexport_module_spec;
 851                 reexport_module_spec.GetPlatformFileSpec() =
 852                 symbol->GetReExportedSymbolSharedLibrary();
 853                 if (reexport_module_spec.GetPlatformFileSpec()) {
 854                   reexport_module_sp =
 855                   target.GetImages().FindFirstModule(reexport_module_spec);
 856                   if (!reexport_module_sp) {
 857                     reexport_module_spec.GetPlatformFileSpec()
 858                     .GetDirectory()
 859                     .Clear();
 860                     reexport_module_sp =
 861                     target.GetImages().FindFirstModule(reexport_module_spec);
 862                   }
 863                 }
 864                 // Don't allow us to try and resolve a re-exported symbol if it is
 865                 // the same as the current symbol
 866                 if (name == symbol->GetReExportedSymbolName() &&
 867                     module == reexport_module_sp.get())
 868                   return nullptr;
 869
 870                 return FindBestGlobalDataSymbol(
 871                     symbol->GetReExportedSymbolName(), error);
 872               }
 873             } break;
 874
 875             case eSymbolTypeCode: // We already lookup functions elsewhere
 876             case eSymbolTypeVariable:
 877             case eSymbolTypeLocal:
 878             case eSymbolTypeParam:
 879             case eSymbolTypeTrampoline:
 880             case eSymbolTypeInvalid:
 881             case eSymbolTypeException:
 882             case eSymbolTypeSourceFile:
 883             case eSymbolTypeHeaderFile:
 884             case eSymbolTypeObjectFile:
 885             case eSymbolTypeCommonBlock:
 886             case eSymbolTypeBlock:
 887             case eSymbolTypeVariableType:
 888             case eSymbolTypeLineEntry:
 889             case eSymbolTypeLineHeader:
 890             case eSymbolTypeScopeBegin:
 891             case eSymbolTypeScopeEnd:
 892             case eSymbolTypeAdditional:
 893             case eSymbolTypeCompiler:
 894             case eSymbolTypeInstrumentation:
 895             case eSymbolTypeUndefined:
 896             case eSymbolTypeResolver:
 897               break;
 898           }
 899         }
 900       }
 901     }
 902
 903     if (external_symbols.size() > 1) {
 904       StreamString ss;
 905       ss.Printf("Multiple external symbols found for '%s'\n", name.AsCString());
 906       for (const Symbol *symbol : external_symbols) {
 907         symbol->GetDescription(&ss, eDescriptionLevelFull, &target);
 908       }
 909       ss.PutChar('\n');
 910       error.SetErrorString(ss.GetData());
 911       return nullptr;
 912     } else if (external_symbols.size()) {
 913       return external_symbols[0];
 914     } else if (internal_symbols.size() > 1) {
 915       StreamString ss;
 916       ss.Printf("Multiple internal symbols found for '%s'\n", name.AsCString());
 917       for (const Symbol *symbol : internal_symbols) {
 918         symbol->GetDescription(&ss, eDescriptionLevelVerbose, &target);
 919         ss.PutChar('\n');
 920       }
 921       error.SetErrorString(ss.GetData());
 922       return nullptr;
 923     } else if (internal_symbols.size()) {
 924       return internal_symbols[0];
 925     } else {
 926       return nullptr;
 927     }
 928   };
 929
 930   if (module) {
 931     SymbolContextList sc_list;
 932     module->FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
 933     const Symbol *const module_symbol = ProcessMatches(sc_list, error);
 934
 935     if (!error.Success()) {
 936       return nullptr;
 937     } else if (module_symbol) {
 938       return module_symbol;
 939     }
 940   }
 941
 942   {
 943     SymbolContextList sc_list;
 944     target.GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeAny,
 945                                                   sc_list);
 946     const Symbol *const target_symbol = ProcessMatches(sc_list, error);
 947
 948     if (!error.Success()) {
 949       return nullptr;
 950     } else if (target_symbol) {
 951       return target_symbol;
 952     }
 953   }
 954
 955   return nullptr; // no error; we just didn't find anything
 956 }
 957
 958
 959 //----------------------------------------------------------------------
 960 //
 961 //  SymbolContextSpecifier
 962 //
 963 //----------------------------------------------------------------------
 964
 965 SymbolContextSpecifier::SymbolContextSpecifier(const TargetSP &target_sp)
 966     : m_target_sp(target_sp), m_module_spec(), m_module_sp(), m_file_spec_ap(),
 967       m_start_line(0), m_end_line(0), m_function_spec(), m_class_name(),
 968       m_address_range_ap(), m_type(eNothingSpecified) {}
 969
 970 SymbolContextSpecifier::~SymbolContextSpecifier() {}
 971
 972 bool SymbolContextSpecifier::AddLineSpecification(uint32_t line_no,
 973                                                   SpecificationType type) {
 974   bool return_value = true;
 975   switch (type) {
 976   case eNothingSpecified:
 977     Clear();
 978     break;
 979   case eLineStartSpecified:
 980     m_start_line = line_no;
 981     m_type |= eLineStartSpecified;
 982     break;
 983   case eLineEndSpecified:
 984     m_end_line = line_no;
 985     m_type |= eLineEndSpecified;
 986     break;
 987   default:
 988     return_value = false;
 989     break;
 990   }
 991   return return_value;
 992 }
 993
 994 bool SymbolContextSpecifier::AddSpecification(const char *spec_string,
 995                                               SpecificationType type) {
 996   bool return_value = true;
 997   switch (type) {
 998   case eNothingSpecified:
 999     Clear();
1000     break;
1001   case eModuleSpecified: {
1002     // See if we can find the Module, if so stick it in the SymbolContext.
1003     FileSpec module_file_spec(spec_string, false);
1004     ModuleSpec module_spec(module_file_spec);
1005     lldb::ModuleSP module_sp(
1006         m_target_sp->GetImages().FindFirstModule(module_spec));
1007     m_type |= eModuleSpecified;
1008     if (module_sp)
1009       m_module_sp = module_sp;
1010     else
1011       m_module_spec.assign(spec_string);
1012   } break;
1013   case eFileSpecified:
1014     // CompUnits can't necessarily be resolved here, since an inlined function
1015     // might show up in
1016     // a number of CompUnits.  Instead we just convert to a FileSpec and store
1017     // it away.
1018     m_file_spec_ap.reset(new FileSpec(spec_string, false));
1019     m_type |= eFileSpecified;
1020     break;
1021   case eLineStartSpecified:
1022     m_start_line = StringConvert::ToSInt32(spec_string, 0, 0, &return_value);
1023     if (return_value)
1024       m_type |= eLineStartSpecified;
1025     break;
1026   case eLineEndSpecified:
1027     m_end_line = StringConvert::ToSInt32(spec_string, 0, 0, &return_value);
1028     if (return_value)
1029       m_type |= eLineEndSpecified;
1030     break;
1031   case eFunctionSpecified:
1032     m_function_spec.assign(spec_string);
1033     m_type |= eFunctionSpecified;
1034     break;
1035   case eClassOrNamespaceSpecified:
1036     Clear();
1037     m_class_name.assign(spec_string);
1038     m_type = eClassOrNamespaceSpecified;
1039     break;
1040   case eAddressRangeSpecified:
1041     // Not specified yet...
1042     break;
1043   }
1044
1045   return return_value;
1046 }
1047
1048 void SymbolContextSpecifier::Clear() {
1049   m_module_spec.clear();
1050   m_file_spec_ap.reset();
1051   m_function_spec.clear();
1052   m_class_name.clear();
1053   m_start_line = 0;
1054   m_end_line = 0;
1055   m_address_range_ap.reset();
1056
1057   m_type = eNothingSpecified;
1058 }
1059
1060 bool SymbolContextSpecifier::SymbolContextMatches(SymbolContext &sc) {
1061   if (m_type == eNothingSpecified)
1062     return true;
1063
1064   if (m_target_sp.get() != sc.target_sp.get())
1065     return false;
1066
1067   if (m_type & eModuleSpecified) {
1068     if (sc.module_sp) {
1069       if (m_module_sp.get() != nullptr) {
1070         if (m_module_sp.get() != sc.module_sp.get())
1071           return false;
1072       } else {
1073         FileSpec module_file_spec(m_module_spec, false);
1074         if (!FileSpec::Equal(module_file_spec, sc.module_sp->GetFileSpec(),
1075                              false))
1076           return false;
1077       }
1078     }
1079   }
1080   if (m_type & eFileSpecified) {
1081     if (m_file_spec_ap.get()) {
1082       // If we don't have a block or a comp_unit, then we aren't going to match
1083       // a source file.
1084       if (sc.block == nullptr && sc.comp_unit == nullptr)
1085         return false;
1086
1087       // Check if the block is present, and if so is it inlined:
1088       bool was_inlined = false;
1089       if (sc.block != nullptr) {
1090         const InlineFunctionInfo *inline_info =
1091             sc.block->GetInlinedFunctionInfo();
1092         if (inline_info != nullptr) {
1093           was_inlined = true;
1094           if (!FileSpec::Equal(inline_info->GetDeclaration().GetFile(),
1095                                *(m_file_spec_ap.get()), false))
1096             return false;
1097         }
1098       }
1099
1100       // Next check the comp unit, but only if the SymbolContext was not
1101       // inlined.
1102       if (!was_inlined && sc.comp_unit != nullptr) {
1103         if (!FileSpec::Equal(*(sc.comp_unit), *(m_file_spec_ap.get()), false))
1104           return false;
1105       }
1106     }
1107   }
1108   if (m_type & eLineStartSpecified || m_type & eLineEndSpecified) {
1109     if (sc.line_entry.line < m_start_line || sc.line_entry.line > m_end_line)
1110       return false;
1111   }
1112
1113   if (m_type & eFunctionSpecified) {
1114     // First check the current block, and if it is inlined, get the inlined
1115     // function name:
1116     bool was_inlined = false;
1117     ConstString func_name(m_function_spec.c_str());
1118
1119     if (sc.block != nullptr) {
1120       const InlineFunctionInfo *inline_info =
1121           sc.block->GetInlinedFunctionInfo();
1122       if (inline_info != nullptr) {
1123         was_inlined = true;
1124         const Mangled &name = inline_info->GetMangled();
1125         if (!name.NameMatches(func_name, sc.function->GetLanguage()))
1126           return false;
1127       }
1128     }
1129     //  If it wasn't inlined, check the name in the function or symbol:
1130     if (!was_inlined) {
1131       if (sc.function != nullptr) {
1132         if (!sc.function->GetMangled().NameMatches(func_name,
1133                                                    sc.function->GetLanguage()))
1134           return false;
1135       } else if (sc.symbol != nullptr) {
1136         if (!sc.symbol->GetMangled().NameMatches(func_name,
1137                                                  sc.symbol->GetLanguage()))
1138           return false;
1139       }
1140     }
1141   }
1142
1143   return true;
1144 }
1145
1146 bool SymbolContextSpecifier::AddressMatches(lldb::addr_t addr) {
1147   if (m_type & eAddressRangeSpecified) {
1148
1149   } else {
1150     Address match_address(addr, nullptr);
1151     SymbolContext sc;
1152     m_target_sp->GetImages().ResolveSymbolContextForAddress(
1153         match_address, eSymbolContextEverything, sc);
1154     return SymbolContextMatches(sc);
1155   }
1156   return true;
1157 }
1158
1159 void SymbolContextSpecifier::GetDescription(
1160     Stream *s, lldb::DescriptionLevel level) const {
1161   char path_str[PATH_MAX + 1];
1162
1163   if (m_type == eNothingSpecified) {
1164     s->Printf("Nothing specified.\n");
1165   }
1166
1167   if (m_type == eModuleSpecified) {
1168     s->Indent();
1169     if (m_module_sp) {
1170       m_module_sp->GetFileSpec().GetPath(path_str, PATH_MAX);
1171       s->Printf("Module: %s\n", path_str);
1172     } else
1173       s->Printf("Module: %s\n", m_module_spec.c_str());
1174   }
1175
1176   if (m_type == eFileSpecified && m_file_spec_ap.get() != nullptr) {
1177     m_file_spec_ap->GetPath(path_str, PATH_MAX);
1178     s->Indent();
1179     s->Printf("File: %s", path_str);
1180     if (m_type == eLineStartSpecified) {
1181       s->Printf(" from line %" PRIu64 "", (uint64_t)m_start_line);
1182       if (m_type == eLineEndSpecified)
1183         s->Printf("to line %" PRIu64 "", (uint64_t)m_end_line);
1184       else
1185         s->Printf("to end");
1186     } else if (m_type == eLineEndSpecified) {
1187       s->Printf(" from start to line %" PRIu64 "", (uint64_t)m_end_line);
1188     }
1189     s->Printf(".\n");
1190   }
1191
1192   if (m_type == eLineStartSpecified) {
1193     s->Indent();
1194     s->Printf("From line %" PRIu64 "", (uint64_t)m_start_line);
1195     if (m_type == eLineEndSpecified)
1196       s->Printf("to line %" PRIu64 "", (uint64_t)m_end_line);
1197     else
1198       s->Printf("to end");
1199     s->Printf(".\n");
1200   } else if (m_type == eLineEndSpecified) {
1201     s->Printf("From start to line %" PRIu64 ".\n", (uint64_t)m_end_line);
1202   }
1203
1204   if (m_type == eFunctionSpecified) {
1205     s->Indent();
1206     s->Printf("Function: %s.\n", m_function_spec.c_str());
1207   }
1208
1209   if (m_type == eClassOrNamespaceSpecified) {
1210     s->Indent();
1211     s->Printf("Class name: %s.\n", m_class_name.c_str());
1212   }
1213
1214   if (m_type == eAddressRangeSpecified && m_address_range_ap.get() != nullptr) {
1215     s->Indent();
1216     s->PutCString("Address range: ");
1217     m_address_range_ap->Dump(s, m_target_sp.get(),
1218                              Address::DumpStyleLoadAddress,
1219                              Address::DumpStyleFileAddress);
1220     s->PutCString("\n");
1221   }
1222 }
1223
1224 //----------------------------------------------------------------------
1225 //
1226 //  SymbolContextList
1227 //
1228 //----------------------------------------------------------------------
1229
1230 SymbolContextList::SymbolContextList() : m_symbol_contexts() {}
1231
1232 SymbolContextList::~SymbolContextList() {}
1233
1234 void SymbolContextList::Append(const SymbolContext &sc) {
1235   m_symbol_contexts.push_back(sc);
1236 }
1237
1238 void SymbolContextList::Append(const SymbolContextList &sc_list) {
1239   collection::const_iterator pos, end = sc_list.m_symbol_contexts.end();
1240   for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos)
1241     m_symbol_contexts.push_back(*pos);
1242 }
1243
1244 uint32_t SymbolContextList::AppendIfUnique(const SymbolContextList &sc_list,
1245                                            bool merge_symbol_into_function) {
1246   uint32_t unique_sc_add_count = 0;
1247   collection::const_iterator pos, end = sc_list.m_symbol_contexts.end();
1248   for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos) {
1249     if (AppendIfUnique(*pos, merge_symbol_into_function))
1250       ++unique_sc_add_count;
1251   }
1252   return unique_sc_add_count;
1253 }
1254
1255 bool SymbolContextList::AppendIfUnique(const SymbolContext &sc,
1256                                        bool merge_symbol_into_function) {
1257   collection::iterator pos, end = m_symbol_contexts.end();
1258   for (pos = m_symbol_contexts.begin(); pos != end; ++pos) {
1259     if (*pos == sc)
1260       return false;
1261   }
1262   if (merge_symbol_into_function && sc.symbol != nullptr &&
1263       sc.comp_unit == nullptr && sc.function == nullptr &&
1264       sc.block == nullptr && sc.line_entry.IsValid() == false) {
1265     if (sc.symbol->ValueIsAddress()) {
1266       for (pos = m_symbol_contexts.begin(); pos != end; ++pos) {
1267         // Don't merge symbols into inlined function symbol contexts
1268         if (pos->block && pos->block->GetContainingInlinedBlock())
1269           continue;
1270
1271         if (pos->function) {
1272           if (pos->function->GetAddressRange().GetBaseAddress() ==
1273               sc.symbol->GetAddressRef()) {
1274             // Do we already have a function with this symbol?
1275             if (pos->symbol == sc.symbol)
1276               return false;
1277             if (pos->symbol == nullptr) {
1278               pos->symbol = sc.symbol;
1279               return false;
1280             }
1281           }
1282         }
1283       }
1284     }
1285   }
1286   m_symbol_contexts.push_back(sc);
1287   return true;
1288 }
1289
1290 bool SymbolContextList::MergeSymbolContextIntoFunctionContext(
1291     const SymbolContext &symbol_sc, uint32_t start_idx, uint32_t stop_idx) {
1292   if (symbol_sc.symbol != nullptr && symbol_sc.comp_unit == nullptr &&
1293       symbol_sc.function == nullptr && symbol_sc.block == nullptr &&
1294       symbol_sc.line_entry.IsValid() == false) {
1295     if (symbol_sc.symbol->ValueIsAddress()) {
1296       const size_t end = std::min<size_t>(m_symbol_contexts.size(), stop_idx);
1297       for (size_t i = start_idx; i < end; ++i) {
1298         const SymbolContext &function_sc = m_symbol_contexts[i];
1299         // Don't merge symbols into inlined function symbol contexts
1300         if (function_sc.block && function_sc.block->GetContainingInlinedBlock())
1301           continue;
1302
1303         if (function_sc.function) {
1304           if (function_sc.function->GetAddressRange().GetBaseAddress() ==
1305               symbol_sc.symbol->GetAddressRef()) {
1306             // Do we already have a function with this symbol?
1307             if (function_sc.symbol == symbol_sc.symbol)
1308               return true; // Already have a symbol context with this symbol,
1309                            // return true
1310
1311             if (function_sc.symbol == nullptr) {
1312               // We successfully merged this symbol into an existing symbol
1313               // context
1314               m_symbol_contexts[i].symbol = symbol_sc.symbol;
1315               return true;
1316             }
1317           }
1318         }
1319       }
1320     }
1321   }
1322   return false;
1323 }
1324
1325 void SymbolContextList::Clear() { m_symbol_contexts.clear(); }
1326
1327 void SymbolContextList::Dump(Stream *s, Target *target) const {
1328
1329   *s << this << ": ";
1330   s->Indent();
1331   s->PutCString("SymbolContextList");
1332   s->EOL();
1333   s->IndentMore();
1334
1335   collection::const_iterator pos, end = m_symbol_contexts.end();
1336   for (pos = m_symbol_contexts.begin(); pos != end; ++pos) {
1337     // pos->Dump(s, target);
1338     pos->GetDescription(s, eDescriptionLevelVerbose, target);
1339   }
1340   s->IndentLess();
1341 }
1342
1343 bool SymbolContextList::GetContextAtIndex(size_t idx, SymbolContext &sc) const {
1344   if (idx < m_symbol_contexts.size()) {
1345     sc = m_symbol_contexts[idx];
1346     return true;
1347   }
1348   return false;
1349 }
1350
1351 bool SymbolContextList::GetLastContext(SymbolContext &sc) const {
1352   if (!m_symbol_contexts.empty()) {
1353     sc = m_symbol_contexts.back();
1354     return true;
1355   }
1356   return false;
1357 }
1358
1359 bool SymbolContextList::RemoveContextAtIndex(size_t idx) {
1360   if (idx < m_symbol_contexts.size()) {
1361     m_symbol_contexts.erase(m_symbol_contexts.begin() + idx);
1362     return true;
1363   }
1364   return false;
1365 }
1366
1367 uint32_t SymbolContextList::GetSize() const { return m_symbol_contexts.size(); }
1368
1369 uint32_t SymbolContextList::NumLineEntriesWithLine(uint32_t line) const {
1370   uint32_t match_count = 0;
1371   const size_t size = m_symbol_contexts.size();
1372   for (size_t idx = 0; idx < size; ++idx) {
1373     if (m_symbol_contexts[idx].line_entry.line == line)
1374       ++match_count;
1375   }
1376   return match_count;
1377 }
1378
1379 void SymbolContextList::GetDescription(Stream *s, lldb::DescriptionLevel level,
1380                                        Target *target) const {
1381   const size_t size = m_symbol_contexts.size();
1382   for (size_t idx = 0; idx < size; ++idx)
1383     m_symbol_contexts[idx].GetDescription(s, level, target);
1384 }
1385
1386 bool lldb_private::operator==(const SymbolContextList &lhs,
1387                               const SymbolContextList &rhs) {
1388   const uint32_t size = lhs.GetSize();
1389   if (size != rhs.GetSize())
1390     return false;
1391
1392   SymbolContext lhs_sc;
1393   SymbolContext rhs_sc;
1394   for (uint32_t i = 0; i < size; ++i) {
1395     lhs.GetContextAtIndex(i, lhs_sc);
1396     rhs.GetContextAtIndex(i, rhs_sc);
1397     if (lhs_sc != rhs_sc)
1398       return false;
1399   }
1400   return true;
1401 }
1402
1403 bool lldb_private::operator!=(const SymbolContextList &lhs,
1404                               const SymbolContextList &rhs) {
1405   return !(lhs == rhs);
1406 }