Add "current" token for the -t option to "break set/modify"

[jingham]

Summary

It's fairly common to want to set a breakpoint that is limited to the current thread. For instance, if you hit function A on thread 1, then you want to set a breakpoint on function B but only when this thread hits it. You can do this in Python, but it should be simple to do this just from the command line. With this patch you can do:

break set -t current -n foo

or something like that.

This actually uses the thread from the ExecutionContext passed to the CommandObjectBreakpointSet::DoExecute, not the currently selected thread, so it will work in breakpoint commands as well as from the command line. That's the right thing to do.

[JDevlieghere]

Instead of using the token current, wouldn't it feel more natural to allow an empty value more natural? Would we reject that before we get to the option parsing code?

[jingham]

You can have options with optional values, but I don't favor using those. They have slightly odd behavior in the parser since you have to disambiguate them when they have a value, and them when they happen to be next to an argument. They aren't as easy to document, and just feel wrong to me. So I don't want to go with -t -n foo meaning the current thread.

lldb/source/Commands/CommandObjectBreakpoint.cpp

case 'o': {
       } else
         error.SetErrorStringWithFormat(
             "invalid boolean value '%s' passed for -o option",
             option_arg.str().c_str());
     } break;
     case 't': {
       lldb::tid_t thread_id = LLDB_INVALID_THREAD_ID;
       if (option_arg[0] != '\0') {
-        if (option_arg.getAsInteger(0, thread_id))
+        if (option_arg == "current") {
+          if (!execution_context) {
+            error.SetErrorStringWithFormat("No context to determine current "
+                                           "thread");
+          } else {
+            ThreadSP ctx_thread_sp = execution_context->GetThreadSP();
+            if (!ctx_thread_sp || !ctx_thread_sp->IsValid()) {
+              error.SetErrorStringWithFormat("No currently selected thread");
+            } else {
+              thread_id = ctx_thread_sp->GetID();
+            }
+          }
+        } else if (option_arg.getAsInteger(0, thread_id))
           error.SetErrorStringWithFormat("invalid thread id string '%s'",
                                          option_arg.str().c_str());
       }
       m_bp_opts.SetThreadID(thread_id);
     } break;
     case 'T':
       m_bp_opts.GetThreadSpec()->SetName(option_arg.str().c_str());
       break;

lldb/source/Commands/Options.td

let Command = "breakpoint modify" in {
   def breakpoint_modify_one_shot : Option<"one-shot", "o">, Group<1>,
     Arg<"Boolean">,
     Desc<"The breakpoint is deleted the first time it stop causes a stop.">;
   def breakpoint_modify_thread_index : Option<"thread-index", "x">, Group<1>,
     Arg<"ThreadIndex">, Desc<"The breakpoint stops only for the thread whose "
     "index matches this argument.">;
   def breakpoint_modify_thread_id : Option<"thread-id", "t">, Group<1>,
     Arg<"ThreadID">, Desc<"The breakpoint stops only for the thread whose TID "
-    "matches this argument.">;
+    "matches this argument.  The token 'current' resolves to the current thread's ID.">;
   def breakpoint_modify_thread_name : Option<"thread-name", "T">, Group<1>,
     Arg<"ThreadName">, Desc<"The breakpoint stops only for the thread whose "
     "thread name matches this argument.">;
   def breakpoint_modify_queue_name : Option<"queue-name", "q">, Group<1>,
     Arg<"QueueName">, Desc<"The breakpoint stops only for threads in the queue "
     "whose name is given by this argument.">;
   def breakpoint_modify_condition : Option<"condition", "c">, Group<1>,
     Arg<"Expression">, Desc<"The breakpoint stops only if this condition "

lldb/test/API/functionalities/thread/thread_specific_break/TestThreadSpecificBreakpoint.py

 """
 Test that we obey thread conditioned breakpoints.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
-def set_thread_id(thread, breakpoint):
+def using_current(test, thread, breakpoint):
+    bp_id = breakpoint.GetID()
+    test.runCmd("break modify -t current {0}".format(bp_id))
+    
+def set_thread_id(test, thread, breakpoint):
     id = thread.id
     breakpoint.SetThreadID(id)
 
-def set_thread_name(thread, breakpoint):
+def set_thread_name(test, thread, breakpoint):
     breakpoint.SetThreadName("main-thread")
 
 class ThreadSpecificBreakTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     @add_test_categories(['pyapi'])
 
     @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'armv7k'], bugnumber='rdar://problem/34563920') # armv7 ios problem - breakpoint with tid qualifier isn't working
     def test_thread_id(self):
         self.do_test(set_thread_id)
 
     @skipUnlessDarwin
     @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'armv7k'], bugnumber='rdar://problem/34563920') # armv7 ios problem - breakpoint with tid qualifier isn't working
     def test_thread_name(self):
         self.do_test(set_thread_name)
 
+    @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'armv7k'], bugnumber='rdar://problem/34563920') # armv7 ios problem - breakpoint with tid qualifier isn't working
+    def test_current_token(self):
+        self.do_test(using_current)
+
     def do_test(self, setter_method):
         """Test that we obey thread conditioned breakpoints."""
         self.build()
         main_source_spec = lldb.SBFileSpec("main.cpp")
         (target, process, main_thread, main_breakpoint) = lldbutil.run_to_source_breakpoint(self,
                 "Set main breakpoint here", main_source_spec)
 
         thread_breakpoint = target.BreakpointCreateBySourceRegex(
             "Set thread-specific breakpoint here", main_source_spec)
         self.assertGreater(
             thread_breakpoint.GetNumLocations(),
             0,
             "thread breakpoint has no locations associated with it.")
 
         # Set the thread-specific breakpoint to stop only on the main thread
         # before the secondary thread has a chance to execute it.  The main
         # thread joins the secondary thread, and then the main thread will
         # execute the code at the breakpoint.  If the thread-specific
         # breakpoint works, the next stop will be on the main thread.
-        setter_method(main_thread, thread_breakpoint)
+        setter_method(self, main_thread, thread_breakpoint)
 
         process.Continue()
         next_stop_state = process.GetState()
         self.assertEqual(
             next_stop_state,
             lldb.eStateStopped,
             "We should have stopped at the thread breakpoint.")
         stopped_threads = lldbutil.get_threads_stopped_at_breakpoint(