Make eSearchDepthFunction work for scripted resolvers

[jingham]

Summary

I hadn't needed eSearchDepthFunction for anything so it was stubbed out. Greg indicated he would be interested in using this for the scripted resolvers, so I got it to work with this patch. I also added tests to make sure the filters were doing the right thing for the Module, CU and Function depth searches.

[clayborg]

Very nice. You got it right.

lldb/trunk/include/lldb/Core/SearchFilter.h

public:
   ///    The CompileUnit to check against the filter.
   ///
   /// @return
   ///    \b true if \a Comp Unit passes, and \b false otherwise.
   //------------------------------------------------------------------
   virtual bool CompUnitPasses(CompileUnit &compUnit);
 
   //------------------------------------------------------------------
+  /// Call this method with a Function to see if \a function passes the
+  /// filter.
+  ///
+  /// @param[in] function
+  ///    The Functions to check against the filter.
+  ///
+  /// @return
+  ///    \b true if \a function passes, and \b false otherwise.
+  //------------------------------------------------------------------
+  virtual bool FunctionPasses(Function &function);
+
+  //------------------------------------------------------------------
   /// Call this method to do the search using the Searcher.
   ///
   /// @param[in] searcher
   ///    The searcher to drive with this search.
   ///
   //------------------------------------------------------------------
   virtual void Search(Searcher &searcher);
 

lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/TestScriptedResolver.py

def do_test(self):
         file_list.Clear()
         wrong = []
 
         # one with the wrong module - should not fire:
         module_list.Append(lldb.SBFileSpec("noSuchModule"))
         wrong.append(target.BreakpointCreateFromScript("resolver.Resolver", extra_args, module_list, file_list))
 
         # one with the wrong file - also should not fire:
+        file_list.Clear()
         module_list.Clear()
         file_list.Append(lldb.SBFileSpec("noFileOfThisName.xxx"))
         wrong.append(target.BreakpointCreateFromScript("resolver.Resolver", extra_args, module_list, file_list))
         
+        # Now make sure the CU level iteration obeys the file filters:
+        file_list.Clear()
+        module_list.Clear()
+        file_list.Append(lldb.SBFileSpec("no_such_file.xxx"))
+        wrong.append(target.BreakpointCreateFromScript("resolver.ResolverCUDepth", extra_args, module_list, file_list))
+
+        # And the Module filters:
+        file_list.Clear()
+        module_list.Clear()
+        module_list.Append(lldb.SBFileSpec("NoSuchModule.dylib"))
+        wrong.append(target.BreakpointCreateFromScript("resolver.ResolverCUDepth", extra_args, module_list, file_list))
+
+        # Now make sure the Function level iteration obeys the file filters:
+        file_list.Clear()
+        module_list.Clear()
+        file_list.Append(lldb.SBFileSpec("no_such_file.xxx"))
+        wrong.append(target.BreakpointCreateFromScript("resolver.ResolverFuncDepth", extra_args, module_list, file_list))
+
+        # And the Module filters:
+        file_list.Clear()
+        module_list.Clear()
+        module_list.Append(lldb.SBFileSpec("NoSuchModule.dylib"))
+        wrong.append(target.BreakpointCreateFromScript("resolver.ResolverFuncDepth", extra_args, module_list, file_list))
+
         # Make sure these didn't get locations:
         for i in range(0, len(wrong)):
             self.assertEqual(wrong[i].GetNumLocations(), 0, "Breakpoint %d has locations."%(i))
 
         # Now run to main and ensure we hit the breakpoints we should have:
 
         lldbutil.run_to_breakpoint_do_run(self, target, right[0])
         
def do_test_depths(self):
         self.assertTrue(bkpt.GetNumLocations() > 0, "ResolverCUDepth got no locations.")
         self.expect("script print resolver.Resolver.got_files", substrs=["1"], msg="Was passed compile units")
 
         # Make a breakpoint that returns a bad value - we should convert that to "modules" so check that:
         bkpt = target.BreakpointCreateFromScript("resolver.ResolverBadDepth", extra_args, module_list, file_list)
         self.assertTrue(bkpt.GetNumLocations() > 0, "ResolverBadDepth got no locations.")
         self.expect("script print resolver.Resolver.got_files", substrs=["2"], msg="Was only passed modules")
 
-        # Make a breakpoint that searches at function depth - FIXME: uncomment this when I fix the function
-        # depth search.
-        #bkpt = target.BreakpointCreateFromScript("resolver.ResolverFuncDepth", extra_args, module_list, file_list)
-        #self.assertTrue(bkpt.GetNumLocations() > 0, "ResolverFuncDepth got no locations.")
-        #self.expect("script print resolver.Resolver.got_files", substrs=["3"], msg="Was only passed modules")
-        #self.expect("script print resolver.Resolver.func_list", substrs=["break_on_me", "main", "test_func"], msg="Saw all the functions")
+        # Make a breakpoint that searches at function depth:
+        bkpt = target.BreakpointCreateFromScript("resolver.ResolverFuncDepth", extra_args, module_list, file_list)
+        self.assertTrue(bkpt.GetNumLocations() > 0, "ResolverFuncDepth got no locations.")
+        self.expect("script print resolver.Resolver.got_files", substrs=["3"], msg="Was only passed modules")
+        self.expect("script print resolver.Resolver.func_list", substrs=["break_on_me", "main", "test_func"], msg="Saw all the functions")
 
     def do_test_cli(self):
         target = self.make_target_and_import()
 
         lldbutil.run_break_set_by_script(self, "resolver.Resolver", extra_options="-k symbol -v break_on_me")

lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/resolver.py

def __callback__(self, sym_ctx):
       if sym_ctx.compile_unit.IsValid():
           Resolver.got_files = 1
       else:
           Resolver.got_files = 2
       
       if sym_ctx.function.IsValid():
         Resolver.got_files = 3
         func_name = sym_ctx.function.GetName()
-        print("got called with: ", func_name)
         Resolver.func_list.append(func_name)
         if sym_name == func_name:
-          self.bkpt.AddLocations(func.GetStartAddress())
+          self.bkpt.AddLocation(sym_ctx.function.GetStartAddress())
         return
 
       if sym_ctx.module.IsValid():
           sym = sym_ctx.module.FindSymbol(sym_name, lldb.eSymbolTypeCode)
           if sym.IsValid():
               self.bkpt.AddLocation(sym.GetStartAddress())
 
   def get_short_help(self):

lldb/trunk/source/Core/SearchFilter.cpp

 //===-- SearchFilter.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/SearchFilter.h"
 
 #include "lldb/Breakpoint/Breakpoint.h" // for Breakpoint
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h" // for ModuleList
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContext.h" // for SymbolContext
+#include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h" // for ConstString
 #include "lldb/Utility/Status.h"      // for Status
 #include "lldb/Utility/Stream.h"      // for Stream
 #include "lldb/lldb-enumerations.h"   // for SymbolContextItem::eSymbolCo...
 
 #include "llvm/ADT/StringRef.h"         // for StringRef
 #include "llvm/Support/ErrorHandling.h" // for llvm_unreachable

 bool SearchFilter::ModulePasses(const ModuleSP &module_sp) { return true; }
 
 bool SearchFilter::AddressPasses(Address &address) { return true; }
 
 bool SearchFilter::CompUnitPasses(FileSpec &fileSpec) { return true; }
 
 bool SearchFilter::CompUnitPasses(CompileUnit &compUnit) { return true; }
 
+bool SearchFilter::FunctionPasses(Function &function) {
+  // This is a slightly cheesy job, but since we don't have finer grained 
+  // filters yet, just checking that the start address passes is probably
+  // good enough for the base class behavior.
+  Address addr = function.GetAddressRange().GetBaseAddress();
+  return AddressPasses(addr);
+}
+
+
 uint32_t SearchFilter::GetFilterRequiredItems() {
   return (lldb::SymbolContextItem)0;
 }
 
 void SearchFilter::GetDescription(Stream *s) {}
 
 void SearchFilter::Dump(Stream *s) const {}
 
for (size_t i = 0; i < num_comp_units; i++) {
 
           shouldContinue =
               searcher.SearchCallback(*this, matchingContext, nullptr, false);
 
           if (shouldContinue == Searcher::eCallbackReturnPop)
             return Searcher::eCallbackReturnContinue;
           else if (shouldContinue == Searcher::eCallbackReturnStop)
             return shouldContinue;
-        } else if (searcher.GetDepth() == lldb::eSearchDepthFunction) {
-          // FIXME Descend to block.
+        } else {
+          // First make sure this compile unit's functions are parsed
+          // since CompUnit::ForeachFunction only iterates over already
+          // parsed functions.
+          SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
+          if (!sym_vendor)
+            continue;
+          SymbolContext sym_ctx;
+          cu_sp->CalculateSymbolContext(&sym_ctx);
+          if (!sym_vendor->ParseCompileUnitFunctions(sym_ctx))
+            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);
+            } 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);
     }