Make breakpoint names real entities.

When introduced, breakpoint names were just tags that you could
apply to breakpoints that would allow you to refer to a breakpoint
when you couldn't capture the ID, or to refer to a collection of
breakpoints.  

This change makes the names independent holders of breakpoint options
that you can then apply to breakpoints when you add the name to the
breakpoint.  It adds the "breakpoint name configure" command to set
up or reconfigure breakpoint names.  There is also full support for
then in the SB API, including a new SBBreakpointName class.

The connection between the name and the breakpoints
sharing the name remains live, so if you reconfigure the name, all the
breakpoint options all change as well.  This allows a quick way
to share complex breakpoint behavior among a bunch of breakpoints, and
a convenient way to iterate on the set.

You can also create a name from a breakpoint, allowing a quick way
to copy options from one breakpoint to another.

I also added the ability to make hidden and delete/disable protected
names.  When applied to a breakpoint, you will only be able to list,
delete or disable that breakpoint if you refer to it explicitly by ID.

This feature will allow GUI's that need to use breakpoints for their
own purposes to keep their breakpoints from getting accidentally 
disabled or deleted.

<rdar://problem/22094452>

llvm-svn: 313292

5 files changed, 283 insertions, 21 deletions

diff --git a/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/auto_continue/TestBreakpointAutoContinue.py b/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/auto_continue/TestBreakpointAutoContinue.py
index b1b37ae3817..9630e39e014 100644
--- a/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/auto_continue/TestBreakpointAutoContinue.py
+++ b/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/auto_continue/TestBreakpointAutoContinue.py
@@ -73,7 +73,7 @@ class BreakpointAutoContinue(TestBase):
         self.assertEqual(bkpt.GetHitCount(), 2, "Should have run through the breakpoint twice")
 
     def auto_continue_with_command(self):
-        bpno = self.make_target_and_bkpt("-N BKPT -d 'break modify --auto-continue 0 BKPT'")
+        bpno = self.make_target_and_bkpt("-N BKPT -C 'break modify --auto-continue 0 BKPT'")
         process = self.launch_it(lldb.eStateStopped)
         state = process.GetState()
         self.assertEqual(state, lldb.eStateStopped, "Process should be stopped")
diff --git a/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py b/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py
index cb4aeadbf93..386eafbb0b6 100644
--- a/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py
+++ b/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py
@@ -287,7 +287,7 @@ class BreakpointCommandTestCase(TestBase):
         # Add a breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.c", self.line, num_expected_locations=1, loc_exact=True,
-            extra_options='-d bt -d "thread list" -d continue')
+            extra_options='-C bt -C "thread list" -C continue')
 
         bkpt = target.FindBreakpointByID(1)
         self.assertTrue(bkpt.IsValid(), "Couldn't find breakpoint 1")
diff --git a/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py b/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py
index cc31ef80e8a..a758f76cc57 100644
--- a/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py
+++ b/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py
@@ -17,6 +17,7 @@ from lldbsuite.test import lldbutil
 class BreakpointNames(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     @add_test_categories(['pyapi'])
     def test_setting_names(self):
@@ -37,6 +38,25 @@ class BreakpointNames(TestBase):
         self.setup_target()
         self.do_check_using_names()
 
+    def test_configuring_names(self):
+        """Use Python APIs to test that configuring options on breakpoint names works correctly."""
+        self.build()
+        self.make_a_dummy_name()
+        self.setup_target()
+        self.do_check_configuring_names()
+
+    def test_configuring_permissions_sb(self):
+        """Use Python APIs to test that configuring permissions on names works correctly."""
+        self.build()
+        self.setup_target()
+        self.do_check_configuring_permissions_sb()
+
+    def test_configuring_permissions_cli(self):
+        """Use Python APIs to test that configuring permissions on names works correctly."""
+        self.build()
+        self.setup_target()
+        self.do_check_configuring_permissions_cli()
+
     def setup_target(self):
         exe = os.path.join(os.getcwd(), "a.out")
 
@@ -45,10 +65,35 @@ class BreakpointNames(TestBase):
         self.assertTrue(self.target, VALID_TARGET)
         self.main_file_spec = lldb.SBFileSpec(os.path.join(os.getcwd(), "main.c"))
         
+    def check_name_in_target(self, bkpt_name):
+        name_list = lldb.SBStringList()
+        self.target.GetBreakpointNames(name_list)
+        found_it = False
+        for name in name_list:
+            if name == bkpt_name:
+                found_it = True
+                break
+        self.assertTrue(found_it, "Didn't find the name %s in the target's name list:"%(bkpt_name))
+       
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
+        # These are the settings we're going to be putting into names & breakpoints:
+        self.bp_name_string = "ABreakpoint"
+        self.is_one_shot = True
+        self.ignore_count = 1000
+        self.condition = "1 == 2"
+        self.auto_continue = True
+        self.tid = 0xaaaa
+        self.tidx = 10
+        self.thread_name = "Fooey"
+        self.queue_name = "Blooey"
+        self.cmd_list = lldb.SBStringList()
+        self.cmd_list.AppendString("frame var")
+        self.cmd_list.AppendString("bt")
+
+
     def do_check_names(self):
         """Use Python APIs to check that we can set & retrieve breakpoint names"""
         bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
@@ -66,11 +111,15 @@ class BreakpointNames(TestBase):
         matches = bkpt.MatchesName("NotABreakpoint")
         self.assertTrue(not matches, "We matched a name we didn't set.")
 
+        # Make sure the name is also in the target:
+        self.check_name_in_target(bkpt_name)
+ 
         # Add another name, make sure that works too:
         bkpt.AddName(other_bkpt_name)
 
         matches = bkpt.MatchesName(bkpt_name)
         self.assertTrue(matches, "Adding a name means we didn't match the name we just set")
+        self.check_name_in_target(other_bkpt_name)
 
         # Remove the name and make sure we no longer match it:
         bkpt.RemoveName(bkpt_name)
@@ -89,26 +138,21 @@ class BreakpointNames(TestBase):
     def do_check_illegal_names(self):
         """Use Python APIs to check that we reject illegal names."""
         bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
-        success = bkpt.AddName("-CantStartWithADash")
-        self.assertTrue(not success,"We allowed a name starting with a dash.")
-
-        success = bkpt.AddName("1CantStartWithANumber")
-        self.assertTrue(not success, "We allowed a name starting with a number.")
-
-        success = bkpt.AddName("^CantStartWithNonAlpha")
-        self.assertTrue(not success, "We allowed a name starting with an ^.")
+        bad_names = ["-CantStartWithADash",
+                     "1CantStartWithANumber",
+                     "^CantStartWithNonAlpha",
+                     "CantHave-ADash",
+                     "Cant Have Spaces"]
+        for bad_name in bad_names:
+            success = bkpt.AddName(bad_name)
+            self.assertTrue(not success,"We allowed an illegal name: %s"%(bad_name))
+            bp_name = lldb.SBBreakpointName(self.target, bad_name)
+            self.assertFalse(bp_name.IsValid(), "We made a breakpoint name with an illegal name: %s"%(bad_name));
 
-        success = bkpt.AddName("CantHave-ADash")
-        self.assertTrue(not success, "We allowed a name with a dash in it.")
+            retval =lldb.SBCommandReturnObject()
+            self.dbg.GetCommandInterpreter().HandleCommand("break set -n whatever -N '%s'"%(bad_name), retval)
+            self.assertTrue(not retval.Succeeded(), "break set succeeded with: illegal name: %s"%(bad_name))
 
-        success = bkpt.AddName("Cant Have Spaces")
-        self.assertTrue(not success, "We allowed a name with spaces.")
-
-        # Check from the command line as well:
-        retval =lldb.SBCommandReturnObject()
-        self.dbg.GetCommandInterpreter().HandleCommand("break set -n whatever -N has-dashes", retval)
-        self.assertTrue(not retval.Succeeded(), "break set succeeded with: illegal name")
-        
     def do_check_using_names(self):
         """Use Python APIs to check names work in place of breakpoint ID's."""
         
@@ -133,9 +177,174 @@ class BreakpointNames(TestBase):
         self.assertTrue(not bkpt.IsEnabled(), "We didn't disable the breakpoint.")
 
         # Also make sure we don't apply commands to non-matching names:
-        self.dbg.GetCommandInterpreter().HandleCommand("break modify --one-shot 1 %s"%(bkpt_name), retval)
+        self.dbg.GetCommandInterpreter().HandleCommand("break modify --one-shot 1 %s"%(other_bkpt_name), retval)
         self.assertTrue(retval.Succeeded(), "break modify failed with: %s."%(retval.GetError()))
         self.assertTrue(not bkpt.IsOneShot(), "We applied one-shot to the wrong breakpoint.")
 
+    def check_option_values(self, bp_object):
+        self.assertEqual(bp_object.IsOneShot(), self.is_one_shot, "IsOneShot")
+        self.assertEqual(bp_object.GetIgnoreCount(), self.ignore_count, "IgnoreCount")
+        self.assertEqual(bp_object.GetCondition(), self.condition, "Condition")
+        self.assertEqual(bp_object.GetAutoContinue(), self.auto_continue, "AutoContinue")
+        self.assertEqual(bp_object.GetThreadID(), self.tid, "Thread ID")
+        self.assertEqual(bp_object.GetThreadIndex(), self.tidx, "Thread Index")
+        self.assertEqual(bp_object.GetThreadName(), self.thread_name, "Thread Name")
+        self.assertEqual(bp_object.GetQueueName(), self.queue_name, "Queue Name")
+        set_cmds = lldb.SBStringList()
+        bp_object.GetCommandLineCommands(set_cmds)
+        self.assertEqual(set_cmds.GetSize(), self.cmd_list.GetSize(), "Size of command line commands")
+        for idx in range(0, set_cmds.GetSize()):
+            self.assertEqual(self.cmd_list.GetStringAtIndex(idx), set_cmds.GetStringAtIndex(idx), "Command %d"%(idx))
+
+    def make_a_dummy_name(self):
+        "This makes a breakpoint name in the dummy target to make sure it gets copied over"
+
+        dummy_target = self.dbg.GetDummyTarget()
+        self.assertTrue(dummy_target.IsValid(), "Dummy target was not valid.")
+
+        def cleanup ():
+            self.dbg.GetDummyTarget().DeleteBreakpointName(self.bp_name_string)
+
+        # Execute the cleanup function during test case tear down.
+        self.addTearDownHook(cleanup)
+
+        # Now find it in the dummy target, and make sure these settings took:
+        bp_name = lldb.SBBreakpointName(dummy_target, self.bp_name_string)
+        # Make sure the name is right:
+        self.assertTrue (bp_name.GetName() == self.bp_name_string, "Wrong bp_name: %s"%(bp_name.GetName()))
+        bp_name.SetOneShot(self.is_one_shot)
+        bp_name.SetIgnoreCount(self.ignore_count)
+        bp_name.SetCondition(self.condition)
+        bp_name.SetAutoContinue(self.auto_continue)
+        bp_name.SetThreadID(self.tid)
+        bp_name.SetThreadIndex(self.tidx)
+        bp_name.SetThreadName(self.thread_name)
+        bp_name.SetQueueName(self.queue_name)
+        bp_name.SetCommandLineCommands(self.cmd_list)
+
+        # Now look it up again, and make sure it got set correctly.
+        bp_name = lldb.SBBreakpointName(dummy_target, self.bp_name_string)
+        self.assertTrue(bp_name.IsValid(), "Failed to make breakpoint name.")
+        self.check_option_values(bp_name)
+
+    def do_check_configuring_names(self):
+        """Use Python APIs to check that configuring breakpoint names works correctly."""
+        other_bp_name_string = "AnotherBreakpointName"
+        cl_bp_name_string = "CLBreakpointName"
+
+        # Now find the version copied in from the dummy target, and make sure these settings took:
+        bp_name = lldb.SBBreakpointName(self.target, self.bp_name_string)
+        self.assertTrue(bp_name.IsValid(), "Failed to make breakpoint name.")
+        self.check_option_values(bp_name)
+
+        # Now add this name to a breakpoint, and make sure it gets configured properly
+        bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
+        success = bkpt.AddName(self.bp_name_string)
+        self.assertTrue(success, "Couldn't add this name to the breakpoint")
+        self.check_option_values(bkpt)
+
+        # Now make a name from this breakpoint, and make sure the new name is properly configured:
+        new_name = lldb.SBBreakpointName(bkpt, other_bp_name_string)
+        self.assertTrue(new_name.IsValid(), "Couldn't make a valid bp_name from a breakpoint.")
+        self.check_option_values(bkpt)
+
+        # Now change the name's option and make sure it gets propagated to
+        # the breakpoint:
+        new_auto_continue = not self.auto_continue
+        bp_name.SetAutoContinue(new_auto_continue)
+        self.assertEqual(bp_name.GetAutoContinue(), new_auto_continue, "Couldn't change auto-continue on the name")
+        self.assertEqual(bkpt.GetAutoContinue(), new_auto_continue, "Option didn't propagate to the breakpoint.")
         
+        # Now make this same breakpoint name - but from the command line
+        cmd_str = "breakpoint name configure %s -o %d -i %d -c '%s' -G %d -t %d -x %d -T '%s' -q '%s'"%(cl_bp_name_string, 
+                                                                             self.is_one_shot, 
+                                                                             self.ignore_count, 
+                                                                             self.condition, 
+                                                                             self.auto_continue,
+                                                                             self.tid,
+                                                                             self.tidx,
+                                                                             self.thread_name,
+                                                                             self.queue_name)
+        for cmd in self.cmd_list:
+            cmd_str += " -C '%s'"%(cmd)
         
+        result = lldb.SBCommandReturnObject()
+        self.dbg.GetCommandInterpreter().HandleCommand(cmd_str, result)
+        self.assertTrue(result.Succeeded())
+        # Now look up this name again and check its options:
+        cl_name = lldb.SBBreakpointName(self.target, cl_bp_name_string)
+        self.check_option_values(cl_name)
+        
+        # We should have three names now, make sure the target can list them:
+        name_list = lldb.SBStringList()
+        self.target.GetBreakpointNames(name_list)
+        for name_string in [self.bp_name_string, other_bp_name_string, cl_bp_name_string]:
+            self.assertTrue(name_string in name_list, "Didn't find %s in names"%(name_string))
+
+        # Test that deleting the name we injected into the dummy target works (there's also a
+        # cleanup that will do this, but that won't test the result...
+        dummy_target = self.dbg.GetDummyTarget()
+        dummy_target.DeleteBreakpointName(self.bp_name_string)
+        name_list.Clear()
+        dummy_target.GetBreakpointNames(name_list)
+        self.assertTrue(self.bp_name_string not in name_list, "Didn't delete %s from the dummy target"%(self.bp_name_string))
+        
+    def check_permission_results(self, bp_name):
+        self.assertEqual(bp_name.GetAllowDelete(), False, "Didn't set allow delete.")
+        protected_bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
+        protected_id = protected_bkpt.GetID()
+
+        unprotected_bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
+        unprotected_id = unprotected_bkpt.GetID()
+
+        success = protected_bkpt.AddName(self.bp_name_string)
+        self.assertTrue(success, "Couldn't add this name to the breakpoint")
+
+        self.target.DisableAllBreakpoints()
+        self.assertEqual(protected_bkpt.IsEnabled(), True, "Didnt' keep breakpoint from being disabled")
+        self.assertEqual(unprotected_bkpt.IsEnabled(), False, "Protected too many breakpoints from disabling.")
+
+        # Try from the command line too:
+        unprotected_bkpt.SetEnabled(True)
+        result = lldb.SBCommandReturnObject()
+        self.dbg.GetCommandInterpreter().HandleCommand("break disable", result)
+        self.assertTrue(result.Succeeded())
+        self.assertEqual(protected_bkpt.IsEnabled(), True, "Didnt' keep breakpoint from being disabled")
+        self.assertEqual(unprotected_bkpt.IsEnabled(), False, "Protected too many breakpoints from disabling.")
+
+        self.target.DeleteAllBreakpoints()
+        bkpt = self.target.FindBreakpointByID(protected_id)
+        self.assertTrue(bkpt.IsValid(), "Didn't keep the breakpoint from being deleted.")
+        bkpt = self.target.FindBreakpointByID(unprotected_id)
+        self.assertFalse(bkpt.IsValid(), "Protected too many breakpoints from deletion.")
+
+        # Remake the unprotected breakpoint and try again from the command line:
+        unprotected_bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
+        unprotected_id = unprotected_bkpt.GetID()
+
+        self.dbg.GetCommandInterpreter().HandleCommand("break delete -f", result)
+        self.assertTrue(result.Succeeded())
+        bkpt = self.target.FindBreakpointByID(protected_id)
+        self.assertTrue(bkpt.IsValid(), "Didn't keep the breakpoint from being deleted.")
+        bkpt = self.target.FindBreakpointByID(unprotected_id)
+        self.assertFalse(bkpt.IsValid(), "Protected too many breakpoints from deletion.")
+
+    def do_check_configuring_permissions_sb(self):
+        bp_name = lldb.SBBreakpointName(self.target, self.bp_name_string)
+
+        # Make a breakpoint name with delete disallowed:
+        bp_name = lldb.SBBreakpointName(self.target, self.bp_name_string)
+        self.assertTrue(bp_name.IsValid(), "Failed to make breakpoint name for valid name.")
+
+        bp_name.SetAllowDelete(False)
+        bp_name.SetAllowDisable(False)
+        bp_name.SetAllowList(False)
+        self.check_permission_results(bp_name)
+
+    def do_check_configuring_permissions_cli(self):
+        # Make the name with the right options using the command line:
+        self.runCmd("breakpoint name configure -L 0 -D 0 -A 0 %s"%(self.bp_name_string), check=True)
+        # Now look up the breakpoint we made, and check that it works.
+        bp_name = lldb.SBBreakpointName(self.target, self.bp_name_string)
+        self.assertTrue(bp_name.IsValid(), "Didn't make a breakpoint name we could find.")
+        self.check_permission_results(bp_name)
diff --git a/lldb/packages/Python/lldbsuite/test/python_api/default-constructor/TestDefaultConstructorForAPIObjects.py b/lldb/packages/Python/lldbsuite/test/python_api/default-constructor/TestDefaultConstructorForAPIObjects.py
index bea9f5962d6..5c0c7bbd766 100644
--- a/lldb/packages/Python/lldbsuite/test/python_api/default-constructor/TestDefaultConstructorForAPIObjects.py
+++ b/lldb/packages/Python/lldbsuite/test/python_api/default-constructor/TestDefaultConstructorForAPIObjects.py
@@ -73,6 +73,17 @@ class APIDefaultConstructorTestCase(TestBase):
 
     @add_test_categories(['pyapi'])
     @no_debug_info_test
+    def test_SBBreakpointName(self):
+        obj = lldb.SBBreakpointName()
+        if self.TraceOn():
+            print(obj)
+        self.assertFalse(obj)
+        # Do fuzz testing on the invalid obj, it should not crash lldb.
+        import sb_breakpointname
+        sb_breakpointname.fuzz_obj(obj)
+
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
     def test_SBBroadcaster(self):
         obj = lldb.SBBroadcaster()
         if self.TraceOn():
diff --git a/lldb/packages/Python/lldbsuite/test/python_api/default-constructor/sb_breakpointname.py b/lldb/packages/Python/lldbsuite/test/python_api/default-constructor/sb_breakpointname.py
new file mode 100644
index 00000000000..56016c05c31
--- /dev/null
+++ b/lldb/packages/Python/lldbsuite/test/python_api/default-constructor/sb_breakpointname.py
@@ -0,0 +1,42 @@
+"""
+Fuzz tests an object after the default construction to make sure it does not crash lldb.
+"""
+
+import sys
+import lldb
+
+
+def fuzz_obj(obj):
+    obj.IsValid()
+    obj.GetName()
+    obj.SetEnabled(True)
+    obj.IsEnabled()
+    obj.SetOneShot(True)
+    obj.IsOneShot()
+    obj.SetIgnoreCount(1)
+    obj.GetIgnoreCount()
+    obj.SetCondition("1 == 2")
+    obj.GetCondition()
+    obj.SetAutoContinue(False)
+    obj.GetAutoContinue()
+    obj.SetThreadID(0x1234)
+    obj.GetThreadID()
+    obj.SetThreadIndex(10)
+    obj.GetThreadIndex()
+    obj.SetThreadName("AThread")
+    obj.GetThreadName()
+    obj.SetQueueName("AQueue")
+    obj.GetQueueName()
+    obj.SetScriptCallbackFunction("AFunction")
+    commands = lldb.SBStringList()
+    obj.SetCommandLineCommands(commands)
+    obj.GetCommandLineCommands(commands)
+    obj.SetScriptCallbackBody("Insert Python Code here")
+    obj.GetAllowList()
+    obj.SetAllowList(False)
+    obj.GetAllowDelete()
+    obj.SetAllowDelete(False)
+    obj.GetAllowDisable()
+    obj.SetAllowDisable(False)
+    stream = lldb.SBStream()
+    obj.GetDescription(stream)