Revert "Make stop-hooks fire when lldb first gains control of a process. (#137410)"

This reverts commit 4fdb8cb.

Author: Prabhuk

lldb/include/lldb/Target/Target.h

@@ -1375,12 +1375,6 @@ class Target : public std::enable_shared_from_this<Target>,
 
     bool GetAutoContinue() const { return m_auto_continue; }
 
-    void SetRunAtInitialStop(bool at_initial_stop) {
-      m_at_initial_stop = at_initial_stop;
-    }
-
-    bool GetRunAtInitialStop() const { return m_at_initial_stop; }
-
     void GetDescription(Stream &s, lldb::DescriptionLevel level) const;
     virtual void GetSubclassDescription(Stream &s,
                                         lldb::DescriptionLevel level) const = 0;
@@ -1391,7 +1385,6 @@ class Target : public std::enable_shared_from_this<Target>,
     std::unique_ptr<ThreadSpec> m_thread_spec_up;
     bool m_active = true;
     bool m_auto_continue = false;
-    bool m_at_initial_stop = true;
 
     StopHook(lldb::TargetSP target_sp, lldb::user_id_t uid);
   };
@@ -1458,9 +1451,7 @@ class Target : public std::enable_shared_from_this<Target>,
 
   // Runs the stop hooks that have been registered for this target.
   // Returns true if the stop hooks cause the target to resume.
-  // Pass at_initial_stop if this is the stop where lldb gains
-  // control over the process for the first time.
-  bool RunStopHooks(bool at_initial_stop = false);
+  bool RunStopHooks();
 
   size_t GetStopHookSize();
 

lldb/source/Commands/CommandObjectTarget.cpp

@@ -4806,17 +4806,6 @@ class CommandObjectTargetStopHookAdd : public CommandObjectParsed,
         m_one_liner.push_back(std::string(option_arg));
         break;
 
-      case 'I': {
-        bool value, success;
-        value = OptionArgParser::ToBoolean(option_arg, false, &success);
-        if (success)
-          m_at_initial_stop = value;
-        else
-          error = Status::FromErrorStringWithFormat(
-              "invalid boolean value '%s' passed for -F option",
-              option_arg.str().c_str());
-      } break;
-
       default:
         llvm_unreachable("Unimplemented option");
       }
@@ -4843,7 +4832,6 @@ class CommandObjectTargetStopHookAdd : public CommandObjectParsed,
       m_use_one_liner = false;
       m_one_liner.clear();
       m_auto_continue = false;
-      m_at_initial_stop = true;
     }
 
     std::string m_class_name;
@@ -4864,7 +4852,6 @@ class CommandObjectTargetStopHookAdd : public CommandObjectParsed,
     // Instance variables to hold the values for one_liner options.
     bool m_use_one_liner = false;
     std::vector<std::string> m_one_liner;
-    bool m_at_initial_stop;
 
     bool m_auto_continue = false;
   };
@@ -5030,9 +5017,6 @@ Filter Options:
     if (specifier_up)
       new_hook_sp->SetSpecifier(specifier_up.release());
 
-    // Should we run at the initial stop:
-    new_hook_sp->SetRunAtInitialStop(m_options.m_at_initial_stop);
-
     // Next see if any of the thread options have been entered:
 
     if (m_options.m_thread_specified) {

lldb/source/Commands/Options.td

@@ -1052,14 +1052,8 @@ let Command = "target stop hook add" in {
     Arg<"FunctionName">, Desc<"Set the function name within which the stop hook"
     " will be run.">, Completion<"Symbol">;
   def target_stop_hook_add_auto_continue : Option<"auto-continue", "G">,
-    Arg<"Boolean">, Desc<"The stop-hook will auto-continue after running its"
+    Arg<"Boolean">, Desc<"The breakpoint will auto-continue after running its"
     " commands.">;
-  def target_stop_hook_add_at_initial_stop : Option<"at-initial-stop", "I">,
-    Arg<"Boolean">, Desc<"Whether the stop-hook will trigger when lldb  "
-    "initially gains control of the process.  For a process launch, this "
-    "initial stop may happen very early on - before the loader has run.  You "
-    "can use this option if you do not want some stop-hooks to run then.  "
-    "Defaults to true.">;
 }
 
 let Command = "thread backtrace" in {

lldb/source/Target/Process.cpp

@@ -2802,9 +2802,6 @@ Status Process::LoadCore() {
           "Did not get stopped event after loading the core file.");
     }
     RestoreProcessEvents();
-    // Since we hijacked the event stream, we will have we won't have run the
-    // stop hooks.  Make sure we do that here:
-    GetTarget().RunStopHooks(/* at_initial_stop= */ true);
   }
   return error;
 }
@@ -3176,9 +3173,6 @@ void Process::CompleteAttach() {
                         : "<none>");
     }
   }
-  // Since we hijacked the event stream, we will have we won't have run the
-  // stop hooks.  Make sure we do that here:
-  GetTarget().RunStopHooks(/* at_initial_stop= */ true);
 }
 
 Status Process::ConnectRemote(llvm::StringRef remote_url) {

lldb/source/Target/Target.cpp

@@ -3048,7 +3048,7 @@ void Target::SetAllStopHooksActiveState(bool active_state) {
   }
 }
 
-bool Target::RunStopHooks(bool at_initial_stop) {
+bool Target::RunStopHooks() {
   if (m_suppress_stop_hooks)
     return false;
 
@@ -3057,19 +3057,14 @@ bool Target::RunStopHooks(bool at_initial_stop) {
 
   // Somebody might have restarted the process:
   // Still return false, the return value is about US restarting the target.
-  lldb::StateType state = m_process_sp->GetState();
-  if (!(state == eStateStopped || state == eStateAttaching))
+  if (m_process_sp->GetState() != eStateStopped)
     return false;
 
   if (m_stop_hooks.empty())
     return false;
 
   bool no_active_hooks =
-      llvm::none_of(m_stop_hooks, [at_initial_stop](auto &p) {
-        bool should_run_now =
-            !at_initial_stop || p.second->GetRunAtInitialStop();
-        return p.second->IsActive() && should_run_now;
-      });
+      llvm::none_of(m_stop_hooks, [](auto &p) { return p.second->IsActive(); });
   if (no_active_hooks)
     return false;
 
@@ -3099,22 +3094,9 @@ bool Target::RunStopHooks(bool at_initial_stop) {
   }
 
   // If no threads stopped for a reason, don't run the stop-hooks.
-  // However, if this is the FIRST stop for this process, then we are in the
-  // state where an attach or a core file load was completed without designating
-  // a particular thread as responsible for the stop.  In that case, we do
-  // want to run the stop hooks, but do so just on one thread.
   size_t num_exe_ctx = exc_ctx_with_reasons.size();
-  if (num_exe_ctx == 0) {
-    if (at_initial_stop && num_threads > 0) {
-      lldb::ThreadSP thread_to_use_sp = cur_threadlist.GetThreadAtIndex(0);
-      exc_ctx_with_reasons.emplace_back(
-          m_process_sp.get(), thread_to_use_sp.get(),
-          thread_to_use_sp->GetStackFrameAtIndex(0).get());
-      num_exe_ctx = 1;
-    } else {
-      return false;
-    }
-  }
+  if (num_exe_ctx == 0)
+    return false;
 
   StreamSP output_sp = m_debugger.GetAsyncOutputStream();
   auto on_exit = llvm::make_scope_exit([output_sp] { output_sp->Flush(); });
@@ -3128,8 +3110,6 @@ bool Target::RunStopHooks(bool at_initial_stop) {
     StopHookSP cur_hook_sp = stop_entry.second;
     if (!cur_hook_sp->IsActive())
       continue;
-    if (at_initial_stop && !cur_hook_sp->GetRunAtInitialStop())
-      continue;
 
     bool any_thread_matched = false;
     for (auto exc_ctx : exc_ctx_with_reasons) {
@@ -3456,14 +3436,10 @@ Status Target::Launch(ProcessLaunchInfo &launch_info, Stream *stream) {
   m_process_sp->RestoreProcessEvents();
 
   if (rebroadcast_first_stop) {
-    // We don't need to run the stop hooks by hand here, they will get
-    // triggered when this rebroadcast event gets fetched.
     assert(first_stop_event_sp);
     m_process_sp->BroadcastEvent(first_stop_event_sp);
     return error;
   }
-  // Run the stop hooks that want to run at entry.
-  RunStopHooks(true /* at entry point */);
 
   switch (state) {
   case eStateStopped: {
@@ -3616,10 +3592,6 @@ Status Target::Attach(ProcessAttachInfo &attach_info, Stream *stream) {
           true, SelectMostRelevantFrame);
       process_sp->RestoreProcessEvents();
 
-      // Run the stop hooks here.  Since we were hijacking the events, they
-      // wouldn't have gotten run as part of event delivery.
-      RunStopHooks(/* at_initial_stop= */ true);
-
       if (state != eStateStopped) {
         const char *exit_desc = process_sp->GetExitDescription();
         if (exit_desc)

lldb/test/API/commands/target/stop-hooks/TestStopHookScripted.py

@@ -50,11 +50,7 @@ def test_bad_handler(self):
 
     def test_stop_hooks_scripted(self):
         """Test that a scripted stop hook works with no specifiers"""
-        self.stop_hooks_scripted(5, "-I false")
-
-    def test_stop_hooks_scripted_no_entry(self):
-        """Test that a scripted stop hook works with no specifiers"""
-        self.stop_hooks_scripted(10)
+        self.stop_hooks_scripted(5)
 
     def test_stop_hooks_scripted_right_func(self):
         """Test that a scripted stop hook fires when there is a function match"""

lldb/test/API/commands/target/stop-hooks/TestStopHooks.py

@@ -55,7 +55,7 @@ def step_out_test(self):
     def after_expr_test(self):
         interp = self.dbg.GetCommandInterpreter()
         result = lldb.SBCommandReturnObject()
-        interp.HandleCommand("target stop-hook add -o 'expr g_var++' -I false", result)
+        interp.HandleCommand("target stop-hook add -o 'expr g_var++'", result)
         self.assertTrue(result.Succeeded(), "Set the target stop hook")
 
         (target, process, thread, first_bkpt) = lldbutil.run_to_source_breakpoint(