vendor/lldb/lldb-trunk-r351319

15 files changed, 498 insertions, 8 deletions

diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_by_line_and_column/Makefile b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_by_line_and_column/Makefile
new file mode 100644
index 000000000000..6c22351dc3b5
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_by_line_and_column/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+CFLAGS_EXTRAS += -std=c99 -gcolumn-info
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_by_line_and_column/TestBreakpointByLineAndColumn.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_by_line_and_column/TestBreakpointByLineAndColumn.py
new file mode 100644
index 000000000000..07032cc0380c
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_by_line_and_column/TestBreakpointByLineAndColumn.py
@@ -0,0 +1,48 @@
+"""
+Test setting a breakpoint by line and column.
+"""
+
+from __future__ import print_function
+
+
+import os
+import time
+import re
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class BreakpointByLineAndColumnTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    ## Skip gcc version less 7.1 since it doesn't support -gcolumn-info
+    @skipIf(compiler="gcc", compiler_version=['<', '7.1'])
+    def testBreakpointByLineAndColumn(self):
+        self.build()
+        main_c = lldb.SBFileSpec("main.c")
+        _, _, _, breakpoint = lldbutil.run_to_line_breakpoint(self,
+                                                              main_c, 20, 50)
+        self.expect("fr v did_call", substrs='1')
+        in_then = False
+        for i in range(breakpoint.GetNumLocations()):
+            b_loc = breakpoint.GetLocationAtIndex(i).GetAddress().GetLineEntry()
+            self.assertEqual(b_loc.GetLine(), 20)
+            in_then |= b_loc.GetColumn() == 50
+        self.assertTrue(in_then)
+
+    ## Skip gcc version less 7.1 since it doesn't support -gcolumn-info
+    @skipIf(compiler="gcc", compiler_version=['<', '7.1'])
+    def testBreakpointByLine(self):
+        self.build()
+        main_c = lldb.SBFileSpec("main.c")
+        _, _, _, breakpoint = lldbutil.run_to_line_breakpoint(self, main_c, 20)
+        self.expect("fr v did_call", substrs='0')
+        in_condition = False
+        for i in range(breakpoint.GetNumLocations()):
+            b_loc = breakpoint.GetLocationAtIndex(i).GetAddress().GetLineEntry()
+            self.assertEqual(b_loc.GetLine(), 20)
+            in_condition |= b_loc.GetColumn() < 30
+        self.assertTrue(in_condition)
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_by_line_and_column/main.c b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_by_line_and_column/main.c
new file mode 100644
index 000000000000..921bc382023f
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_by_line_and_column/main.c
@@ -0,0 +1,23 @@
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+int square(int x)
+{
+  return x * x;
+}
+
+int main (int argc, char const *argv[])
+{
+  int did_call = 0;
+
+  // Line 20.                                    v Column 50.
+  if(square(argc+1) != 0) { did_call = 1; return square(argc); }
+  //                                             ^
+  return square(0);
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py
index 7a2dc61b1b69..8143fa96433f 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py
@@ -25,7 +25,6 @@ class BreakpointCommandTestCase(TestBase):
         self.build()
         self.breakpoint_command_sequence()
 
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
     def test_script_parameters(self):
         """Test a sequence of breakpoint command add, list, and delete."""
         self.build()
@@ -45,7 +44,6 @@ class BreakpointCommandTestCase(TestBase):
         self.addTearDownHook(
             lambda: self.runCmd("settings clear auto-confirm"))
 
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
     def test_delete_all_breakpoints(self):
         """Test that deleting all breakpoints works."""
         self.build()
@@ -133,9 +131,9 @@ class BreakpointCommandTestCase(TestBase):
             patterns=[
                 "1: file = '.*main.c', line = %d, exact_match = 0, locations = 1" %
                 self.line,
-                "1.1: .+at main.c:%d, .+unresolved, hit count = 0" %
+                "1.1: .+at main.c:%d:?[0-9]*, .+unresolved, hit count = 0" %
                 self.line,
-                "2.1: .+at main.c:%d, .+unresolved, hit count = 0" %
+                "2.1: .+at main.c:%d:?[0-9]*, .+unresolved, hit count = 0" %
                 self.line])
 
         self.expect("breakpoint command list 1", "Breakpoint 1 command ok",
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py
index eb4bac7e6e66..e3bf4c27f31e 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py
@@ -18,12 +18,14 @@ class BreakpointIgnoreCountTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    @skipIfWindows # This test will hang on windows llvm.org/pr21753
     def test_with_run_command(self):
         """Exercise breakpoint ignore count with 'breakpoint set -i <count>'."""
         self.build()
         self.breakpoint_ignore_count()
 
     @add_test_categories(['pyapi'])
+    @skipIfWindows # This test will hang on windows llvm.org/pr21753
     def test_with_python_api(self):
         """Use Python APIs to set breakpoint ignore count."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/move_nearest/TestMoveNearest.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/move_nearest/TestMoveNearest.py
index 16d5bc75473c..b8281e9c85bd 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/move_nearest/TestMoveNearest.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/move_nearest/TestMoveNearest.py
@@ -18,6 +18,8 @@ class TestMoveNearest(TestBase):
         # Find the line number to break inside main().
         self.line1 = line_number('foo.h', '// !BR1')
         self.line2 = line_number('foo.h', '// !BR2')
+        self.line_between = line_number('main.cpp', "// BR_Between")
+        print("BR_Between found at", self.line_between)
         self.line_main = line_number('main.cpp', '// !BR_main')
 
     def test(self):
@@ -61,3 +63,7 @@ class TestMoveNearest(TestBase):
         # "return .."
         lldbutil.run_break_set_by_file_and_line(self, 'main.cpp',
                 self.line_main+2, extra_options="-m 1")
+
+        # Make sure we don't put move the breakpoint if it is set between two functions:
+        lldbutil.run_break_set_by_file_and_line(self, 'main.cpp',
+                self.line_between, extra_options="-m 1", num_expected_locations=0)
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/move_nearest/main.cpp b/packages/Python/lldbsuite/test/functionalities/breakpoint/move_nearest/main.cpp
index c9295a5c7d3c..76a22a5420fe 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/move_nearest/main.cpp
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/move_nearest/main.cpp
@@ -1,7 +1,7 @@
 #include "foo.h"
 
 int call_foo2() { return foo2(); }
-
+// BR_Between
 int
 main() // !BR_main
 {
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/Makefile b/packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/Makefile
new file mode 100644
index 000000000000..7934cd5db427
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/Makefile
@@ -0,0 +1,9 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+ifneq (,$(findstring icc,$(CC)))
+    CFLAGS += -debug inline-debug-info
+endif
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/TestRequireHWBreakpoints.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/TestRequireHWBreakpoints.py
new file mode 100644
index 000000000000..cda15fee84b8
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/TestRequireHWBreakpoints.py
@@ -0,0 +1,106 @@
+"""
+Test require hardware breakpoints.
+"""
+
+from __future__ import print_function
+
+import os
+import time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class BreakpointLocationsTestCase(TestBase):
+    NO_DEBUG_INFO_TESTCASE = True
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_breakpoint(self):
+        """Test regular breakpoints when hardware breakpoints are required."""
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        self.runCmd("settings set target.require-hardware-breakpoint true")
+
+        breakpoint = target.BreakpointCreateByLocation("main.c", 1)
+        self.assertTrue(breakpoint.IsHardware())
+
+    @skipIfWindows
+    def test_step_range(self):
+        """Test stepping when hardware breakpoints are required."""
+        self.build()
+
+        _, _, thread, _ = lldbutil.run_to_line_breakpoint(
+            self, lldb.SBFileSpec("main.c"), 1)
+
+        self.runCmd("settings set target.require-hardware-breakpoint true")
+
+        # Ensure we fail in the interpreter.
+        self.expect("thread step-in")
+        self.expect("thread step-in", error=True)
+
+        # Ensure we fail when stepping through the API.
+        error = lldb.SBError()
+        thread.StepInto('', 4, error)
+        self.assertTrue(error.Fail())
+        self.assertTrue("Could not create hardware breakpoint for thread plan"
+                        in error.GetCString())
+
+    @skipIfWindows
+    def test_step_out(self):
+        """Test stepping out when hardware breakpoints are required."""
+        self.build()
+
+        _, _, thread, _ = lldbutil.run_to_line_breakpoint(
+            self, lldb.SBFileSpec("main.c"), 1)
+
+        self.runCmd("settings set target.require-hardware-breakpoint true")
+
+        # Ensure this fails in the command interpreter.
+        self.expect("thread step-out", error=True)
+
+        # Ensure we fail when stepping through the API.
+        error = lldb.SBError()
+        thread.StepOut(error)
+        self.assertTrue(error.Fail())
+        self.assertTrue("Could not create hardware breakpoint for thread plan"
+                        in error.GetCString())
+
+    @skipIfWindows
+    def test_step_over(self):
+        """Test stepping over when hardware breakpoints are required."""
+        self.build()
+
+        _, _, thread, _ = lldbutil.run_to_line_breakpoint(
+            self, lldb.SBFileSpec("main.c"), 7)
+
+        self.runCmd("settings set target.require-hardware-breakpoint true")
+
+        # Step over doesn't fail immediately but fails later on.
+        self.expect("thread step-over")
+        self.expect(
+            "process status",
+            substrs=[
+                'step over failed',
+                'Could not create hardware breakpoint for thread plan'
+            ])
+
+    @skipIfWindows
+    def test_step_until(self):
+        """Test stepping until when hardware breakpoints are required."""
+        self.build()
+
+        _, _, thread, _ = lldbutil.run_to_line_breakpoint(
+            self, lldb.SBFileSpec("main.c"), 7)
+
+        self.runCmd("settings set target.require-hardware-breakpoint true")
+
+        self.expect("thread until 5", error=True)
+
+        # Ensure we fail when stepping through the API.
+        error = thread.StepOverUntil(lldb.SBFrame(), lldb.SBFileSpec(), 5)
+        self.assertTrue(error.Fail())
+        self.assertTrue("Could not create hardware breakpoint for thread plan"
+                        in error.GetCString())
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/main.c b/packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/main.c
new file mode 100644
index 000000000000..7d49a57d4c7b
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/main.c
@@ -0,0 +1,9 @@
+int break_on_me() {
+  int i = 10;
+  i++;
+  return i;
+}
+
+int main() {
+  return break_on_me();
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/Makefile b/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/Makefile
new file mode 100644
index 000000000000..6067ee45e984
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+CFLAGS_EXTRAS += -std=c99
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/TestScriptedResolver.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/TestScriptedResolver.py
new file mode 100644
index 000000000000..0eb9033e754b
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/TestScriptedResolver.py
@@ -0,0 +1,199 @@
+"""
+Test setting breakpoints using a scripted resolver
+"""
+
+from __future__ import print_function
+
+
+import os
+import time
+import re
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+
+
+class TestScriptedResolver(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
+    def test_scripted_resolver(self):
+        """Use a scripted resolver to set a by symbol name breakpoint"""
+        self.build()
+        self.do_test()
+
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
+    def test_search_depths(self):
+        """ Make sure we are called at the right depths depending on what we return
+            from __get_depth__"""
+        self.build()
+        self.do_test_depths()
+
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
+    def test_command_line(self):
+        """ Make sure we are called at the right depths depending on what we return
+            from __get_depth__"""
+        self.build()
+        self.do_test_cli()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+    def make_target_and_import(self):
+        target = lldbutil.run_to_breakpoint_make_target(self)
+        interp = self.dbg.GetCommandInterpreter()
+        error = lldb.SBError()
+
+        script_name = os.path.join(self.getSourceDir(), "resolver.py")
+        source_name = os.path.join(self.getSourceDir(), "main.c")
+
+        command = "command script import " + script_name
+        result = lldb.SBCommandReturnObject()
+        interp.HandleCommand(command, result)
+        self.assertTrue(result.Succeeded(), "com scr imp failed: %s"%(result.GetError()))
+        return target
+
+    def make_extra_args(self):
+        json_string = '{"symbol":"break_on_me", "test1": "value1"}'
+        json_stream = lldb.SBStream()
+        json_stream.Print(json_string)
+        extra_args = lldb.SBStructuredData()
+        error = extra_args.SetFromJSON(json_stream)
+        self.assertTrue(error.Success(), "Error making SBStructuredData: %s"%(error.GetCString()))
+        return extra_args
+
+    def do_test(self):
+        """This reads in a python file and sets a breakpoint using it."""
+
+        target = self.make_target_and_import()
+        extra_args = self.make_extra_args()
+
+        file_list = lldb.SBFileSpecList()
+        module_list = lldb.SBFileSpecList()
+
+        # Make breakpoints with this resolver using different filters, first ones that will take:
+        right = []
+        # one with no file or module spec - this one should fire:
+        right.append(target.BreakpointCreateFromScript("resolver.Resolver", extra_args, module_list, file_list))
+
+        # one with the right source file and no module - should also fire:
+        file_list.Append(lldb.SBFileSpec("main.c"))
+        right.append(target.BreakpointCreateFromScript("resolver.Resolver", extra_args, module_list, file_list))
+        # Make sure the help text shows up in the "break list" output:
+        self.expect("break list", substrs=["I am a python breakpoint resolver"], msg="Help is listed in break list")
+
+        # one with the right source file and right module - should also fire:
+        module_list.Append(lldb.SBFileSpec("a.out"))
+        right.append(target.BreakpointCreateFromScript("resolver.Resolver", extra_args, module_list, file_list))
+
+        # And one with no source file but the right module:
+        file_list.Clear()
+        right.append(target.BreakpointCreateFromScript("resolver.Resolver", extra_args, module_list, file_list))
+
+        # Make sure these all got locations:
+        for i in range (0, len(right)):
+            self.assertTrue(right[i].GetNumLocations() >= 1, "Breakpoint %d has no locations."%(i))
+
+        # Now some ones that won't take:
+
+        module_list.Clear()
+        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])
+        
+        # Test the hit counts:
+        for i in range(0, len(right)):
+            self.assertEqual(right[i].GetHitCount(), 1, "Breakpoint %d has the wrong hit count"%(i))
+
+        for i in range(0, len(wrong)):
+            self.assertEqual(wrong[i].GetHitCount(), 0, "Breakpoint %d has the wrong hit count"%(i))
+
+    def do_test_depths(self):
+        """This test uses a class variable in resolver.Resolver which gets set to 1 if we saw
+           compile unit and 2 if we only saw modules.  If the search depth is module, you get passed just
+           the modules with no comp_unit.  If the depth is comp_unit you get comp_units.  So we can use
+           this to test that our callback gets called at the right depth."""
+
+        target = self.make_target_and_import()
+        extra_args = self.make_extra_args()
+
+        file_list = lldb.SBFileSpecList()
+        module_list = lldb.SBFileSpecList()
+        module_list.Append(lldb.SBFileSpec("a.out"))
+
+        # Make a breakpoint that has no __get_depth__, check that that is converted to eSearchDepthModule:
+        bkpt = target.BreakpointCreateFromScript("resolver.Resolver", extra_args, module_list, file_list)
+        self.assertTrue(bkpt.GetNumLocations() > 0, "Resolver got no locations.")
+        self.expect("script print resolver.Resolver.got_files", substrs=["2"], msg="Was only passed modules")
+        
+        # Make a breakpoint that asks for modules, check that we didn't get any files:
+        bkpt = target.BreakpointCreateFromScript("resolver.ResolverModuleDepth", extra_args, module_list, file_list)
+        self.assertTrue(bkpt.GetNumLocations() > 0, "ResolverModuleDepth got no locations.")
+        self.expect("script print resolver.Resolver.got_files", substrs=["2"], msg="Was only passed modules")
+        
+        # Make a breakpoint that asks for compile units, check that we didn't get any files:
+        bkpt = target.BreakpointCreateFromScript("resolver.ResolverCUDepth", extra_args, module_list, file_list)
+        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:
+        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")
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/main.c b/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/main.c
new file mode 100644
index 000000000000..b91ccfc1b43e
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/main.c
@@ -0,0 +1,21 @@
+#include <stdio.h>
+
+int
+test_func()
+{
+  return printf("I am a test function.");
+}
+
+void
+break_on_me()
+{
+  printf("I was called.\n");
+}
+
+int
+main()
+{
+  break_on_me();
+  test_func();
+  return 0;
+}
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/resolver.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/resolver.py
new file mode 100644
index 000000000000..61f5f2df20ac
--- /dev/null
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/scripted_bkpt/resolver.py
@@ -0,0 +1,54 @@
+import lldb
+
+class Resolver:
+  got_files = 0
+  func_list = []
+
+  def __init__(self, bkpt, extra_args, dict):
+      self.bkpt = bkpt
+      self.extra_args = extra_args
+      Resolver.func_list = []
+      Resolver.got_files = 0
+
+  def __callback__(self, sym_ctx):
+      sym_name = "not_a_real_function_name"
+      sym_item = self.extra_args.GetValueForKey("symbol")
+      if sym_item.IsValid():
+          sym_name = sym_item.GetStringValue(1000)
+
+      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()
+        Resolver.func_list.append(func_name)
+        if sym_name == func_name:
+          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):
+      return "I am a python breakpoint resolver"
+
+class ResolverModuleDepth(Resolver):
+    def __get_depth__ (self):
+        return lldb.eSearchDepthModule
+
+class ResolverCUDepth(Resolver):
+    def __get_depth__ (self):
+        return lldb.eSearchDepthCompUnit
+
+class ResolverFuncDepth(Resolver):
+    def __get_depth__ (self):
+        return lldb.eSearchDepthFunction
+
+class ResolverBadDepth(Resolver):
+    def __get_depth__ (self):
+        return lldb.kLastSearchDepthKind + 1
diff --git a/packages/Python/lldbsuite/test/functionalities/breakpoint/serialize/TestBreakpointSerialization.py b/packages/Python/lldbsuite/test/functionalities/breakpoint/serialize/TestBreakpointSerialization.py
index c615278e8d48..943998a421be 100644
--- a/packages/Python/lldbsuite/test/functionalities/breakpoint/serialize/TestBreakpointSerialization.py
+++ b/packages/Python/lldbsuite/test/functionalities/breakpoint/serialize/TestBreakpointSerialization.py
@@ -180,7 +180,8 @@ class BreakpointSerialization(TestBase):
         # actually have locations.
         source_bps = lldb.SBBreakpointList(self.orig_target)
 
-        bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666)
+        bkpt = self.orig_target.BreakpointCreateByLocation(
+            lldb.SBFileSpec("blubby.c"), 666, 333, 0, lldb.SBFileSpecList())
         bkpt.SetEnabled(False)
         bkpt.SetOneShot(True)
         bkpt.SetThreadID(10)
@@ -226,7 +227,8 @@ class BreakpointSerialization(TestBase):
         all_bps = lldb.SBBreakpointList(self.orig_target)
         source_bps = lldb.SBBreakpointList(self.orig_target)
 
-        bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666)
+        bkpt = self.orig_target.BreakpointCreateByLocation(
+            lldb.SBFileSpec("blubby.c"), 666, 333, 0, lldb.SBFileSpecList())
         bkpt.SetEnabled(False)
         bkpt.SetOneShot(True)
         bkpt.SetThreadID(10)
@@ -260,7 +262,8 @@ class BreakpointSerialization(TestBase):
         self.check_equivalence(all_bps)
 
     def do_check_names(self):
-        bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666)
+        bkpt = self.orig_target.BreakpointCreateByLocation(
+            lldb.SBFileSpec("blubby.c"), 666, 333, 0, lldb.SBFileSpecList())
         good_bkpt_name = "GoodBreakpoint"
         write_bps = lldb.SBBreakpointList(self.orig_target)
         bkpt.AddName(good_bkpt_name)