Add --auto-continue to stop-hooks, fix up a few tests

[jingham]

Summary

Auto-continuing a stop hook by adding a "continue" command to the hook didn't work very well for multi-threaded programs. The first hook in kept all the others from running, so the behavior was unpredictable.

Also, the stop hooks were running in synchronous mode, which meant that 'continue' in a stop hook would start nesting hook execution, which they were not designed to do.

This patch forces Async execution for the stop-hooks, and adds an auto-continue flag.

I also made it possible to add more than one command at a time to the stop hook by repeating the -o command. I can't remember why I thought it was a good idea originally to have only ONE --one-liner option here & in breakpoint commands, etc. It's really convenient to be able to build these on a single line.

Also fixed up a few tests. The plain stop-hook tests were failing for me, even though I didn't change any relevant output. Adding the 'interpreter.echo-comment-commands false' made them start passing again...

I didn't uncomment the UNSUPPORTED on Linux for stop-hook-threads.test, I'd appreciate somebody giving this a whirl there first to see if this works now.

[jingham]

I wasn't using the right %lldb when running the tests. That provides the 'echo-comment-commands false'. Run correctly you don't need the command in the test files.

[labath]

Thank you for jumping onto this. I've tried the patch out on linux, and the stop-hook-threads.test now passes. However, the basic test now fails for me because the stop hook isn't fired in the "run" command. it is caused by the "is hijacked" check in ProcessEventData::DoOnRemoval, as removing that condition causes to hook to fire, but that's probably not the right thing to do here. The difference here is probably caused by PlatformLinux hijacking the process events during the launch sequence https://github.com/llvm-mirror/lldb/blob/76c0545e7f24cd6636df61292472df64cfa2900e/source/Plugins/Platform/Linux/PlatformLinux.cpp#L337, but I am not sure where is the error here. I definitely know that there is something fishy going on in PlatformLinux, as e.g. we don't get a "Process XXX stopped" message when launching with the --stop-at-entry flag, so it's quite possible the error is there. If you think that the general behavior is right there, then we can just XFAIL this test for linux, and one of us will get to fixing PlatformLinux eventually.

lit/ExecControl/StopHook/stop-hook-threads.test

31–33

BTW, this check is fairly dodgy, because in the case of two threads hitting a breakpoint simultaneously, we will get 4 stop reasons instead of two ("thread list" will be executed twice, and each instance will print the stop reason for both threads). It might be better to replace "thread list" with a different command, or add synchronization to the test to prevent two threads from hitting the breakpoint at once, depending on what we want to test.

[jingham]

Trying to guess how thread list output is going to look is indeed a losing game.

I changed the stop hook to set a global variable in the target, then just print the value at the end. If we ran the stop hook the right number of times, the variable will have the right value.

[jingham]

Pavel, I think the new behavior w.r.t. launching is better. When the process plugins are managing events to handle a launch or attach, they really don't want random stop hooks getting in their way. On MacOS, if you set a stop hook before launch you always got one stop message at a place you didn't cause the target to stop, which I think was just confusing.

lit/ExecControl/StopHook/stop-hook-threads.test

31–33

Yes, trying to make a good test scraping thread list output is no good. Instead I made the stop-hook set a variable in the target. Then we can just check that value to see if we hit and ran the stop hooks the right number of times.

[labath]

Ok, LGTM in that case. In terms of the linux decorators, I guess this means that the "unsupported" decorator can be removed on the threaded version of the test, and an "XFAIL" needs to be added to the non-threaded one.

[jingham]

Is this the right way to do it? I don't know why the other was UNSUPPORTED: linux. The only other XFAIL for linux I could see spelled it -linux-?

[labath]

It seems both linux and system-linux work. I am not sure what's the difference between the two, but it looks like for other OSs we use the system- form, so I'd go with that.

[jankratochvil]

Getting now failure for every run:

LLDB :: ExecControl/StopHook/stop-hook.test

http://lab.llvm.org:8014/buildslaves/lldb-x86_64-fedora

[labath]

I'm not sure why you ended up reverting this, but it looks like the revert wasn't complete (which is why we got the test failures that Jan mentions). I've finished the revert in r354766.

[jankratochvil]

In D58394#1408117, @jankratochvil wrote:

Getting now failure for every run: LLDB :: ExecControl/StopHook/stop-hook.test

It is because after this commit (rL354706 = GIT ff8c7a0947663ce7515f0b8ee52b9d0fe8883bc3) there was its revert (rL354711 = GIT 0513a24d62e1eef4e8179ced177c3672dab21bce) but it did not revert one testcase patch hunk:

lldb/lit/ExecControl/StopHook/stop-hook.test
 # CHECK: (lldb) run
+# CHECK-NEXT: Process {{.*}} launched:
 # CHECK-NEXT: (void *) $0 = 0x
+# CHECK-NEXT: Process {{.*}} stopped

while on Fedora 29 x86_64 the LLDB output is reversed:

(lldb) run
(void *) $0 = 0x0000000000405260

Process 460013 stopped
* thread #1, name = 'stop-hook.test.', stop reason = breakpoint 1.1
    frame #0: 0x00000000004011c4 stop-hook.test.tmp`b(val=1) at stop-hook.c:29:10
   26  	{
   27  	    int rc = c(val);
   28  	    void *ptr = malloc(1024);
-> 29  	    if (!ptr)  // Set breakpoint here to test target stop-hook.
   30  	        return -1;
   31  	    else
   32  	        printf("ptr=%p\n", ptr); // We should stop here after stepping.

Process 460013 launched: '.../tools/lldb/lit/ExecControl/StopHook/Output/stop-hook.test.tmp' (x86_64)
(lldb) thread step-over

include/lldb/Target/Process.h

public:
   //------------------------------------------------------------------
   bool HijackProcessEvents(lldb::ListenerSP listener_sp);
 
   //------------------------------------------------------------------
   /// Restores the process event broadcasting to its normal state.
   ///
   //------------------------------------------------------------------
   void RestoreProcessEvents();
   
+  bool IsHijackedForSynchronousResume();
+
   const lldb::ABISP &GetABI();
 
   OperatingSystem *GetOperatingSystem() { return m_os_up.get(); }
 
   virtual LanguageRuntime *GetLanguageRuntime(lldb::LanguageType language,
                                               bool retry_if_null = true);
 
   virtual CPPLanguageRuntime *GetCPPLanguageRuntime(bool retry_if_null = true);

include/lldb/Target/Target.h

public:
     void SetThreadSpecifier(ThreadSpec *specifier);
 
     ThreadSpec *GetThreadSpecifier() { return m_thread_spec_up.get(); }
 
     bool IsActive() { return m_active; }
 
     void SetIsActive(bool is_active) { m_active = is_active; }
 
+    void SetAutoContinue(bool auto_continue) {m_auto_continue = auto_continue;}
+
+    bool GetAutoContinue() const { return m_auto_continue; }
+
     void GetDescription(Stream *s, lldb::DescriptionLevel level) const;
 
   private:
     lldb::TargetSP m_target_sp;
     StringList m_commands;
     lldb::SymbolContextSpecifierSP m_specifier_sp;
     std::unique_ptr<ThreadSpec> m_thread_spec_up;
-    bool m_active;
+    bool m_active = true;
+    bool m_auto_continue = false;
 
     // Use CreateStopHook to make a new empty stop hook. The GetCommandPointer
     // and fill it with commands, and SetSpecifier to set the specifier shared
     // pointer (can be null, that will match anything.)
     StopHook(lldb::TargetSP target_sp, lldb::user_id_t uid);
     friend class Target;
   };
   typedef std::shared_ptr<StopHook> StopHookSP;

lit/ExecControl/StopHook/Inputs/stop-hook-2.lldbinit

-target stop-hook add -f stop-hook.c -l 29 -e 34 -o "expr ptr"
+target stop-hook add -f stop-hook.c -l 29 -e 34 -o "expr ptr"
 

lit/ExecControl/StopHook/Inputs/stop-hook-3.lldbinit

 target stop-hook add -f stop-hook.c -l 29 -e 34
 expr ptr
-DONE
+DONE
 

lit/ExecControl/StopHook/Inputs/stop-hook-threads-1.lldbinit

+break set -f stop-hook-threads.cpp -p "Break here to set up the stop hook"
 break set -f stop-hook-threads.cpp -p "Break here to test that the stop-hook"
 run
-target stop-hook add
-frame variable --show-globals g_val
+target stop-hook add -G true
+expr lldb_val += 1
 thread list
-continue
 DONE

lit/ExecControl/StopHook/Inputs/stop-hook-threads-2.lldbinit

+break set -f stop-hook-threads.cpp -p "Break here to set up the stop hook"
 break set -f stop-hook-threads.cpp -p "Break here to test that the stop-hook"
 run
-target stop-hook add -x 2 -o "frame variable thread_index"
-target stop-hook add -o continue
+target stop-hook add -x 2 -o "expr lldb_val += 1" -o "thread list"
+target stop-hook add -G true -o "script print('Hit stop hook') 

lit/ExecControl/StopHook/Inputs/stop-hook-threads.cpp

 #include <mutex>
 #include <random>
 #include <thread>
 
 std::default_random_engine g_random_engine{std::random_device{}()};
 std::uniform_int_distribution<> g_distribution{0, 3000};
 
 uint32_t g_val = 0;
+uint32_t lldb_val = 0;
 
 uint32_t
 access_pool (bool flag = false)
 {
     static std::mutex g_access_mutex;
     if (!flag)
         g_access_mutex.lock();
 
thread_func (uint32_t thread_index)
     }
     printf ("%s (thread index = %u) exiting...\n", __FUNCTION__, thread_index);
 }
 
 
 int main (int argc, char const *argv[])
 {
     std::thread threads[3];
-
+    // Break here to set up the stop hook
+    printf("Stop hooks engaged.\n");
     // Create 3 threads
     for (auto &thread : threads)
         thread = std::thread{thread_func, std::distance(threads, &thread)};
 
     // Join all of our threads
     for (auto &thread : threads)
         thread.join();
 
+    // print lldb_val so we can check it here.
+    printf ("lldb_val was set to: %d.\n", lldb_val);
     return 0;
 }

lit/ExecControl/StopHook/stop-hook-threads.test

 # RUN: %clangxx %p/Inputs/stop-hook-threads.cpp -g -o %t
 # RUN: %lldb -b -s %p/Inputs/stop-hook-threads-1.lldbinit -s %s -f %t \
 # RUN:     | FileCheck --check-prefix=CHECK --check-prefix=CHECK-NO-FILTER %s
 # RUN: %lldb -b -s %p/Inputs/stop-hook-threads-2.lldbinit -s %s -f %t \
 # RUN:     | FileCheck --check-prefix=CHECK --check-prefix=CHECK-FILTER %s
 # XFAIL: system-windows
 # UNSUPPORTED: linux
 
 thread list
 break set -f stop-hook-threads.cpp -p "Set break point at this line"
 target stop-hook list
 
 # CHECK: Hook: 1
 # CHECK-NEXT:  State: enabled
+# CHECK-NO-FILTER-NEXT: AutoContinue on
 # CHECK-FILTER-NEXT:  Thread
 # CHECK-FILTER-NEXT:  index: 2
 # CHECK-NEXT:  Commands: 
-# CHECK-NEXT:    frame variable
+# CHECK-NEXT:    expr lldb_val += 1
+# CHECK-NEXT:    thread list
 
 # CHECK-FILTER: Hook: 2
 # CHECK-FILTER-NEXT:  State: enabled
+# CHECK-FILTER-NEXT:  AutoContinue on
 # CHECK-FILTER-NEXT:  Commands: 
-# CHECK-FILTER-NEXT:    continue
+# CHECK-FILTER-NEXT:    script print('Hit stop hook')
 
 # Get the threads going
 continue
 
-# When we filter per thread, we expect exactly 4 identical "frame var" results
-# CHECK-FILTER: (uint32_t) thread_index = [[THREAD_INDEX:[0-9]*]]
-# CHECK-FILTER-COUNT-3: (uint32_t) thread_index = [[THREAD_INDEX]]
-# CHECK-FILTER-NOT: thread_index
-
-# When we don't filter, we expect to count 12 stopped threads in the thread list output
-# CHECK-NO-FILTER-COUNT-12: at stop-hook-threads.cpp{{.*}} stop reason = breakpoint
+# Now make sure we hit the command the right number of times:
+# CHECK-NO-FILTER: lldb_val was set to: 15.
+# CHECK-FILTER: lldb_val was set to: 5.
 

source/Commands/CommandObjectTarget.cpp

 #pragma mark CommandObjectTargetStopHookAdd
 
 //-------------------------------------------------------------------------
 // CommandObjectTargetStopHookAdd
 //-------------------------------------------------------------------------
 
 static constexpr OptionDefinition g_target_stop_hook_add_options[] = {
     // clang-format off
-  { LLDB_OPT_SET_ALL, false, "one-liner",    'o', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeOneLiner,                                         "Specify a one-line breakpoint command inline. Be sure to surround it with quotes." },
+  { LLDB_OPT_SET_ALL, false, "one-liner",    'o', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeOneLiner,                                         "Add a command for the stop hook.  Can be specified more than once, and commands will be run in the order they appear." },
   { LLDB_OPT_SET_ALL, false, "shlib",        's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eModuleCompletion, eArgTypeShlibName,    "Set the module within which the stop-hook is to be run." },
   { LLDB_OPT_SET_ALL, false, "thread-index", 'x', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeThreadIndex,                                      "The stop hook is run only for the thread whose index matches this argument." },
   { LLDB_OPT_SET_ALL, false, "thread-id",    't', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeThreadID,                                         "The stop hook is run only for the thread whose TID matches this argument." },
   { LLDB_OPT_SET_ALL, false, "thread-name",  'T', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeThreadName,                                       "The stop hook is run only for the thread whose thread name matches this argument." },
   { LLDB_OPT_SET_ALL, false, "queue-name",   'q', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeQueueName,                                        "The stop hook is run only for threads in the queue whose name is given by this argument." },
   { LLDB_OPT_SET_1,   false, "file",         'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "Specify the source file within which the stop-hook is to be run." },
   { LLDB_OPT_SET_1,   false, "start-line",   'l', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeLineNum,                                          "Set the start of the line range for which the stop-hook is to be run." },
   { LLDB_OPT_SET_1,   false, "end-line",     'e', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeLineNum,                                          "Set the end of the line range for which the stop-hook is to be run." },
   { LLDB_OPT_SET_2,   false, "classname",    'c', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeClassName,                                        "Specify the class within which the stop-hook is to be run." },
   { LLDB_OPT_SET_3,   false, "name",         'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName, "Set the function name within which the stop hook will be run." },
+  { LLDB_OPT_SET_ALL, false, "auto-continue",'G', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean,     "The breakpoint will auto-continue after running its commands." },
     // clang-format on
 };
 
 class CommandObjectTargetStopHookAdd : public CommandObjectParsed,
                                        public IOHandlerDelegateMultiline {
 public:
   class CommandOptions : public Options {
   public:
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         if (option_arg.getAsInteger(0, m_line_end)) {
           error.SetErrorStringWithFormat("invalid end line number: \"%s\"",
                                          option_arg.str().c_str());
           break;
         }
         m_sym_ctx_specified = true;
         break;
 
+      case 'G': {
+        bool value, success;
+        value = OptionArgParser::ToBoolean(option_arg, false, &success);
+        if (success) {
+          m_auto_continue = value;
+        } else
+          error.SetErrorStringWithFormat(
+              "invalid boolean value '%s' passed for -G option",
+              option_arg.str().c_str());
+      }
+      break;
       case 'l':
         if (option_arg.getAsInteger(0, m_line_start)) {
           error.SetErrorStringWithFormat("invalid start line number: \"%s\"",
                                          option_arg.str().c_str());
           break;
         }
         m_sym_ctx_specified = true;
         break;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         if (option_arg.getAsInteger(0, m_thread_index))
           error.SetErrorStringWithFormat("invalid thread index string '%s'",
                                          option_arg.str().c_str());
         m_thread_specified = true;
         break;
 
       case 'o':
         m_use_one_liner = true;
-        m_one_liner = option_arg;
+        m_one_liner.push_back(option_arg);
         break;
 
       default:
         error.SetErrorStringWithFormat("unrecognized option %c.", short_option);
         break;
       }
       return error;
     }
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_queue_name.clear();
 
       m_no_inlines = false;
       m_sym_ctx_specified = false;
       m_thread_specified = false;
 
       m_use_one_liner = false;
       m_one_liner.clear();
+      m_auto_continue = false;
     }
 
     std::string m_class_name;
     std::string m_function_name;
     uint32_t m_line_start;
     uint32_t m_line_end;
     std::string m_file_name;
     std::string m_module_name;
     uint32_t m_func_name_type_mask; // A pick from lldb::FunctionNameType.
     lldb::tid_t m_thread_id;
     uint32_t m_thread_index;
     std::string m_thread_name;
     std::string m_queue_name;
     bool m_sym_ctx_specified;
     bool m_no_inlines;
     bool m_thread_specified;
     // Instance variables to hold the values for one_liner options.
     bool m_use_one_liner;
-    std::string m_one_liner;
+    std::vector<std::string> m_one_liner;
+    bool m_auto_continue;
   };
 
   CommandObjectTargetStopHookAdd(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "target stop-hook add",
                             "Add a hook to be executed when the target stops.",
                             "target stop-hook add"),
         IOHandlerDelegateMultiline("DONE",
                                    IOHandlerDelegate::Completion::LLDBCommand),
if (target) {
         if (!m_options.m_thread_name.empty())
           thread_spec->SetName(m_options.m_thread_name.c_str());
 
         if (!m_options.m_queue_name.empty())
           thread_spec->SetQueueName(m_options.m_queue_name.c_str());
 
         new_hook_sp->SetThreadSpecifier(thread_spec);
       }
+      
+      new_hook_sp->SetAutoContinue(m_options.m_auto_continue);
       if (m_options.m_use_one_liner) {
-        // Use one-liner.
+        // Use one-liners.
+        for (auto cmd : m_options.m_one_liner)
           new_hook_sp->GetCommandPointer()->AppendString(
-            m_options.m_one_liner.c_str());
+            cmd.c_str());
         result.AppendMessageWithFormat("Stop hook #%" PRIu64 " added.\n",
                                        new_hook_sp->GetID());
       } else {
         m_stop_hook_sp = new_hook_sp;
         m_interpreter.GetLLDBCommandsFromIOHandler(
             "> ",     // Prompt
             *this,    // IOHandlerDelegate
             true,     // Run IOHandler in async mode

source/Target/Process.cpp

Status Process::Resume() {
   Status error = PrivateResume();
   if (!error.Success()) {
     // Undo running state change
     m_public_run_lock.SetStopped();
   }
   return error;
 }
 
+static const char *g_resume_sync_name = "lldb.Process.ResumeSynchronous.hijack";
+
 Status Process::ResumeSynchronous(Stream *stream) {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STATE |
                                                   LIBLLDB_LOG_PROCESS));
   if (log)
     log->Printf("Process::ResumeSynchronous -- locking run lock");
   if (!m_public_run_lock.TrySetRunning()) {
     Status error("Resume request failed - process still running.");
     if (log)
       log->Printf("Process::Resume: -- TrySetRunning failed, not resuming.");
     return error;
   }
 
   ListenerSP listener_sp(
-      Listener::MakeListener("lldb.Process.ResumeSynchronous.hijack"));
+      Listener::MakeListener(g_resume_sync_name));
   HijackProcessEvents(listener_sp);
 
   Status error = PrivateResume();
   if (error.Success()) {
     StateType state =
         WaitForProcessToStop(llvm::None, NULL, true, listener_sp, stream);
     const bool must_be_alive =
         false; // eStateExited is ok, so this must be false
     if (!StateIsStoppedState(state, must_be_alive))
       error.SetErrorStringWithFormat(
           "process not in stopped state after synchronous resume: %s",
           StateAsCString(state));
   } else {
     // Undo running state change
     m_public_run_lock.SetStopped();
   }
 
   // Undo the hijacking of process events...
   RestoreProcessEvents();
 
   return error;
 }
 
+bool Process::IsHijackedForSynchronousResume() {
+  const char *hijacker_name = GetHijackingListenerName();
+  return strcmp(hijacker_name, g_resume_sync_name) == 0;
+}
+
 StateType Process::GetPrivateState() { return m_private_state.GetValue(); }
 
 void Process::SetPrivateState(StateType new_state) {
   if (m_finalize_called)
     return;
 
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_STATE |
                                                   LIBLLDB_LOG_PROCESS));
if (m_state == eStateStopped && !m_restarted) {
     if (!GetRestarted()) {
       if (!still_should_stop && does_anybody_have_an_opinion) {
         // We've been asked to continue, so do that here.
         SetRestarted(true);
         // Use the public resume method here, since this is just extending a
         // public resume.
         process_sp->PrivateResume();
       } else {
-        // If we didn't restart, run the Stop Hooks here: They might also
-        // restart the target, so watch for that.
+        bool hijacked = 
+            process_sp->IsHijackedForEvent(eBroadcastBitStateChanged)
+            && !process_sp->IsHijackedForSynchronousResume();
+
+        if (!hijacked) {
+          // If we didn't restart, run the Stop Hooks here.
+          // Don't do that if state changed events aren't hooked up to the
+          // public (or SyncResume) broadcasters.  StopHooks are just for 
+          // real public stops.  They might also restart the target, 
+          // so watch for that.
           process_sp->GetTarget().RunStopHooks();
           if (process_sp->GetPrivateState() == eStateRunning)
             SetRestarted(true);
         }
       }
     }
   }
+}
 
 void Process::ProcessEventData::Dump(Stream *s) const {
   ProcessSP process_sp(m_process_wp.lock());
 
   if (process_sp)
     s->Printf(" process = %p (pid = %" PRIu64 "), ",
               static_cast<void *>(process_sp.get()), process_sp->GetID());
   else

source/Target/Target.cpp

void Target::RunStopHooks() {
   if (m_process_sp->GetModIDRef().IsLastResumeForUserExpression())
     return;
 
   if (m_stop_hooks.empty())
     return;
 
   StopHookCollection::iterator pos, end = m_stop_hooks.end();
 
-  // If there aren't any active stop hooks, don't bother either:
+  // If there aren't any active stop hooks, don't bother either.
+  // Also see if any of the active hooks want to auto-continue.
   bool any_active_hooks = false;
-  for (pos = m_stop_hooks.begin(); pos != end; pos++) {
-    if ((*pos).second->IsActive()) {
+  bool auto_continue = false;
+  for (auto hook : m_stop_hooks) {
+    if (hook.second->IsActive()) {
       any_active_hooks = true;
-      break;
+      auto_continue |= hook.second->GetAutoContinue();
     }
   }
   if (!any_active_hooks)
     return;
 
   CommandReturnObject result;
 
   std::vector<ExecutionContext> exc_ctx_with_reasons;
void Target::RunStopHooks() {
 
   result.SetImmediateOutputStream(m_debugger.GetAsyncOutputStream());
   result.SetImmediateErrorStream(m_debugger.GetAsyncErrorStream());
 
   bool keep_going = true;
   bool hooks_ran = false;
   bool print_hook_header = (m_stop_hooks.size() != 1);
   bool print_thread_header = (num_exe_ctx != 1);
+  bool did_restart = false;
 
   for (pos = m_stop_hooks.begin(); keep_going && pos != end; pos++) {
     // result.Clear();
     StopHookSP cur_hook_sp = (*pos).second;
     if (!cur_hook_sp->IsActive())
       continue;
 
     bool any_thread_matched = false;
for (size_t i = 0; keep_going && i < num_exe_ctx; i++) {
 
         CommandInterpreterRunOptions options;
         options.SetStopOnContinue(true);
         options.SetStopOnError(true);
         options.SetEchoCommands(false);
         options.SetPrintResults(true);
         options.SetAddToHistory(false);
 
+        // Force Async:
+        bool old_async = GetDebugger().GetAsyncExecution();
+        GetDebugger().SetAsyncExecution(true);
         GetDebugger().GetCommandInterpreter().HandleCommands(
             cur_hook_sp->GetCommands(), &exc_ctx_with_reasons[i], options,
             result);
-
+        GetDebugger().SetAsyncExecution(old_async);
         // If the command started the target going again, we should bag out of
         // running the stop hooks.
         if ((result.GetStatus() == eReturnStatusSuccessContinuingNoResult) ||
             (result.GetStatus() == eReturnStatusSuccessContinuingResult)) {
           // But only complain if there were more stop hooks to do:
           StopHookCollection::iterator tmp = pos;
           if (++tmp != end)
             result.AppendMessageWithFormat("\nAborting stop hooks, hook %" PRIu64
-                                           " set the program running.\n",
+                                           " set the program running.\n"
+                                           "  Consider using '-G true' to make "
+                                           "stop hooks auto-continue.\n",
                                            cur_hook_sp->GetID());
           keep_going = false;
+          did_restart = true;
         }
       }
     }
   }
+  // Finally, if auto-continue was requested, do it now:
+  if (!did_restart && auto_continue)
+    m_process_sp->PrivateResume();
 
   result.GetImmediateOutputStream()->Flush();
   result.GetImmediateErrorStream()->Flush();
 }
 
 const TargetPropertiesSP &Target::GetGlobalProperties() {
   // NOTE: intentional leak so we don't crash if global destructor chain gets
   // called as other threads still use the result of this function
void Target::FinalizeFileActions(ProcessLaunchInfo &info) {
   }
 }
 
 //--------------------------------------------------------------
 // Target::StopHook
 //--------------------------------------------------------------
 Target::StopHook::StopHook(lldb::TargetSP target_sp, lldb::user_id_t uid)
     : UserID(uid), m_target_sp(target_sp), m_commands(), m_specifier_sp(),
-      m_thread_spec_up(), m_active(true) {}
+      m_thread_spec_up() {}
 
 Target::StopHook::StopHook(const StopHook &rhs)
     : UserID(rhs.GetID()), m_target_sp(rhs.m_target_sp),
       m_commands(rhs.m_commands), m_specifier_sp(rhs.m_specifier_sp),
-      m_thread_spec_up(), m_active(rhs.m_active) {
+      m_thread_spec_up(), m_active(rhs.m_active),
+      m_auto_continue(rhs.m_auto_continue) {
   if (rhs.m_thread_spec_up)
     m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up));
 }
 
 Target::StopHook::~StopHook() = default;
 
 void Target::StopHook::SetSpecifier(SymbolContextSpecifier *specifier) {
   m_specifier_sp.reset(specifier);
void Target::StopHook::GetDescription(Stream *s,
   s->SetIndentLevel(indent_level + 2);
 
   s->Printf("Hook: %" PRIu64 "\n", GetID());
   if (m_active)
     s->Indent("State: enabled\n");
   else
     s->Indent("State: disabled\n");
 
+  if (m_auto_continue)
+    s->Indent("AutoContinue on\n");
+
   if (m_specifier_sp) {
     s->Indent();
     s->PutCString("Specifier:\n");
     s->SetIndentLevel(indent_level + 4);
     m_specifier_sp->GetDescription(s, level);
     s->SetIndentLevel(indent_level + 2);
   }