[lldb][NFC] Remove strange bool parameter from Searcher::SearchCallback

[teemperor]

Summary

The SearchCallback has a bool parameter that we always set to false, we never use in any callback implementation and that also changes its name
from one file to the other (either containing and complete). It was added in the original LLDB check in, so there isn't any history what
this was supposed to be, so let's just remove it.

[teemperor]

I just realised the same is true for addr (beside that it is consistently named). I'll remove this too after this has landed.

[labath]

lol

[jingham]

One of the oddities of the Search -> Search callback stuff is that the Searcher's Filter might be narrower than the level at which the Search Callback wants to be invoked. The former is whatever the user actually wants limit the search to which is really undetermined, whereas the latter is the level that is convenient for implementing the callback, so there's no necessary linkage. That means that every time the callback finds a match, it has to check with the filter to see if the match falls within the filter. This parameter was supposed to be a way for the searcher to tell the callback that it's search scope exactly matched the filter, so the callback didn't need to check.

That would be useful if checking the filter ever showed up as a performance issue, but it never has. So it's fine to remove this.

[jingham]

I have no memory of adding the 'addr' parameter.

If you had a search that was guaranteed to only return one address per invocation, this would allow you to have the searcher coordinate gathering the results, rather than having the callback record them on its own. That might be another convenient usage pattern, but if we really wanted to do that we should have passed in a vector of addresses, since it seems hard to guarantee one-match per invocation. Since we've never actually wanted to handle searches this way, it seems fine to remove this parameter.

[teemperor]

Thanks for the explanation! Doesn't seem like removing this breaks Swift, so I'll land this.

lldb/include/lldb/Breakpoint/BreakpointResolverAddress.h

public:
   StructuredData::ObjectSP SerializeToStructuredData() override;
 
   void ResolveBreakpoint(SearchFilter &filter) override;
 
   void ResolveBreakpointInModules(SearchFilter &filter,
                                   ModuleList &modules) override;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) override;
+                                          SymbolContext &context,
+                                          Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
   void Dump(Stream *s) const override;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:

lldb/include/lldb/Breakpoint/BreakpointResolverFileLine.h

CreateFromStructuredData(Breakpoint *bkpt,
                            const StructuredData::Dictionary &data_dict,
                            Status &error);
 
   StructuredData::ObjectSP SerializeToStructuredData() override;
 
   ~BreakpointResolverFileLine() override;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) override;
+                                          SymbolContext &context,
+                                          Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
   void Dump(Stream *s) const override;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:

lldb/include/lldb/Breakpoint/BreakpointResolverFileRegex.h

CreateFromStructuredData(Breakpoint *bkpt,
                            const StructuredData::Dictionary &options_dict,
                            Status &error);
 
   StructuredData::ObjectSP SerializeToStructuredData() override;
 
   ~BreakpointResolverFileRegex() override;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) override;
+                                          SymbolContext &context,
+                                          Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
   void Dump(Stream *s) const override;
 
   void AddFunctionName(const char *func_name);

lldb/include/lldb/Breakpoint/BreakpointResolverName.h

CreateFromStructuredData(Breakpoint *bkpt,
                            const StructuredData::Dictionary &data_dict,
                            Status &error);
 
   StructuredData::ObjectSP SerializeToStructuredData() override;
 
   ~BreakpointResolverName() override;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) override;
+                                          SymbolContext &context,
+                                          Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
   void Dump(Stream *s) const override;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:

lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h

public:
   static BreakpointResolver *
   CreateFromStructuredData(Breakpoint *bkpt,
                            const StructuredData::Dictionary &options_dict,
                            Status &error);
 
   StructuredData::ObjectSP SerializeToStructuredData() override;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) override;
+                                          SymbolContext &context,
+                                          Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
   void Dump(Stream *s) const override;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:

lldb/include/lldb/Core/AddressResolverFileLine.h

 class AddressResolverFileLine : public AddressResolver {
 public:
   AddressResolverFileLine(const FileSpec &resolver, uint32_t line_no,
                           bool check_inlines);
 
   ~AddressResolverFileLine() override;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) override;
+                                          SymbolContext &context,
+                                          Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
 protected:
   FileSpec m_file_spec;   // This is the file spec we are looking for.
   uint32_t m_line_number; // This is the line number that we are looking for.

lldb/include/lldb/Core/AddressResolverName.h

public:
   AddressResolverName(RegularExpression func_regex);
 
   AddressResolverName(const char *class_name, const char *method,
                       AddressResolver::MatchType type);
 
   ~AddressResolverName() override;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) override;
+                                          SymbolContext &context,
+                                          Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
 protected:
   ConstString m_func_name;
   ConstString m_class_name; // FIXME: Not used yet.  The idea would be to stop

lldb/include/lldb/Core/FileLineResolver.h

FileLineResolver()
         m_sc_list(), m_inlines(true) {}
 
   FileLineResolver(const FileSpec &resolver, uint32_t line_no,
                    bool check_inlines);
 
   ~FileLineResolver() override;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) override;
+                                          SymbolContext &context,
+                                          Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
   const SymbolContextList &GetFileLineMatches() { return m_sc_list; }
 
   void Clear();

lldb/include/lldb/Core/SearchFilter.h

enum CallbackReturn {
     eCallbackReturnPop       // Pop one level up and continue iterating
   };
 
   Searcher();
 
   virtual ~Searcher();
 
   virtual CallbackReturn SearchCallback(SearchFilter &filter,
-                                        SymbolContext &context, Address *addr,
-                                        bool complete) = 0;
+                                        SymbolContext &context,
+                                        Address *addr) = 0;
 
   virtual lldb::SearchDepth GetDepth() = 0;
 
   /// Prints a canonical description for the searcher to the stream \a s.
   ///
   /// \param[in] s
   ///   Stream to which the output is copied.
   virtual void GetDescription(Stream *s);

lldb/include/lldb/Interpreter/CommandCompletions.h

public:
   // go along with the SearchFilter passed to the standard Completer functions.
   class Completer : public Searcher {
   public:
     Completer(CommandInterpreter &interpreter, CompletionRequest &request);
 
     ~Completer() override;
 
     CallbackReturn SearchCallback(SearchFilter &filter, SymbolContext &context,
-                                  Address *addr, bool complete) override = 0;
+                                  Address *addr) override = 0;
 
     lldb::SearchDepth GetDepth() override = 0;
 
     virtual void DoCompletion(SearchFilter *filter) = 0;
 
   protected:
     CommandInterpreter &m_interpreter;
     CompletionRequest &m_request;
 
   private:
     DISALLOW_COPY_AND_ASSIGN(Completer);
   };
 
   // SourceFileCompleter implements the source file completer
   class SourceFileCompleter : public Completer {
   public:
     SourceFileCompleter(CommandInterpreter &interpreter,
                         bool include_support_files, CompletionRequest &request);
 
     lldb::SearchDepth GetDepth() override;
 
     Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                             SymbolContext &context,
-                                            Address *addr,
-                                            bool complete) override;
+                                            Address *addr) override;
 
     void DoCompletion(SearchFilter *filter) override;
 
   private:
     bool m_include_support_files;
     FileSpecList m_matching_files;
     const char *m_file_name;
     const char *m_dir_name;
 
     DISALLOW_COPY_AND_ASSIGN(SourceFileCompleter);
   };
 
   // ModuleCompleter implements the module completer
   class ModuleCompleter : public Completer {
   public:
     ModuleCompleter(CommandInterpreter &interpreter,
                     CompletionRequest &request);
 
     lldb::SearchDepth GetDepth() override;
 
     Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                             SymbolContext &context,
-                                            Address *addr,
-                                            bool complete) override;
+                                            Address *addr) override;
 
     void DoCompletion(SearchFilter *filter) override;
 
   private:
     const char *m_file_name;
     const char *m_dir_name;
 
     DISALLOW_COPY_AND_ASSIGN(ModuleCompleter);
   };
 
   // SymbolCompleter implements the symbol completer
   class SymbolCompleter : public Completer {
   public:
     SymbolCompleter(CommandInterpreter &interpreter,
                     CompletionRequest &request);
 
     lldb::SearchDepth GetDepth() override;
 
     Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                             SymbolContext &context,
-                                            Address *addr,
-                                            bool complete) override;
+                                            Address *addr) override;
 
     void DoCompletion(SearchFilter *filter) override;
 
   private:
     RegularExpression m_regex;
     typedef std::set<ConstString> collection;
     collection m_match_set;
 

lldb/source/Breakpoint/BreakpointResolverAddress.cpp

if (m_addr.GetSection())
     re_resolve = true;
   else if (m_breakpoint->GetNumLocations() == 0)
     re_resolve = true;
 
   if (re_resolve)
     BreakpointResolver::ResolveBreakpointInModules(filter, modules);
 }
 
-Searcher::CallbackReturn
-BreakpointResolverAddress::SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) {
+Searcher::CallbackReturn BreakpointResolverAddress::SearchCallback(
+    SearchFilter &filter, SymbolContext &context, Address *addr) {
   assert(m_breakpoint != nullptr);
 
   if (filter.AddressPasses(m_addr)) {
     if (m_breakpoint->GetNumLocations() == 0) {
       // If the address is just an offset, and we're given a module, see if we
       // can find the appropriate module loaded in the binary, and fix up
       // m_addr to use that.
       if (!m_addr.IsSectionOffset() && m_module_filespec) {

lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

for(uint32_t i = 0; i < sc_list.GetSize(); ++i) {
     if (line && m_line_number < line - decl_line_is_too_late_fudge) {
       LLDB_LOG(log, "removing symbol context at {0}:{1}", file, line);
       sc_list.RemoveContextAtIndex(i);
       --i;
     }
   }
 }
 
-Searcher::CallbackReturn
-BreakpointResolverFileLine::SearchCallback(SearchFilter &filter,
-                                           SymbolContext &context,
-                                           Address *addr, bool containing) {
+Searcher::CallbackReturn BreakpointResolverFileLine::SearchCallback(
+    SearchFilter &filter, SymbolContext &context, Address *addr) {
   SymbolContextList sc_list;
 
   assert(m_breakpoint != nullptr);
 
   // There is a tricky bit here.  You can have two compilation units that
   // #include the same file, and in one of them the function at m_line_number
   // is used (and so code and a line entry for it is generated) but in the
   // other it isn't.  If we considered the CU's independently, then in the

lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp

for (std::string name : m_function_names) {
       names_array_sp->AddItem(item);
     }
     options_dict_sp->AddItem(GetKey(OptionNames::LineNumber), names_array_sp);
   }
 
   return WrapOptionsDict(options_dict_sp);
 }
 
-Searcher::CallbackReturn
-BreakpointResolverFileRegex::SearchCallback(SearchFilter &filter,
-                                            SymbolContext &context,
-                                            Address *addr, bool containing) {
+Searcher::CallbackReturn BreakpointResolverFileRegex::SearchCallback(
+    SearchFilter &filter, SymbolContext &context, Address *addr) {
 
   assert(m_breakpoint != nullptr);
   if (!context.target_sp)
     return eCallbackReturnContinue;
 
   CompileUnit *cu = context.comp_unit;
   FileSpec cu_file_spec = *(static_cast<FileSpec *>(cu));
   std::vector<uint32_t> line_matches;

lldb/source/Breakpoint/BreakpointResolverName.cpp

 // FIXME: Right now we look at the module level, and call the module's
 // "FindFunctions".
 // Greg says he will add function tables, maybe at the CompileUnit level to
 // accelerate function lookup.  At that point, we should switch the depth to
 // CompileUnit, and look in these tables.
 
 Searcher::CallbackReturn
 BreakpointResolverName::SearchCallback(SearchFilter &filter,
-                                       SymbolContext &context, Address *addr,
-                                       bool containing) {
+                                       SymbolContext &context, Address *addr) {
   SymbolContextList func_list;
   // SymbolContextList sym_list;
 
   uint32_t i;
   bool new_location;
   Address break_addr;
   assert(m_breakpoint != nullptr);
 

lldb/source/Breakpoint/BreakpointResolverScripted.cpp

options_dict_sp->AddStringItem(GetKey(OptionNames::PythonClassName),
                                    m_class_name);
   return WrapOptionsDict(options_dict_sp);
 }
 
 ScriptInterpreter *BreakpointResolverScripted::GetScriptInterpreter() {
   return m_breakpoint->GetTarget().GetDebugger().GetScriptInterpreter();
 }
 
-Searcher::CallbackReturn
-BreakpointResolverScripted::SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) {
+Searcher::CallbackReturn BreakpointResolverScripted::SearchCallback(
+    SearchFilter &filter, SymbolContext &context, Address *addr) {
   assert(m_breakpoint != nullptr);
   bool should_continue = true;
   if (!m_implementation_sp)
     return Searcher::eCallbackReturnStop;
   
   ScriptInterpreter *interp = GetScriptInterpreter();
   should_continue = interp->ScriptedBreakpointResolverSearchCallback(
       m_implementation_sp,

lldb/source/Commands/CommandCompletions.cpp

 
 lldb::SearchDepth CommandCompletions::SourceFileCompleter::GetDepth() {
   return lldb::eSearchDepthCompUnit;
 }
 
 Searcher::CallbackReturn
 CommandCompletions::SourceFileCompleter::SearchCallback(SearchFilter &filter,
                                                         SymbolContext &context,
-                                                        Address *addr,
-                                                        bool complete) {
+                                                        Address *addr) {
   if (context.comp_unit != nullptr) {
     if (m_include_support_files) {
       FileSpecList supporting_files = context.comp_unit->GetSupportFiles();
       for (size_t sfiles = 0; sfiles < supporting_files.GetSize(); sfiles++) {
         const FileSpec &sfile_spec =
             supporting_files.GetFileSpecAtIndex(sfiles);
         const char *sfile_file_name = sfile_spec.GetFilename().GetCString();
         const char *sfile_dir_name = sfile_spec.GetFilename().GetCString();
CommandCompletions::SymbolCompleter::SymbolCompleter(
   m_regex = RegularExpression(regex_str);
 }
 
 lldb::SearchDepth CommandCompletions::SymbolCompleter::GetDepth() {
   return lldb::eSearchDepthModule;
 }
 
 Searcher::CallbackReturn CommandCompletions::SymbolCompleter::SearchCallback(
-    SearchFilter &filter, SymbolContext &context, Address *addr,
-    bool complete) {
+    SearchFilter &filter, SymbolContext &context, Address *addr) {
   if (context.module_sp) {
     SymbolContextList sc_list;
     const bool include_symbols = true;
     const bool include_inlines = true;
     const bool append = true;
     context.module_sp->FindFunctions(m_regex, include_symbols, include_inlines,
                                      append, sc_list);
 
CommandCompletions::ModuleCompleter::ModuleCompleter(
   m_dir_name = partial_spec.GetDirectory().GetCString();
 }
 
 lldb::SearchDepth CommandCompletions::ModuleCompleter::GetDepth() {
   return lldb::eSearchDepthModule;
 }
 
 Searcher::CallbackReturn CommandCompletions::ModuleCompleter::SearchCallback(
-    SearchFilter &filter, SymbolContext &context, Address *addr,
-    bool complete) {
+    SearchFilter &filter, SymbolContext &context, Address *addr) {
   if (context.module_sp) {
     const char *cur_file_name =
         context.module_sp->GetFileSpec().GetFilename().GetCString();
     const char *cur_dir_name =
         context.module_sp->GetFileSpec().GetDirectory().GetCString();
 
     bool match = false;
     if (m_file_name && cur_file_name &&

lldb/source/Core/AddressResolverFileLine.cpp

AddressResolverFileLine::AddressResolverFileLine(const FileSpec &file_spec,
                                                  bool check_inlines)
     : AddressResolver(), m_file_spec(file_spec), m_line_number(line_no),
       m_inlines(check_inlines) {}
 
 AddressResolverFileLine::~AddressResolverFileLine() {}
 
 Searcher::CallbackReturn
 AddressResolverFileLine::SearchCallback(SearchFilter &filter,
-                                        SymbolContext &context, Address *addr,
-                                        bool containing) {
+                                        SymbolContext &context, Address *addr) {
   SymbolContextList sc_list;
   uint32_t sc_list_size;
   CompileUnit *cu = context.comp_unit;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 
   sc_list_size =
       cu->ResolveSymbolContext(m_file_spec, m_line_number, m_inlines, false,

lldb/source/Core/AddressResolverName.cpp

 // FIXME: Right now we look at the module level, and call the module's
 // "FindFunctions".
 // Greg says he will add function tables, maybe at the CompileUnit level to
 // accelerate function lookup.  At that point, we should switch the depth to
 // CompileUnit, and look in these tables.
 
 Searcher::CallbackReturn
 AddressResolverName::SearchCallback(SearchFilter &filter,
-                                    SymbolContext &context, Address *addr,
-                                    bool containing) {
+                                    SymbolContext &context, Address *addr) {
   SymbolContextList func_list;
   SymbolContextList sym_list;
 
   bool skip_prologue = true;
   uint32_t i;
   SymbolContext sc;
   Address func_addr;
 

lldb/source/Core/FileLineResolver.cpp

FileLineResolver::FileLineResolver(const FileSpec &file_spec, uint32_t line_no,
                                    bool check_inlines)
     : Searcher(), m_file_spec(file_spec), m_line_number(line_no),
       m_inlines(check_inlines) {}
 
 FileLineResolver::~FileLineResolver() {}
 
 Searcher::CallbackReturn
 FileLineResolver::SearchCallback(SearchFilter &filter, SymbolContext &context,
-                                 Address *addr, bool containing) {
+                                 Address *addr) {
   CompileUnit *cu = context.comp_unit;
 
   if (m_inlines ||
       m_file_spec.Compare(*cu, m_file_spec, (bool)m_file_spec.GetDirectory())) {
     uint32_t start_file_idx = 0;
     uint32_t file_idx =
         cu->GetSupportFiles().FindFileIndex(start_file_idx, m_file_spec, false);
     if (file_idx != UINT32_MAX) {

lldb/source/Core/SearchFilter.cpp

 void SearchFilter::Search(Searcher &searcher) {
   SymbolContext empty_sc;
 
   if (!m_target_sp)
     return;
   empty_sc.target_sp = m_target_sp;
 
   if (searcher.GetDepth() == lldb::eSearchDepthTarget)
-    searcher.SearchCallback(*this, empty_sc, nullptr, false);
+    searcher.SearchCallback(*this, empty_sc, nullptr);
   else
     DoModuleIteration(empty_sc, searcher);
 }
 
 void SearchFilter::SearchInModuleList(Searcher &searcher, ModuleList &modules) {
   SymbolContext empty_sc;
 
   if (!m_target_sp)
     return;
   empty_sc.target_sp = m_target_sp;
 
   if (searcher.GetDepth() == lldb::eSearchDepthTarget)
-    searcher.SearchCallback(*this, empty_sc, nullptr, false);
+    searcher.SearchCallback(*this, empty_sc, nullptr);
   else {
     std::lock_guard<std::recursive_mutex> guard(modules.GetMutex());
     const size_t numModules = modules.GetSize();
 
     for (size_t i = 0; i < numModules; i++) {
       ModuleSP module_sp(modules.GetModuleAtIndexUnlocked(i));
       if (ModulePasses(module_sp)) {
         if (DoModuleIteration(module_sp, searcher) ==

 
 Searcher::CallbackReturn
 SearchFilter::DoModuleIteration(const SymbolContext &context,
                                 Searcher &searcher) {
   if (searcher.GetDepth() >= lldb::eSearchDepthModule) {
     if (context.module_sp) {
       if (searcher.GetDepth() == lldb::eSearchDepthModule) {
         SymbolContext matchingContext(context.module_sp.get());
-        searcher.SearchCallback(*this, matchingContext, nullptr, false);
+        searcher.SearchCallback(*this, matchingContext, nullptr);
       } else {
         return DoCUIteration(context.module_sp, context, searcher);
       }
     } else {
       const ModuleList &target_images = m_target_sp->GetImages();
       std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex());
 
       size_t n_modules = target_images.GetSize();
       for (size_t i = 0; i < n_modules; i++) {
         // If this is the last level supplied, then call the callback directly,
         // otherwise descend.
         ModuleSP module_sp(target_images.GetModuleAtIndexUnlocked(i));
         if (!ModulePasses(module_sp))
           continue;
 
         if (searcher.GetDepth() == lldb::eSearchDepthModule) {
           SymbolContext matchingContext(m_target_sp, module_sp);
 
           Searcher::CallbackReturn shouldContinue =
-              searcher.SearchCallback(*this, matchingContext, nullptr, false);
+              searcher.SearchCallback(*this, matchingContext, nullptr);
           if (shouldContinue == Searcher::eCallbackReturnStop ||
               shouldContinue == Searcher::eCallbackReturnPop)
             return shouldContinue;
         } else {
           Searcher::CallbackReturn shouldContinue =
               DoCUIteration(module_sp, context, searcher);
           if (shouldContinue == Searcher::eCallbackReturnStop)
             return shouldContinue;
for (size_t i = 0; i < num_comp_units; i++) {
       if (cu_sp) {
         if (!CompUnitPasses(*(cu_sp.get())))
           continue;
 
         if (searcher.GetDepth() == lldb::eSearchDepthCompUnit) {
           SymbolContext matchingContext(m_target_sp, module_sp, cu_sp.get());
 
           shouldContinue =
-              searcher.SearchCallback(*this, matchingContext, nullptr, false);
+              searcher.SearchCallback(*this, matchingContext, nullptr);
 
           if (shouldContinue == Searcher::eCallbackReturnPop)
             return Searcher::eCallbackReturnContinue;
           else if (shouldContinue == Searcher::eCallbackReturnStop)
             return shouldContinue;
         } else {
           // First make sure this compile unit's functions are parsed
           // since CompUnit::ForeachFunction only iterates over already
           // parsed functions.
           SymbolFile *sym_file = module_sp->GetSymbolFile();
           if (!sym_file)
             continue;
           if (!sym_file->ParseFunctions(*cu_sp))
             continue;
           // If we got any functions, use ForeachFunction to do the iteration.
           cu_sp->ForeachFunction([&](const FunctionSP &func_sp) {
             if (!FunctionPasses(*func_sp.get()))
               return false; // Didn't pass the filter, just keep going.
             if (searcher.GetDepth() == lldb::eSearchDepthFunction) {
               SymbolContext matchingContext(m_target_sp, module_sp, 
                                             cu_sp.get(), func_sp.get());
-              shouldContinue = searcher.SearchCallback(*this, 
-                                                       matchingContext, 
-                                                       nullptr, false);
+              shouldContinue =
+                  searcher.SearchCallback(*this, matchingContext, nullptr);
             } else {
               shouldContinue = DoFunctionIteration(func_sp.get(), context, 
                                                    searcher);
             }
             return shouldContinue != Searcher::eCallbackReturnContinue;
           });
         }
       }
     }
   } else {
     if (CompUnitPasses(*context.comp_unit)) {
       SymbolContext matchingContext(m_target_sp, module_sp, context.comp_unit);
-      return searcher.SearchCallback(*this, matchingContext, nullptr, false);
+      return searcher.SearchCallback(*this, matchingContext, nullptr);
     }
   }
   return Searcher::eCallbackReturnContinue;
 }
 
 Searcher::CallbackReturn SearchFilter::DoFunctionIteration(
     Function *function, const SymbolContext &context, Searcher &searcher) {
   // FIXME: Implement...

 
 void SearchFilterByModule::Search(Searcher &searcher) {
   if (!m_target_sp)
     return;
 
   if (searcher.GetDepth() == lldb::eSearchDepthTarget) {
     SymbolContext empty_sc;
     empty_sc.target_sp = m_target_sp;
-    searcher.SearchCallback(*this, empty_sc, nullptr, false);
+    searcher.SearchCallback(*this, empty_sc, nullptr);
   }
 
   // If the module file spec is a full path, then we can just find the one
   // filespec that passes.  Otherwise, we need to go through all modules and
   // find the ones that match the file name.
 
   const ModuleList &target_modules = m_target_sp->GetImages();
   std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());

 
 void SearchFilterByModuleList::Search(Searcher &searcher) {
   if (!m_target_sp)
     return;
 
   if (searcher.GetDepth() == lldb::eSearchDepthTarget) {
     SymbolContext empty_sc;
     empty_sc.target_sp = m_target_sp;
-    searcher.SearchCallback(*this, empty_sc, nullptr, false);
+    searcher.SearchCallback(*this, empty_sc, nullptr);
   }
 
   // If the module file spec is a full path, then we can just find the one
   // filespec that passes.  Otherwise, we need to go through all modules and
   // find the ones that match the file name.
 
   const ModuleList &target_modules = m_target_sp->GetImages();
   std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());

 
 void SearchFilterByModuleListAndCU::Search(Searcher &searcher) {
   if (!m_target_sp)
     return;
 
   if (searcher.GetDepth() == lldb::eSearchDepthTarget) {
     SymbolContext empty_sc;
     empty_sc.target_sp = m_target_sp;
-    searcher.SearchCallback(*this, empty_sc, nullptr, false);
+    searcher.SearchCallback(*this, empty_sc, nullptr);
   }
 
   // If the module file spec is a full path, then we can just find the one
   // filespec that passes.  Otherwise, we need to go through all modules and
   // find the ones that match the file name.
 
   ModuleList matching_modules;
   const ModuleList &target_images = m_target_sp->GetImages();

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h

void GetDescription(Stream *strm) override {
     if (strm)
       strm->Printf("RenderScript kernel breakpoint for '%s'",
                    m_kernel_name.AsCString());
   }
 
   void Dump(Stream *s) const override {}
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) override;
+                                          SymbolContext &context,
+                                          Address *addr) override;
 
   lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; }
 
   lldb::BreakpointResolverSP
   CopyForBreakpoint(Breakpoint &breakpoint) override {
     lldb::BreakpointResolverSP ret_sp(
         new RSBreakpointResolver(&breakpoint, m_kernel_name));
     return ret_sp;
void GetDescription(Stream *strm) override {
     if (strm)
       strm->Printf("RenderScript reduce breakpoint for '%s'",
                    m_reduce_name.AsCString());
   }
 
   void Dump(Stream *s) const override {}
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) override;
+                                          SymbolContext &context,
+                                          Address *addr) override;
 
   lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; }
 
   lldb::BreakpointResolverSP
   CopyForBreakpoint(Breakpoint &breakpoint) override {
     lldb::BreakpointResolverSP ret_sp(new RSReduceBreakpointResolver(
         &breakpoint, m_reduce_name, m_rsmodules, m_kernel_types));
     return ret_sp;
void GetDescription(Stream *strm) override {
     if (strm)
       strm->Printf("RenderScript ScriptGroup breakpoint for '%s'",
                    m_group_name.AsCString());
   }
 
   void Dump(Stream *s) const override {}
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) override;
+                                          SymbolContext &context,
+                                          Address *addr) override;
 
   lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; }
 
   lldb::BreakpointResolverSP
   CopyForBreakpoint(Breakpoint &breakpoint) override {
     lldb::BreakpointResolverSP ret_sp(new RSScriptGroupBreakpointResolver(
         &breakpoint, m_group_name, m_script_groups, m_stop_on_all));
     return ret_sp;

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

 }
 
 // Callback with a module to search for matching symbols. We first check that
 // the module contains RS kernels. Then look for a symbol which matches our
 // kernel name. The breakpoint address is finally set using the address of this
 // symbol.
 Searcher::CallbackReturn
 RSBreakpointResolver::SearchCallback(SearchFilter &filter,
-                                     SymbolContext &context, Address *, bool) {
+                                     SymbolContext &context, Address *) {
   ModuleSP module = context.module_sp;
 
   if (!module || !IsRenderScriptScriptModule(module))
     return Searcher::eCallbackReturnContinue;
 
   // Attempt to set a breakpoint on the kernel name symbol within the module
   // library. If it's not found, it's likely debug info is unavailable - try to
   // set a breakpoint on <name>.expand.
RSBreakpointResolver::SearchCallback(SearchFilter &filter,
   }
 
   return Searcher::eCallbackReturnContinue;
 }
 
 Searcher::CallbackReturn
 RSReduceBreakpointResolver::SearchCallback(lldb_private::SearchFilter &filter,
                                            lldb_private::SymbolContext &context,
-                                           Address *, bool) {
+                                           Address *) {
   // We need to have access to the list of reductions currently parsed, as
   // reduce names don't actually exist as symbols in a module. They are only
   // identifiable by parsing the .rs.info packet, or finding the expand symbol.
   // We therefore need access to the list of parsed rs modules to properly
   // resolve reduction names.
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   ModuleSP module = context.module_sp;
 
for (const auto &reduction : module_desc->m_reductions) {
         }
       }
     }
   }
   return eCallbackReturnContinue;
 }
 
 Searcher::CallbackReturn RSScriptGroupBreakpointResolver::SearchCallback(
-    SearchFilter &filter, SymbolContext &context, Address *addr,
-    bool containing) {
+    SearchFilter &filter, SymbolContext &context, Address *addr) {
 
   if (!m_breakpoint)
     return eCallbackReturnContinue;
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   ModuleSP &module = context.module_sp;
 
   if (!module || !IsRenderScriptScriptModule(module))

lldb/source/Target/LanguageRuntime.cpp

ExceptionBreakpointResolver(lldb::LanguageType language, bool catch_bp,
                               bool throw_bp)
       : BreakpointResolver(nullptr, BreakpointResolver::ExceptionResolver),
         m_language(language), m_language_runtime(nullptr), m_catch_bp(catch_bp),
         m_throw_bp(throw_bp) {}
 
   ~ExceptionBreakpointResolver() override = default;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
-                                          SymbolContext &context, Address *addr,
-                                          bool containing) override {
+                                          SymbolContext &context,
+                                          Address *addr) override {
 
     if (SetActualResolver())
-      return m_actual_resolver_sp->SearchCallback(filter, context, addr,
-                                                  containing);
+      return m_actual_resolver_sp->SearchCallback(filter, context, addr);
     else
       return eCallbackReturnStop;
   }
 
   lldb::SearchDepth GetDepth() override {
     if (SetActualResolver())
       return m_actual_resolver_sp->GetDepth();
     else