reformatting

Author: jimingham

lldb/include/lldb/Target/Target.h

@@ -1369,11 +1369,11 @@ class Target : public std::enable_shared_from_this<Target>,
     }
 
     bool GetAutoContinue() const { return m_auto_continue; }
-    
+
     void SetRunAtFirstStop(bool at_first_stop) {
       m_at_first_stop = at_first_stop;
     }
-    
+
     bool GetRunAtFirstStop() const { return m_at_first_stop; }
 
     void GetDescription(Stream &s, lldb::DescriptionLevel level) const;

lldb/source/Commands/CommandObjectTarget.cpp

@@ -4795,7 +4795,7 @@ class CommandObjectTargetStopHookAdd : public CommandObjectParsed,
         m_use_one_liner = true;
         m_one_liner.push_back(std::string(option_arg));
         break;
-        
+
       case 'F': {
         bool value, success;
         value = OptionArgParser::ToBoolean(option_arg, false, &success);
@@ -5019,7 +5019,7 @@ Filter Options:
 
     if (specifier_up)
       new_hook_sp->SetSpecifier(specifier_up.release());
-      
+
     // Should we run at first stop:
     new_hook_sp->SetRunAtFirstStop(m_options.m_at_first_stop);
 

lldb/source/Target/Target.cpp

@@ -3056,9 +3056,9 @@ bool Target::RunStopHooks(bool at_initial_stop) {
 
   bool no_active_hooks =
       llvm::none_of(m_stop_hooks, [at_initial_stop](auto &p) {
-      bool should_run_now = !at_initial_stop || p.second->GetRunAtFirstStop();
-      return p.second->IsActive() && should_run_now; 
-  });
+        bool should_run_now = !at_initial_stop || p.second->GetRunAtFirstStop();
+        return p.second->IsActive() && should_run_now;
+      });
   if (no_active_hooks)
     return false;
 
@@ -3096,14 +3096,13 @@ bool Target::RunStopHooks(bool at_initial_stop) {
   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());
+      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;
   }
-  
 
   StreamSP output_sp = m_debugger.GetAsyncOutputStream();
   auto on_exit = llvm::make_scope_exit([output_sp] { output_sp->Flush(); });
@@ -3604,8 +3603,8 @@ Status Target::Attach(ProcessAttachInfo &attach_info, Stream *stream) {
           std::nullopt, nullptr, false, attach_info.GetHijackListener(), stream,
           true, SelectMostRelevantFrame);
       process_sp->RestoreProcessEvents();
-      
-      // Run the stop hooks here.  Since we were hijacking the events, they 
+
+      // Run the stop hooks here.  Since we were hijacking the events, they
       // wouldn't have gotten run as part of event delivery.
       RunStopHooks(true /* at_initial_stop */);
 

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

@@ -109,4 +109,3 @@ def before_and_after_target(self):
         self.expect(
             "target stop-hook list", substrs=["expr g_var++", "thread backtrace"]
         )
-        

lldb/test/API/commands/target/stop-hooks/on-core-load/TestStopHookOnCoreLoad.py

@@ -22,15 +22,14 @@ def test_hook_runs_no_threads(self):
         core_path = self.getBuildArtifact("test.core")
         self.yaml2obj("test.core.yaml", core_path)
 
-       # Since mach core files don't have stop reasons, we should choose
-       # the first thread:
+        # Since mach core files don't have stop reasons, we should choose
+        # the first thread:
         self.do_test(core_path, 1)
 
     def test_hook_one_thread(self):
         core_path = os.path.join(self.getSourceDir(), "linux-x86_64.core")
         self.do_test(core_path, 3)
 
-        
     def do_test(self, core_path, stop_thread):
         # Set debugger into synchronous mode
         self.dbg.SetAsync(False)
@@ -42,14 +41,15 @@ def do_test(self, core_path, stop_thread):
         stop_hook_path = os.path.join(self.getSourceDir(), "stop_hook.py")
         self.runCmd(f"command script import {stop_hook_path}")
         self.runCmd("target stop-hook add -P stop_hook.stop_handler")
-        
+
         # Load core.
         process = target.LoadCore(core_path)
         self.assertTrue(process, PROCESS_IS_VALID)
-       # Now run our report command and make sure we get the right answer.
-        
+        # Now run our report command and make sure we get the right answer.
+
         result = lldb.SBCommandReturnObject()
         self.dbg.GetCommandInterpreter().HandleCommand("report_command", result)
         print(f"Command Output: '{result.GetOutput}'")
-        self.assertIn(f"Stop Threads: {stop_thread}", result.GetOutput(), "Ran the stop hook")
-        
+        self.assertIn(
+            f"Stop Threads: {stop_thread}", result.GetOutput(), "Ran the stop hook"
+        )

lldb/test/API/commands/target/stop-hooks/on-core-load/stop_hook.py

@@ -1,13 +1,15 @@
 import lldb
 
+
 def report_command(debugger, command, exe_ctx, result, internal_dict):
     global stop_thread
     print(f"About to report out stop_thread: {stop_thread}")
     mssg = f"Stop Threads: {stop_thread}"
     result.AppendMessage(mssg)
 
     result.SetStatus(lldb.eReturnStatusSuccessFinishResult)
-    
+
+
 class stop_handler:
     def __init__(self, target, extra_args, dict):
         global stop_thread
@@ -19,10 +21,10 @@ def handle_stop(self, exe_ctx, stream):
         thread = exe_ctx.thread
         stop_thread = thread.idx
 
+
 def __lldb_init_module(debugger, internal_dict):
     global stop_thread
     stop_thread = 0
     debugger.HandleCommand(
-           f"command script add -o -f '{__name__}.report_command' report_command"
-)
-
+        f"command script add -o -f '{__name__}.report_command' report_command"
+    )