[lldb] Expose a const iterator for SymbolContextList

[bulbazord]

Summary

There are many situations where we'll iterate over a SymbolContextList
with the pattern:

SymbolContextList sc_list;
// Fill in sc_list here
for (auto i = 0; i < sc_list.GetSize(); i++) {
  SymbolContext sc;
  sc_list.GetSymbolAtContext(i, sc);

  // Do work with sc
}

Adding an iterator to iterate over the instances directly means we don't
have to do bounds checking or create a copy of every element of the
SymbolContextList.

[aprantl]

Please do more of this!
I haven't checked all the replacements for correctness but the direction is good.

[mib]

LGTM but I'd prefer if we kept the type in the for loop

for (const SymbolContext &sym_ctx : sc_list)

[JDevlieghere]

LGTM

[bulbazord]

Explicitly write out type

[bulbazord]

Looks like this may have broken the Debian buildbot: https://lab.llvm.org/buildbot/#/builders/68/builds/52162/steps/6/logs/stdio

I'm taking a look and will try to fix forward. If I can't figure it out quickly, I will revert.

lldb/include/lldb/Breakpoint/BreakpointResolverFileLine.h

static inline bool classof(const BreakpointResolver *V) {
     return V->getResolverID() == BreakpointResolver::FileLineResolver;
   }
 
   lldb::BreakpointResolverSP
   CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override;
 
 protected:
   void FilterContexts(SymbolContextList &sc_list);
-  void DeduceSourceMapping(SymbolContextList &sc_list);
+  void DeduceSourceMapping(const SymbolContextList &sc_list);
 
   friend class Breakpoint;
   SourceLocationSpec m_location_spec;
   bool m_skip_prologue;
   // Any previously removed file path prefix by reverse source mapping.
   // This is used to auto deduce source map if needed.
   std::optional<llvm::StringRef> m_removed_prefix_opt;
 

lldb/include/lldb/Symbol/SymbolContext.h

public:
   uint32_t NumLineEntriesWithLine(uint32_t line) const;
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level,
                       Target *target) const;
 
 protected:
   typedef std::vector<SymbolContext>
       collection; ///< The collection type for the list.
+  typedef collection::const_iterator const_iterator;
 
   // Member variables.
   collection m_symbol_contexts; ///< The list of symbol contexts.
 
 public:
+  const_iterator begin() const { return m_symbol_contexts.begin(); }
+  const_iterator end() const { return m_symbol_contexts.end(); }
+
   typedef AdaptedIterable<collection, SymbolContext, vector_adapter>
       SymbolContextIterable;
   SymbolContextIterable SymbolContexts() {
     return SymbolContextIterable(m_symbol_contexts);
   }
 };
 
 bool operator==(const SymbolContext &lhs, const SymbolContext &rhs);
 bool operator!=(const SymbolContext &lhs, const SymbolContext &rhs);
 
 bool operator==(const SymbolContextList &lhs, const SymbolContextList &rhs);
 bool operator!=(const SymbolContextList &lhs, const SymbolContextList &rhs);
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_SYMBOLCONTEXT_H

lldb/include/lldb/Symbol/UnwindTable.h

public:
   // unwind we want to create brand new UnwindPlans for the function of
   // interest - so ignore any existing FuncUnwinders for that function and
   // don't add this new one to our UnwindTable. This FuncUnwinders object does
   // have a reference to the UnwindTable but the lifetime of this uncached
   // FuncUnwinders is expected to be short so in practice this will not be a
   // problem.
   lldb::FuncUnwindersSP
   GetUncachedFuncUnwindersContainingAddress(const Address &addr,
-                                            SymbolContext &sc);
+                                            const SymbolContext &sc);
 
   ArchSpec GetArchitecture();
 
 private:
   void Dump(Stream &s);
 
   void Initialize();
   std::optional<AddressRange> GetAddressRange(const Address &addr,
-                                              SymbolContext &sc);
+                                              const SymbolContext &sc);
 
   typedef std::map<lldb::addr_t, lldb::FuncUnwindersSP> collection;
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
   Module &m_module;
   collection m_unwinds;
 

lldb/source/API/SBThread.cpp

if (exe_ctx.HasThreadScope()) {
     // TODO: Handle SourceLocationSpec column information
     SourceLocationSpec location_spec(
         step_file_spec, line, /*column=*/std::nullopt, /*check_inlines=*/true,
         /*exact_match=*/false);
 
     SymbolContextList sc_list;
     frame_sc.comp_unit->ResolveSymbolContext(location_spec,
                                              eSymbolContextLineEntry, sc_list);
-    const uint32_t num_matches = sc_list.GetSize();
-    if (num_matches > 0) {
-      SymbolContext sc;
-      for (uint32_t i = 0; i < num_matches; ++i) {
-        if (sc_list.GetContextAtIndex(i, sc)) {
-          addr_t step_addr =
-              sc.line_entry.range.GetBaseAddress().GetLoadAddress(target);
-          if (step_addr != LLDB_INVALID_ADDRESS) {
-            if (fun_range.ContainsLoadAddress(step_addr, target))
-              step_over_until_addrs.push_back(step_addr);
-            else
-              all_in_function = false;
-          }
-        }
-      }
-    }
+    for (const SymbolContext &sc : sc_list) {
 
     if (step_over_until_addrs.empty()) {
       if (all_in_function) {
         step_file_spec.GetPath(path, sizeof(path));
         sb_error.SetErrorStringWithFormat("No line entries for %s:%u", path,
                                           line);
       } else
         sb_error.SetErrorString("step until target not in current function");

lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

if (line &&
       LLDB_LOG(log, "removing symbol context at {0}:{1}", file, line);
       sc_list.RemoveContextAtIndex(i);
       --i;
     }
   }
 }
 
 void BreakpointResolverFileLine::DeduceSourceMapping(
-    SymbolContextList &sc_list) {
+    const SymbolContextList &sc_list) {
   Target &target = GetBreakpoint()->GetTarget();
   if (!target.GetAutoSourceMapRelative())
     return;
 
   Log *log = GetLog(LLDBLog::Breakpoints);
   const llvm::StringRef path_separator = llvm::sys::path::get_separator(
       m_location_spec.GetFileSpec().GetPathStyle());
   // Check if "b" is a suffix of "a".
void BreakpointResolverFileLine::DeduceSourceMapping(
 
   // Only auto deduce source map if breakpoint is full path.
   // Note: an existing source map reverse mapping (m_removed_prefix_opt has
   // value) may make request_file relative.
   if (!m_removed_prefix_opt.has_value() && request_file.IsRelative())
     return;
 
   const bool case_sensitive = request_file.IsCaseSensitive();
-  for (uint32_t i = 0; i < sc_list.GetSize(); ++i) {
-    SymbolContext sc;
-    sc_list.GetContextAtIndex(i, sc);
-
+  for (const SymbolContext &sc : sc_list) {
     FileSpec sc_file = sc.line_entry.file;
 
-    if (FileSpec::Equal(sc_file, request_file, /*full*/true))
+    if (FileSpec::Equal(sc_file, request_file, /*full*/ true))
       continue;
 
     llvm::StringRef sc_file_dir = sc_file.GetDirectory().GetStringRef();
     llvm::StringRef request_file_dir =
         request_file.GetDirectory().GetStringRef();
 
     llvm::StringRef new_mapping_from;
     llvm::SmallString<256> new_mapping_to;

lldb/source/Breakpoint/BreakpointResolverName.cpp

if (filter_by_cu || filter_by_language) {
     }
   }
 
   BreakpointSP breakpoint_sp = GetBreakpoint();
   Breakpoint &breakpoint = *breakpoint_sp;
   Address break_addr;
 
   // Remove any duplicates between the function list and the symbol list
-  SymbolContext sc;
-  if (!func_list.GetSize())
-    return Searcher::eCallbackReturnContinue;
-
-  for (uint32_t i = 0; i < func_list.GetSize(); i++) {
-    if (!func_list.GetContextAtIndex(i, sc))
-      continue;
-
+  for (const SymbolContext &sc : func_list) {
     bool is_reexported = false;
 
     if (sc.block && sc.block->GetInlinedFunctionInfo()) {
       if (!sc.block->GetStartAddress(break_addr))
         break_addr.Clear();
     } else if (sc.function) {
       break_addr = sc.function->GetAddressRange().GetBaseAddress();
       if (m_skip_prologue && break_addr.IsValid()) {

lldb/source/Commands/CommandCompletions.cpp

Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           Address *addr) override {
     if (context.module_sp) {
       SymbolContextList sc_list;
       ModuleFunctionSearchOptions function_options;
       function_options.include_symbols = true;
       function_options.include_inlines = true;
       context.module_sp->FindFunctions(m_regex, function_options, sc_list);
 
-      SymbolContext sc;
       // Now add the functions & symbols to the list - only add if unique:
-      for (uint32_t i = 0; i < sc_list.GetSize(); i++) {
-        if (sc_list.GetContextAtIndex(i, sc)) {
-          ConstString func_name = sc.GetFunctionName(Mangled::ePreferDemangled);
-          // Ensure that the function name matches the regex. This is more than
-          // a sanity check. It is possible that the demangled function name
-          // does not start with the prefix, for example when it's in an
-          // anonymous namespace.
-          if (!func_name.IsEmpty() && m_regex.Execute(func_name.GetStringRef()))
-            m_match_set.insert(func_name);
-        }
-      }
-    }
+      for (const SymbolContext &sc : sc_list) {
     return Searcher::eCallbackReturnContinue;
   }
 
   void DoCompletion(SearchFilter *filter) override {
     filter->Search(*this);
     collection::iterator pos = m_match_set.begin(), end = m_match_set.end();
     for (pos = m_match_set.begin(); pos != end; pos++)
       m_request.AddCompletion((*pos).GetCString());

lldb/source/Commands/CommandObjectSource.cpp

uint32_t DumpLinesInSymbolContexts(Stream &strm,
     uint32_t start_line = m_options.start_line;
     uint32_t end_line = m_options.end_line;
     uint32_t num_lines = m_options.num_lines;
     Target *target = m_exe_ctx.GetTargetPtr();
 
     uint32_t num_matches = 0;
     // Dump all the line entries for the file in the list.
     ConstString last_module_file_name;
-    uint32_t num_scs = sc_list.GetSize();
-    for (uint32_t i = 0; i < num_scs; ++i) {
-      SymbolContext sc;
-      sc_list.GetContextAtIndex(i, sc);
+    for (const SymbolContext &sc : sc_list) {
       if (sc.comp_unit) {
         Module *module = sc.module_sp.get();
         CompileUnit *cu = sc.comp_unit;
         const LineEntry &line_entry = sc.line_entry;
         assert(module && cu);
 
         // Are we looking for specific modules, files or lines?
         if (module_list.GetSize() &&
bool DumpLinesInFunctions(CommandReturnObject &result) {
     size_t num_matches = sc_list_funcs.GetSize();
 
     if (!num_matches) {
       // If we didn't find any functions with that name, try searching for
       // symbols that line up exactly with function addresses.
       SymbolContextList sc_list_symbols;
       module_list.FindFunctionSymbols(name, eFunctionNameTypeAuto,
                                       sc_list_symbols);
-      size_t num_symbol_matches = sc_list_symbols.GetSize();
-      for (size_t i = 0; i < num_symbol_matches; i++) {
-        SymbolContext sc;
-        sc_list_symbols.GetContextAtIndex(i, sc);
+      for (const SymbolContext &sc : sc_list_symbols) {
         if (sc.symbol && sc.symbol->ValueIsAddress()) {
           const Address &base_address = sc.symbol->GetAddressRef();
           Function *function = base_address.CalculateSymbolContextFunction();
           if (function) {
             sc_list_funcs.Append(SymbolContext(function));
             num_matches++;
           }
         }
       }
     }
     if (num_matches == 0) {
       result.AppendErrorWithFormat("Could not find function named \'%s\'.\n",
                                    m_options.symbol_name.c_str());
       return false;
     }
-    for (size_t i = 0; i < num_matches; i++) {
-      SymbolContext sc;
-      sc_list_funcs.GetContextAtIndex(i, sc);
+    for (const SymbolContext &sc : sc_list_funcs) {
       bool context_found_for_symbol = false;
       // Loop through all the ranges in the function.
       AddressRange range;
       for (uint32_t r = 0;
            sc.GetAddressRange(eSymbolContextEverything, r,
                               /*use_inline_block_range=*/true, range);
            ++r) {
         // Append the symbol contexts for each address in the range to
bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = m_exe_ctx.GetTargetPtr();
 
     if (!m_options.symbol_name.empty()) {
       SymbolContextList sc_list;
       ConstString name(m_options.symbol_name.c_str());
 
       // Displaying the source for a symbol. Search for function named name.
       FindMatchingFunctions(target, name, sc_list);
-      size_t num_matches = sc_list.GetSize();
-      if (!num_matches) {
+      if (sc_list.GetSize() == 0) {
         // If we didn't find any functions with that name, try searching for
         // symbols that line up exactly with function addresses.
         SymbolContextList sc_list_symbols;
         FindMatchingFunctionSymbols(target, name, sc_list_symbols);
-        size_t num_symbol_matches = sc_list_symbols.GetSize();
-
-        for (size_t i = 0; i < num_symbol_matches; i++) {
-          SymbolContext sc;
-          sc_list_symbols.GetContextAtIndex(i, sc);
+        for (const SymbolContext &sc : sc_list_symbols) {
           if (sc.symbol && sc.symbol->ValueIsAddress()) {
             const Address &base_address = sc.symbol->GetAddressRef();
             Function *function = base_address.CalculateSymbolContextFunction();
             if (function) {
               sc_list.Append(SymbolContext(function));
-              num_matches++;
               break;
             }
           }
         }
       }
 
-      if (num_matches == 0) {
+      if (sc_list.GetSize() == 0) {
         result.AppendErrorWithFormat("Could not find function named: \"%s\".\n",
                                      m_options.symbol_name.c_str());
         return false;
       }
 
-      if (num_matches > 1) {
-        std::set<SourceInfo> source_match_set;
-
-        bool displayed_something = false;
-        for (size_t i = 0; i < num_matches; i++) {
-          SymbolContext sc;
-          sc_list.GetContextAtIndex(i, sc);
-          SourceInfo source_info(sc.GetFunctionName(),
-                                 sc.GetFunctionStartLineEntry());
-
-          if (source_info.IsValid()) {
-            if (source_match_set.find(source_info) == source_match_set.end()) {
-              source_match_set.insert(source_info);
-              if (DisplayFunctionSource(sc, source_info, result))
-                displayed_something = true;
-            }
-          }
-        }
-
-        if (displayed_something)
-          result.SetStatus(eReturnStatusSuccessFinishResult);
-        else
-          result.SetStatus(eReturnStatusFailed);
-      } else {
-        SymbolContext sc;
-        sc_list.GetContextAtIndex(0, sc);
-        SourceInfo source_info;
-
-        if (DisplayFunctionSource(sc, source_info, result)) {
-          result.SetStatus(eReturnStatusSuccessFinishResult);
-        } else {
-          result.SetStatus(eReturnStatusFailed);
-        }
-      }
+      for (const SymbolContext &sc : sc_list) {
+        if (source_info.IsValid() &&
+            source_match_set.find(source_info) == source_match_set.end()) {
       return result.Succeeded();
     } else if (m_options.address != LLDB_INVALID_ADDRESS) {
       Address so_addr;
       StreamString error_strm;
       SymbolContextList sc_list;
 
       if (target->GetSectionLoadList().IsEmpty()) {
         // The target isn't loaded yet, we need to lookup the file address in
if (!m_options.symbol_name.empty()) {
 
         if (sc_list.GetSize() == 0) {
           result.AppendErrorWithFormat(
               "no modules contain load address 0x%" PRIx64 ".\n",
               m_options.address);
           return false;
         }
       }
-      uint32_t num_matches = sc_list.GetSize();
-      for (uint32_t i = 0; i < num_matches; ++i) {
-        SymbolContext sc;
-        sc_list.GetContextAtIndex(i, sc);
+      for (const SymbolContext &sc : sc_list) {
         if (sc.comp_unit) {
           if (m_options.show_bp_locs) {
             m_breakpoint_locations.Clear();
             const bool show_inlines = true;
             m_breakpoint_locations.Reset(sc.comp_unit->GetPrimaryFile(), 0,
                                          show_inlines);
             SearchFilterForUnconstrainedSearches target_search_filter(
                 target->shared_from_this());
if (!m_options.symbol_name.empty()) {
                                      m_options.file_name.c_str());
         return false;
       }
 
       if (num_matches > 1) {
         bool got_multiple = false;
         CompileUnit *test_cu = nullptr;
 
-        for (unsigned i = 0; i < num_matches; i++) {
-          SymbolContext sc;
-          sc_list.GetContextAtIndex(i, sc);
+        for (const SymbolContext &sc : sc_list) {
           if (sc.comp_unit) {
             if (test_cu) {
               if (test_cu != sc.comp_unit)
                 got_multiple = true;
               break;
             } else
               test_cu = sc.comp_unit;
           }

lldb/source/Commands/CommandObjectTarget.cpp

if (argc > 0) {
         } else {
           // No shared libraries, we just want to find globals for the compile
           // units files that were specified
           for (size_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
             target->GetImages().FindCompileUnits(
                 compile_units.GetFileSpecAtIndex(cu_idx), sc_list);
         }
 
-        const uint32_t num_scs = sc_list.GetSize();
-        if (num_scs > 0) {
-          SymbolContext sc;
-          for (uint32_t sc_idx = 0; sc_idx < num_scs; ++sc_idx) {
-            if (sc_list.GetContextAtIndex(sc_idx, sc)) {
-              if (sc.comp_unit) {
-                const bool can_create = true;
-                VariableListSP comp_unit_varlist_sp(
-                    sc.comp_unit->GetVariableList(can_create));
-                if (comp_unit_varlist_sp)
-                  DumpGlobalVariableList(m_exe_ctx, sc, *comp_unit_varlist_sp,
-                                         s);
-              } else if (sc.module_sp) {
-                // Get all global variables for this module
-                lldb_private::RegularExpression all_globals_regex(
-                    llvm::StringRef(
-                        ".")); // Any global with at least one character
-                VariableList variable_list;
-                sc.module_sp->FindGlobalVariables(all_globals_regex, UINT32_MAX,
-                                                  variable_list);
-                DumpGlobalVariableList(m_exe_ctx, sc, variable_list, s);
-              }
-            }
-          }
-        }
-      }
-    }
+        for (const SymbolContext &sc : sc_list) {
+              DumpGlobalVariableList(m_exe_ctx, sc, *comp_unit_varlist_sp, s);
+                llvm::StringRef(".")); // Any global with at least one character
 
     m_interpreter.PrintWarningsIfNecessary(result.GetOutputStream(),
                                            m_cmd_name);
 
     return result.Succeeded();
   }
 
   OptionGroupOptions m_option_group;
static uint32_t DumpCompileUnitLineTable(CommandInterpreter &interpreter,
                                          const FileSpec &file_spec,
                                          lldb::DescriptionLevel desc_level) {
   uint32_t num_matches = 0;
   if (module) {
     SymbolContextList sc_list;
     num_matches = module->ResolveSymbolContextsForFileSpec(
         file_spec, 0, false, eSymbolContextCompUnit, sc_list);
 
-    for (uint32_t i = 0; i < num_matches; ++i) {
-      SymbolContext sc;
-      if (sc_list.GetContextAtIndex(i, sc)) {
-        if (i > 0)
-          strm << "\n\n";
+    bool first_module = true;
+    for (const SymbolContext &sc : sc_list) {
+      if (!first_module)
 
-        strm << "Line table for " << sc.comp_unit->GetPrimaryFile() << " in `"
-             << module->GetFileSpec().GetFilename() << "\n";
-        LineTable *line_table = sc.comp_unit->GetLineTable();
-        if (line_table)
-          line_table->GetDescription(
-              &strm, interpreter.GetExecutionContext().GetTargetPtr(),
-              desc_level);
-        else
-          strm << "No line table";
-      }
+
+      first_module = false;
     }
   }
   return num_matches;
 }
 
 static void DumpFullpath(Stream &strm, const FileSpec *file_spec_ptr,
                          uint32_t width) {
   if (file_spec_ptr) {
for (uint32_t i = 0; i < num_matches; ++i) {
       }
     }
     strm.IndentLess();
   }
   return num_matches;
 }
 
 static void DumpSymbolContextList(ExecutionContextScope *exe_scope,
-                                  Stream &strm, SymbolContextList &sc_list,
+                                  Stream &strm,
+                                  const SymbolContextList &sc_list,
                                   bool verbose, bool all_ranges) {
   strm.IndentMore();
+  bool first_module = true;
+  for (const SymbolContext &sc : sc_list) {
+    if (!first_module)
+      strm.EOL();
 
-  const uint32_t num_matches = sc_list.GetSize();
-
-  for (uint32_t i = 0; i < num_matches; ++i) {
-    SymbolContext sc;
-    if (sc_list.GetContextAtIndex(i, sc)) {
-      AddressRange range;
 
-      sc.GetAddressRange(eSymbolContextEverything, 0, true, range);
 
-      DumpAddress(exe_scope, range.GetBaseAddress(), verbose, all_ranges, strm);
-      if (i != (num_matches - 1))
-        strm.EOL();
-    }
+    first_module = false;
   }
   strm.IndentLess();
 }
 
 static size_t LookupFunctionInModule(CommandInterpreter &interpreter,
                                      Stream &strm, Module *module,
                                      const char *name, bool name_is_regex,
                                      const ModuleFunctionSearchOptions &options,
if (m_options.m_type == eLookupTypeFunctionOrSymbol) {
         }
       }
     } else {
       result.AppendError(
           "address-expression or function name option must be specified.");
       return false;
     }
 
-    size_t num_matches = sc_list.GetSize();
-    if (num_matches == 0) {
+    if (sc_list.GetSize() == 0) {
       result.AppendErrorWithFormat("no unwind data found that matches '%s'.",
                                    m_options.m_str.c_str());
       return false;
     }
 
-    for (uint32_t idx = 0; idx < num_matches; idx++) {
-      SymbolContext sc;
-      sc_list.GetContextAtIndex(idx, sc);
+    for (const SymbolContext &sc : sc_list) {
       if (sc.symbol == nullptr && sc.function == nullptr)
         continue;
       if (!sc.module_sp || sc.module_sp->GetObjectFile() == nullptr)
         continue;
       AddressRange range;
       if (!sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0,
                               false, range))
         continue;

lldb/source/Core/AddressResolverFileLine.cpp

AddressResolverFileLine::SearchCallback(SearchFilter &filter,
   SymbolContextList sc_list;
   CompileUnit *cu = context.comp_unit;
 
   Log *log = GetLog(LLDBLog::Breakpoints);
 
   // TODO: Handle SourceLocationSpec column information
   cu->ResolveSymbolContext(m_src_location_spec, eSymbolContextEverything,
                            sc_list);
-  uint32_t sc_list_size = sc_list.GetSize();
-  for (uint32_t i = 0; i < sc_list_size; i++) {
-    SymbolContext sc;
-    if (sc_list.GetContextAtIndex(i, sc)) {
-      Address line_start = sc.line_entry.range.GetBaseAddress();
-      addr_t byte_size = sc.line_entry.range.GetByteSize();
-      if (line_start.IsValid()) {
-        AddressRange new_range(line_start, byte_size);
-        m_address_ranges.push_back(new_range);
-      } else {
-        LLDB_LOGF(log,
-                  "error: Unable to resolve address at file address 0x%" PRIx64
-                  " for %s:%d\n",
-                  line_start.GetFileAddress(),
-                  m_src_location_spec.GetFileSpec().GetFilename().AsCString(
-                      "<Unknown>"),
-                  m_src_location_spec.GetLine().value_or(0));
-      }
-    }
-  }
+  for (const SymbolContext &sc : sc_list) {
   return Searcher::eCallbackReturnContinue;
 }
 
 lldb::SearchDepth AddressResolverFileLine::GetDepth() {
   return lldb::eSearchDepthCompUnit;
 }
 
 void AddressResolverFileLine::GetDescription(Stream *s) {
   s->Printf(
       "File and line address - file: \"%s\" line: %u",
       m_src_location_spec.GetFileSpec().GetFilename().AsCString("<Unknown>"),
       m_src_location_spec.GetLine().value_or(0));
 }

lldb/source/Core/SourceManager.cpp

if (target_sp) {
 
         ModuleFunctionSearchOptions function_options;
         function_options.include_symbols =
             false; // Force it to be a debug symbol.
         function_options.include_inlines = true;
         executable_ptr->FindFunctions(main_name, CompilerDeclContext(),
                                       lldb::eFunctionNameTypeBase,
                                       function_options, sc_list);
-        size_t num_matches = sc_list.GetSize();
-        for (size_t idx = 0; idx < num_matches; idx++) {
-          SymbolContext sc;
-          sc_list.GetContextAtIndex(idx, sc);
+        for (const SymbolContext &sc : sc_list) {
           if (sc.function) {
             lldb_private::LineEntry line_entry;
             if (sc.function->GetAddressRange()
                     .GetBaseAddress()
                     .CalculateSymbolContextLineEntry(line_entry)) {
               SetDefaultFileAndLine(line_entry.file, line_entry.line);
               file_spec = m_last_file_spec;
               line = m_last_line;
if (target) {
             target->GetImages().ResolveSymbolContextForFilePath(
                 file_spec.GetFilename().AsCString(), 0, check_inlines,
                 SymbolContextItem(eSymbolContextModule |
                                   eSymbolContextCompUnit),
                 sc_list);
         bool got_multiple = false;
         if (num_matches != 0) {
           if (num_matches > 1) {
-            SymbolContext sc;
             CompileUnit *test_cu = nullptr;
-
-            for (unsigned i = 0; i < num_matches; i++) {
-              sc_list.GetContextAtIndex(i, sc);
+            for (const SymbolContext &sc : sc_list) {
               if (sc.comp_unit) {
                 if (test_cu) {
                   if (test_cu != sc.comp_unit)
                     got_multiple = true;
                   break;
                 } else
                   test_cu = sc.comp_unit;
               }

lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

DynamicLoaderHexagonDYLD::GetStepThroughTrampolinePlan(Thread &thread,
   if (!sym_name)
     return thread_plan_sp;
 
   SymbolContextList target_symbols;
   Target &target = thread.GetProcess()->GetTarget();
   const ModuleList &images = target.GetImages();
 
   images.FindSymbolsWithNameAndType(sym_name, eSymbolTypeCode, target_symbols);
-  size_t num_targets = target_symbols.GetSize();
-  if (!num_targets)
+  if (target_symbols.GetSize() == 0)
     return thread_plan_sp;
 
   typedef std::vector<lldb::addr_t> AddressVector;
   AddressVector addrs;
-  for (size_t i = 0; i < num_targets; ++i) {
-    SymbolContext context;
+  for (const SymbolContext &context : target_symbols) {
     AddressRange range;
-    if (target_symbols.GetContextAtIndex(i, context)) {
-      context.GetAddressRange(eSymbolContextEverything, 0, false, range);
-      lldb::addr_t addr = range.GetBaseAddress().GetLoadAddress(&target);
-      if (addr != LLDB_INVALID_ADDRESS)
-        addrs.push_back(addr);
-    }
-  }
 
   if (addrs.size() > 0) {
     AddressVector::iterator start = addrs.begin();
     AddressVector::iterator end = addrs.end();
 
     llvm::sort(start, end);
     addrs.erase(std::unique(start, end), end);
     thread_plan_sp =

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

if (current_symbol->IsTrampoline()) {
           current_symbol->GetMangled().GetName(Mangled::ePreferMangled);
 
       if (trampoline_name) {
         const ModuleList &images = target_sp->GetImages();
 
         SymbolContextList code_symbols;
         images.FindSymbolsWithNameAndType(trampoline_name, eSymbolTypeCode,
                                           code_symbols);
-        size_t num_code_symbols = code_symbols.GetSize();
-
-        if (num_code_symbols > 0) {
-          for (uint32_t i = 0; i < num_code_symbols; i++) {
-            SymbolContext context;
-            AddressRange addr_range;
-            if (code_symbols.GetContextAtIndex(i, context)) {
-              context.GetAddressRange(eSymbolContextEverything, 0, false,
-                                      addr_range);
-              addresses.push_back(addr_range.GetBaseAddress());
-              if (log) {
-                addr_t load_addr =
-                    addr_range.GetBaseAddress().GetLoadAddress(target_sp.get());
+        for (const SymbolContext &context : code_symbols) {
 
-                LLDB_LOGF(log,
-                          "Found a trampoline target symbol at 0x%" PRIx64 ".",
-                          load_addr);
-              }
-            }
-          }
-        }
+            LLDB_LOGF(log, "Found a trampoline target symbol at 0x%" PRIx64 ".",
 
         SymbolContextList reexported_symbols;
         images.FindSymbolsWithNameAndType(
             trampoline_name, eSymbolTypeReExported, reexported_symbols);
-        size_t num_reexported_symbols = reexported_symbols.GetSize();
-        if (num_reexported_symbols > 0) {
-          for (uint32_t i = 0; i < num_reexported_symbols; i++) {
-            SymbolContext context;
-            if (reexported_symbols.GetContextAtIndex(i, context)) {
-              if (context.symbol) {
-                Symbol *actual_symbol =
-                    context.symbol->ResolveReExportedSymbol(*target_sp.get());
-                if (actual_symbol) {
-                  const Address actual_symbol_addr =
-                      actual_symbol->GetAddress();
-                  if (actual_symbol_addr.IsValid()) {
-                    addresses.push_back(actual_symbol_addr);
-                    if (log) {
-                      lldb::addr_t load_addr =
-                          actual_symbol_addr.GetLoadAddress(target_sp.get());
-                      LLDB_LOGF(
-                          log,
+        for (const SymbolContext &context : reexported_symbols) {
+              const Address actual_symbol_addr = actual_symbol->GetAddress();
+                  LLDB_LOGF(log,
                             "Found a re-exported symbol: %s at 0x%" PRIx64 ".",
                             actual_symbol->GetName().GetCString(), load_addr);
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
 
         SymbolContextList indirect_symbols;
         images.FindSymbolsWithNameAndType(trampoline_name, eSymbolTypeResolver,
                                           indirect_symbols);
-        size_t num_indirect_symbols = indirect_symbols.GetSize();
-        if (num_indirect_symbols > 0) {
-          for (uint32_t i = 0; i < num_indirect_symbols; i++) {
-            SymbolContext context;
-            AddressRange addr_range;
-            if (indirect_symbols.GetContextAtIndex(i, context)) {
-              context.GetAddressRange(eSymbolContextEverything, 0, false,
-                                      addr_range);
-              addresses.push_back(addr_range.GetBaseAddress());
-              if (log) {
-                addr_t load_addr =
-                    addr_range.GetBaseAddress().GetLoadAddress(target_sp.get());
+
+        for (const SymbolContext &context : indirect_symbols) {
 
-                LLDB_LOGF(log,
-                          "Found an indirect target symbol at 0x%" PRIx64 ".",
-                          load_addr);
-              }
-            }
-          }
-        }
-      }
+            LLDB_LOGF(log, "Found an indirect target symbol at 0x%" PRIx64 ".",
     } else if (current_symbol->GetType() == eSymbolTypeReExported) {
       // I am not sure we could ever end up stopped AT a re-exported symbol.
       // But just in case:
 
       const Symbol *actual_symbol =
           current_symbol->ResolveReExportedSymbol(*(target_sp.get()));
       if (actual_symbol) {
         Address target_addr(actual_symbol->GetAddress());

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

DynamicLoaderPOSIXDYLD::GetStepThroughTrampolinePlan(Thread &thread,
   if (!sym_name)
     return thread_plan_sp;
 
   SymbolContextList target_symbols;
   Target &target = thread.GetProcess()->GetTarget();
   const ModuleList &images = target.GetImages();
 
   images.FindSymbolsWithNameAndType(sym_name, eSymbolTypeCode, target_symbols);
-  size_t num_targets = target_symbols.GetSize();
-  if (!num_targets)
+  if (target_symbols.GetSize())
     return thread_plan_sp;
 
   typedef std::vector<lldb::addr_t> AddressVector;
   AddressVector addrs;
-  for (size_t i = 0; i < num_targets; ++i) {
-    SymbolContext context;
+  for (const SymbolContext &context : target_symbols) {
     AddressRange range;
-    if (target_symbols.GetContextAtIndex(i, context)) {
-      context.GetAddressRange(eSymbolContextEverything, 0, false, range);
-      lldb::addr_t addr = range.GetBaseAddress().GetLoadAddress(&target);
-      if (addr != LLDB_INVALID_ADDRESS)
-        addrs.push_back(addr);
-    }
-  }
 
   if (addrs.size() > 0) {
     AddressVector::iterator start = addrs.begin();
     AddressVector::iterator end = addrs.end();
 
     llvm::sort(start, end);
     addrs.erase(std::unique(start, end), end);
     thread_plan_sp =

lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

do {
     // class.
 
     SymbolContextList candidate_sc_list;
 
     m_target->GetImages().FindFunctions(selector_name,
                                         lldb::eFunctionNameTypeSelector,
                                         function_options, candidate_sc_list);
 
-    for (uint32_t ci = 0, ce = candidate_sc_list.GetSize(); ci != ce; ++ci) {
-      SymbolContext candidate_sc;
-
-      if (!candidate_sc_list.GetContextAtIndex(ci, candidate_sc))
-        continue;
-
+    for (const SymbolContext &candidate_sc : candidate_sc_list) {
       if (!candidate_sc.function)
         continue;
 
       const char *candidate_name = candidate_sc.function->GetName().AsCString();
 
       const char *cursor = candidate_name;
 
       if (*cursor != '+' && *cursor != '-')
for (const SymbolContext &candidate_sc : candidate_sc_list) {
       if (*cursor == ' ' || *cursor == '(')
         sc_list.Append(candidate_sc);
     }
   } while (false);
 
   if (sc_list.GetSize()) {
     // We found a good function symbol.  Use that.
 
-    for (uint32_t i = 0, e = sc_list.GetSize(); i != e; ++i) {
-      SymbolContext sc;
-
-      if (!sc_list.GetContextAtIndex(i, sc))
-        continue;
-
+    for (const SymbolContext &sc : sc_list) {
       if (!sc.function)
         continue;
 
       CompilerDeclContext function_decl_ctx = sc.function->GetDeclContext();
       if (!function_decl_ctx)
         continue;
 
       ObjCMethodDecl *method_decl =

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

addr_t ClangExpressionDeclMap::GetSymbolAddress(Target &target,
                                                 lldb_private::Module *module) {
   SymbolContextList sc_list;
 
   if (module)
     module->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
   else
     target.GetImages().FindSymbolsWithNameAndType(name, symbol_type, sc_list);
 
-  const uint32_t num_matches = sc_list.GetSize();
   addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
 
-  for (uint32_t i = 0;
-       i < num_matches &&
-       (symbol_load_addr == 0 || symbol_load_addr == LLDB_INVALID_ADDRESS);
-       i++) {
-    SymbolContext sym_ctx;
-    sc_list.GetContextAtIndex(i, sym_ctx);
+  for (const SymbolContext &sym_ctx : sc_list) {
+    if (symbol_load_addr != 0 || symbol_load_addr != LLDB_INVALID_ADDRESS)
+      break;
 
     const Address sym_address = sym_ctx.symbol->GetAddress();
 
     if (!sym_address.IsValid())
       continue;
 
     switch (sym_ctx.symbol->GetType()) {
     case eSymbolTypeCode:

 
 SymbolContextList ClangExpressionDeclMap::SearchFunctionsInSymbolContexts(
     const SymbolContextList &sc_list,
     const CompilerDeclContext &frame_decl_context) {
   // First, symplify things by looping through the symbol contexts to
   // remove unwanted functions and separate out the functions we want to
   // compare and prune into a separate list. Cache the info needed about
   // the function declarations in a vector for efficiency.
-  uint32_t num_indices = sc_list.GetSize();
   SymbolContextList sc_sym_list;
   std::vector<FuncDeclInfo> decl_infos;
-  decl_infos.reserve(num_indices);
+  decl_infos.reserve(sc_list.GetSize());
   clang::DeclContext *frame_decl_ctx =
       (clang::DeclContext *)frame_decl_context.GetOpaqueDeclContext();
   TypeSystemClang *ast = llvm::dyn_cast_or_null<TypeSystemClang>(
       frame_decl_context.GetTypeSystem());
 
-  for (uint32_t index = 0; index < num_indices; ++index) {
+  for (const SymbolContext &sym_ctx : sc_list) {
     FuncDeclInfo fdi;
-    SymbolContext sym_ctx;
-    sc_list.GetContextAtIndex(index, sym_ctx);
 
     // We don't know enough about symbols to compare them, but we should
     // keep them in the list.
     Function *function = sym_ctx.function;
     if (!function) {
       sc_sym_list.Append(sym_ctx);
       continue;
     }
if (frame_decl_context) {
       sc_list = SearchFunctionsInSymbolContexts(sc_list, frame_decl_context);
     }
   }
 
   if (sc_list.GetSize()) {
     Symbol *extern_symbol = nullptr;
     Symbol *non_extern_symbol = nullptr;
 
-    for (uint32_t index = 0, num_indices = sc_list.GetSize();
-         index < num_indices; ++index) {
-      SymbolContext sym_ctx;
-      sc_list.GetContextAtIndex(index, sym_ctx);
-
+    for (const SymbolContext &sym_ctx : sc_list) {
       if (sym_ctx.function) {
         CompilerDeclContext decl_ctx = sym_ctx.function->GetDeclContext();
 
         if (!decl_ctx)
           continue;
 
         // Filter out class/instance methods.
         if (decl_ctx.IsClassMethod())
           continue;
 
         AddOneFunction(context, sym_ctx.function, nullptr);
         context.m_found_function_with_type_info = true;
         context.m_found_function = true;
       } else if (sym_ctx.symbol) {
-        if (sym_ctx.symbol->GetType() == eSymbolTypeReExported && target) {
-          sym_ctx.symbol = sym_ctx.symbol->ResolveReExportedSymbol(*target);
-          if (sym_ctx.symbol == nullptr)
+        Symbol *symbol = sym_ctx.symbol;
+        if (target && symbol->GetType() == eSymbolTypeReExported) {
+          symbol = symbol->ResolveReExportedSymbol(*target);
+          if (symbol == nullptr)
             continue;
         }
 
-        if (sym_ctx.symbol->IsExternal())
-          extern_symbol = sym_ctx.symbol;
+        if (symbol->IsExternal())
+          extern_symbol = symbol;
         else
-          non_extern_symbol = sym_ctx.symbol;
+          non_extern_symbol = symbol;
       }
     }
 
     if (!context.m_found_function_with_type_info) {
       for (clang::NamedDecl *decl : decls_from_modules) {
         if (llvm::isa<clang::FunctionDecl>(decl)) {
           clang::NamedDecl *copied_decl =
               llvm::cast_or_null<FunctionDecl>(CopyDecl(decl));

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

if (lock) {
             if (response.GetHexByteString(symbol_name)) {
               if (symbol_name.empty())
                 return;
 
               addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
               lldb_private::SymbolContextList sc_list;
               process->GetTarget().GetImages().FindSymbolsWithNameAndType(
                   ConstString(symbol_name), eSymbolTypeAny, sc_list);
-              if (!sc_list.IsEmpty()) {
-                const size_t num_scs = sc_list.GetSize();
-                for (size_t sc_idx = 0;
-                     sc_idx < num_scs &&
-                     symbol_load_addr == LLDB_INVALID_ADDRESS;
-                     ++sc_idx) {
-                  SymbolContext sc;
-                  if (sc_list.GetContextAtIndex(sc_idx, sc)) {
-                    if (sc.symbol) {
-                      switch (sc.symbol->GetType()) {
-                      case eSymbolTypeInvalid:
-                      case eSymbolTypeAbsolute:
-                      case eSymbolTypeUndefined:
-                      case eSymbolTypeSourceFile:
-                      case eSymbolTypeHeaderFile:
-                      case eSymbolTypeObjectFile:
-                      case eSymbolTypeCommonBlock:
-                      case eSymbolTypeBlock:
-                      case eSymbolTypeLocal:
-                      case eSymbolTypeParam:
-                      case eSymbolTypeVariable:
-                      case eSymbolTypeVariableType:
-                      case eSymbolTypeLineEntry:
-                      case eSymbolTypeLineHeader:
-                      case eSymbolTypeScopeBegin:
-                      case eSymbolTypeScopeEnd:
-                      case eSymbolTypeAdditional:
-                      case eSymbolTypeCompiler:
-                      case eSymbolTypeInstrumentation:
-                      case eSymbolTypeTrampoline:
-                        break;
+              for (const SymbolContext &sc : sc_list) {
+                if (symbol_load_addr != LLDB_INVALID_ADDRESS)
+                  break;
 
-                      case eSymbolTypeCode:
-                      case eSymbolTypeResolver:
-                      case eSymbolTypeData:
-                      case eSymbolTypeRuntime:
-                      case eSymbolTypeException:
-                      case eSymbolTypeObjCClass:
-                      case eSymbolTypeObjCMetaClass:
-                      case eSymbolTypeObjCIVar:
-                      case eSymbolTypeReExported:
-                        symbol_load_addr =
-                            sc.symbol->GetLoadAddress(&process->GetTarget());
-                        break;
-                      }
-                    }
-                  }
-                }
-              }
               // This is the normal path where our symbol lookup was successful
               // and we want to send a packet with the new symbol value and see
               // if another lookup needs to be done.
 
               // Change "packet" to contain the requested symbol value and name
               packet.Clear();
               packet.PutCString("qSymbol:");
               if (symbol_load_addr != LLDB_INVALID_ADDRESS) {

lldb/source/Symbol/Symbol.cpp

if (module_sp) {
     // There should not be cycles in the reexport list, but we don't want to
     // crash if there are so make sure we haven't seen this before:
     if (!seen_modules.AppendIfNeeded(module_sp))
       return nullptr;
 
     lldb_private::SymbolContextList sc_list;
     module_sp->FindSymbolsWithNameAndType(reexport_name, eSymbolTypeAny,
                                           sc_list);
-    const size_t num_scs = sc_list.GetSize();
-    if (num_scs > 0) {
-      for (size_t i = 0; i < num_scs; ++i) {
-        lldb_private::SymbolContext sc;
-        if (sc_list.GetContextAtIndex(i, sc)) {
-          if (sc.symbol->IsExternal())
-            return sc.symbol;
-        }
-      }
-    }
+    for (const SymbolContext &sc : sc_list) {
     // If we didn't find the symbol in this module, it may be because this
     // module re-exports some whole other library.  We have to search those as
     // well:
     seen_modules.Append(module_sp);
 
     FileSpecList reexported_libraries =
         module_sp->GetObjectFile()->GetReExportedLibraries();
     size_t num_reexported_libraries = reexported_libraries.GetSize();

lldb/source/Symbol/SymbolContext.cpp

const Symbol *SymbolContext::FindBestGlobalDataSymbol(ConstString name,
   if (!target_sp) {
     return nullptr;
   }
 
   Target &target = *target_sp;
   Module *module = module_sp.get();
 
   auto ProcessMatches = [this, &name, &target,
-                         module](SymbolContextList &sc_list,
+                         module](const SymbolContextList &sc_list,
                                  Status &error) -> const Symbol * {
     llvm::SmallVector<const Symbol *, 1> external_symbols;
     llvm::SmallVector<const Symbol *, 1> internal_symbols;
-    const uint32_t matches = sc_list.GetSize();
-    for (uint32_t i = 0; i < matches; ++i) {
-      SymbolContext sym_ctx;
-      sc_list.GetContextAtIndex(i, sym_ctx);
+    for (const SymbolContext &sym_ctx : sc_list) {
       if (sym_ctx.symbol) {
         const Symbol *symbol = sym_ctx.symbol;
         const Address sym_address = symbol->GetAddress();
 
         if (sym_address.IsValid()) {
           switch (symbol->GetType()) {
           case eSymbolTypeData:
           case eSymbolTypeRuntime:

lldb/source/Symbol/UnwindTable.cpp

if (sect_extab.get()) {
       m_arm_unwind_up =
           std::make_unique<ArmUnwindInfo>(*object_file, sect, sect_extab);
     }
   }
 }
 
 UnwindTable::~UnwindTable() = default;
 
-std::optional<AddressRange> UnwindTable::GetAddressRange(const Address &addr,
-                                                         SymbolContext &sc) {
+std::optional<AddressRange>
+UnwindTable::GetAddressRange(const Address &addr, const SymbolContext &sc) {
   AddressRange range;
 
   // First check the unwind info from the object file plugin
   if (m_object_file_unwind_up &&
       m_object_file_unwind_up->GetAddressRange(addr, range))
     return range;
 
   // Check the symbol context
m_unwinds.insert(insert_pos,
                                   func_unwinder_sp));
   return func_unwinder_sp;
 }
 
 // Ignore any existing FuncUnwinders for this function, create a new one and
 // don't add it to the UnwindTable.  This is intended for use by target modules
 // show-unwind where we want to create new UnwindPlans, not re-use existing
 // ones.
-FuncUnwindersSP
-UnwindTable::GetUncachedFuncUnwindersContainingAddress(const Address &addr,
-                                                       SymbolContext &sc) {
+FuncUnwindersSP UnwindTable::GetUncachedFuncUnwindersContainingAddress(
+    const Address &addr, const SymbolContext &sc) {
   Initialize();
 
   auto range_or = GetAddressRange(addr, sc);
   if (!range_or)
     return nullptr;
 
   return std::make_shared<FuncUnwinders>(*this, *range_or);
 }