diff mbox

[08/31] gdbserver/linux-low: turn some more static functions into private methods

Message ID 8aa8aae17f85cee979f28e467e7fa09e71c46bf1.1583529166.git.tankut.baris.aktemur@intel.com
State New
Headers show

Commit Message

Tankut Baris Aktemur March 6, 2020, 9:31 p.m. UTC
gdbserver/ChangeLog:
2020-03-06  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	Turn some more static methods in linux-low into private methods
	of linux_process_target.

	* linux-low.cc (get_pc): Turn into...
	(linux_process_target::get_pc): ...this.
	(save_stop_reason): Turn into...
	(linux_process_target::save_stop_reason): ...this.
	(thread_still_has_status_pending_p): Turn into...
	(linux_process_target::thread_still_has_status_pending): ...this.
	(status_pending_p_callback): Turn into...
	(linux_process_target::status_pending_p_callback): ...this.
	(resume_stopped_resumed_lwps): Turn into...
	(linux_process_target::resume_stopped_resumed_lwps): ...this.
	(install_software_single_step_breakpoints): Turn into...
	(linux_process_target::install_software_single_step_breakpoints):
	...this.
	(single_step): Turn into...
	(linux_process_target::single_step): ...this.
	(linux_resume_one_lwp_throw): Turn into...
	(linux_process_target::resume_one_lwp_throw): ...this.
	(linux_resume_one_lwp): Turn into...
	(linux_process_target::resume_one_lwp): ...this.
	(resume_status_pending_p): Turn into...
	(linux_process_target::resume_status_pending): ...this.
	(need_step_over_p): Turn into...
	(linux_process_target::thread_needs_step_over): ...this.
	(linux_resume_one_thread): Turn into...
	(linux_process_target::resume_one_thread): ...this.
	(proceed_one_lwp): Turn into...
	(linux_process_target::proceed_one_lwp): ...this.
	(unsuspend_and_proceed_one_lwp): Turn into...
	(linux_process_target::unsuspend_and_proceed_one_lwp): ...this.

	Update the calls/references to the above functions below.

	(linux_process_target::handle_extended_wait)
	(linux_process_target::filter_event)
	(linux_process_target::wait_for_event_filtered)
	(linux_process_target::wait_1)
	(linux_process_target::move_out_of_jump_pad)
	(linux_process_target::start_step_over)
	(linux_process_target::resume)
	(linux_process_target::proceed_all_lwps)
	(regsets_store_inferior_registers)
	(linux_process_target::store_register)

	* linux-low.h (class linux_process_target)
	<get_pc>
	<save_stop_reason>
	<thread_still_has_status_pending>
	<status_pending_p_callback>
	<resume_stopped_resumed_lwps>
	<install_software_single_step_breakpoints>
	<single_step>
	<resume_one_lwp_throw>
	<resume_one_lwp>
	<resume_status_pending>
	<thread_needs_step_over>
	<resume_one_thread>
	<proceed_one_lwp>
	<unsuspend_and_proceed_one_lwp>: Declare.
---
 gdbserver/linux-low.cc | 192 +++++++++++++++--------------------------
 gdbserver/linux-low.h  |  78 +++++++++++++++++
 2 files changed, 149 insertions(+), 121 deletions(-)
diff mbox

Patch

diff --git a/gdbserver/linux-low.cc b/gdbserver/linux-low.cc
index c77e92d17b1..65edde8b0e8 100644
--- a/gdbserver/linux-low.cc
+++ b/gdbserver/linux-low.cc
@@ -267,8 +267,6 @@  int using_threads = 1;
    jump pads).  */
 static int stabilizing_threads;
 
-static void linux_resume_one_lwp (struct lwp_info *lwp,
-				  int step, int signal, siginfo_t *info);
 static void unsuspend_all_lwps (struct lwp_info *except);
 static struct lwp_info *add_lwp (ptid_t ptid);
 static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
@@ -278,7 +276,6 @@  static int kill_lwp (unsigned long lwpid, int signo);
 static void enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info);
 static int linux_low_ptrace_options (int attached);
 static int check_ptrace_stopped_lwp_gone (struct lwp_info *lp);
-static void proceed_one_lwp (thread_info *thread, lwp_info *except);
 
 /* When the event-loop is doing a step-over, this points at the thread
    being stepped.  */
@@ -438,8 +435,6 @@  linux_add_process (int pid, int attached)
   return proc;
 }
 
-static CORE_ADDR get_pc (struct lwp_info *lwp);
-
 void
 linux_process_target::arch_setup_thread (thread_info *thread)
 {
@@ -616,9 +611,9 @@  linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp,
       new_lwp = add_lwp (ptid);
 
       /* Either we're going to immediately resume the new thread
-	 or leave it stopped.  linux_resume_one_lwp is a nop if it
+	 or leave it stopped.  resume_one_lwp is a nop if it
 	 thinks the thread is currently running, so set this first
-	 before calling linux_resume_one_lwp.  */
+	 before calling resume_one_lwp.  */
       new_lwp->stopped = 1;
 
       /* If we're suspending all threads, leave this one suspended
@@ -726,11 +721,8 @@  linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp,
   internal_error (__FILE__, __LINE__, _("unknown ptrace event %d"), event);
 }
 
-/* Return the PC as read from the regcache of LWP, without any
-   adjustment.  */
-
-static CORE_ADDR
-get_pc (struct lwp_info *lwp)
+CORE_ADDR
+linux_process_target::get_pc (lwp_info *lwp)
 {
   struct thread_info *saved_thread;
   struct regcache *regcache;
@@ -783,14 +775,8 @@  get_syscall_trapinfo (struct lwp_info *lwp, int *sysno)
 
 static int check_stopped_by_watchpoint (struct lwp_info *child);
 
-/* Called when the LWP stopped for a signal/trap.  If it stopped for a
-   trap check what caused it (breakpoint, watchpoint, trace, etc.),
-   and save the result in the LWP's stop_reason field.  If it stopped
-   for a breakpoint, decrement the PC if necessary on the lwp's
-   architecture.  Returns true if we now have the LWP's stop PC.  */
-
-static int
-save_stop_reason (struct lwp_info *lwp)
+bool
+linux_process_target::save_stop_reason (lwp_info *lwp)
 {
   CORE_ADDR pc;
   CORE_ADDR sw_breakpoint_pc;
@@ -800,7 +786,7 @@  save_stop_reason (struct lwp_info *lwp)
 #endif
 
   if (the_low_target.get_pc == NULL)
-    return 0;
+    return false;
 
   pc = get_pc (lwp);
   sw_breakpoint_pc = pc - the_low_target.decr_pc_after_break;
@@ -921,7 +907,7 @@  save_stop_reason (struct lwp_info *lwp)
 
   lwp->stop_pc = pc;
   current_thread = saved_thread;
-  return 1;
+  return true;
 }
 
 static struct lwp_info *
@@ -1678,12 +1664,8 @@  linux_process_target::thread_alive (ptid_t ptid)
     return 0;
 }
 
-/* Return 1 if this lwp still has an interesting status pending.  If
-   not (e.g., it had stopped for a breakpoint that is gone), return
-   false.  */
-
-static int
-thread_still_has_status_pending_p (struct thread_info *thread)
+bool
+linux_process_target::thread_still_has_status_pending (thread_info *thread)
 {
   struct lwp_info *lp = get_thread_lwp (thread);
 
@@ -1766,9 +1748,9 @@  lwp_resumed (struct lwp_info *lwp)
   return 0;
 }
 
-/* Return true if this lwp has an interesting status pending.  */
-static bool
-status_pending_p_callback (thread_info *thread, ptid_t ptid)
+bool
+linux_process_target::status_pending_p_callback (thread_info *thread,
+						 ptid_t ptid)
 {
   struct lwp_info *lp = get_thread_lwp (thread);
 
@@ -1781,9 +1763,9 @@  status_pending_p_callback (thread_info *thread, ptid_t ptid)
     return 0;
 
   if (lp->status_pending_p
-      && !thread_still_has_status_pending_p (thread))
+      && !thread_still_has_status_pending (thread))
     {
-      linux_resume_one_lwp (lp, lp->stepping, GDB_SIGNAL_0, NULL);
+      resume_one_lwp (lp, lp->stepping, GDB_SIGNAL_0, NULL);
       return 0;
     }
 
@@ -2517,7 +2499,7 @@  linux_process_target::filter_event (int lwpid, int wstat)
 			  child->stepping ? "step" : "continue",
 			  target_pid_to_str (ptid_of (thread)));
 
-	  linux_resume_one_lwp (child, child->stepping, 0, NULL);
+	  resume_one_lwp (child, child->stepping, 0, NULL);
 	  return NULL;
 	}
     }
@@ -2543,11 +2525,8 @@  maybe_hw_step (struct thread_info *thread)
     }
 }
 
-/* Resume LWPs that are currently stopped without any pending status
-   to report, but are resumed from the core's perspective.  */
-
-static void
-resume_stopped_resumed_lwps (thread_info *thread)
+void
+linux_process_target::resume_stopped_resumed_lwps (thread_info *thread)
 {
   struct lwp_info *lp = get_thread_lwp (thread);
 
@@ -2567,7 +2546,7 @@  resume_stopped_resumed_lwps (thread_info *thread)
 		      paddress (lp->stop_pc),
 		      step);
 
-      linux_resume_one_lwp (lp, step, GDB_SIGNAL_0, NULL);
+      resume_one_lwp (lp, step, GDB_SIGNAL_0, NULL);
     }
 }
 
@@ -2614,7 +2593,7 @@  linux_process_target::wait_for_event_filtered (ptid_t wait_ptid,
 				       &requested_child->status_pending);
 	  requested_child->status_pending_p = 0;
 	  requested_child->status_pending = 0;
-	  linux_resume_one_lwp (requested_child, 0, 0, NULL);
+	  resume_one_lwp (requested_child, 0, 0, NULL);
 	}
 
       if (requested_child->suspended
@@ -2702,7 +2681,10 @@  linux_process_target::wait_for_event_filtered (ptid_t wait_ptid,
       /* Now that we've pulled all events out of the kernel, resume
 	 LWPs that don't have an interesting event to report.  */
       if (stopping_threads == NOT_STOPPING_THREADS)
-	for_each_thread (resume_stopped_resumed_lwps);
+	for_each_thread ([this] (thread_info *thread)
+	  {
+	    resume_stopped_resumed_lwps (thread);
+	  });
 
       /* ... and find an LWP with a status to report to the core, if
 	 any.  */
@@ -3272,7 +3254,7 @@  linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
 	    debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n",
 			  WSTOPSIG (w), lwpid_of (current_thread));
 
-	  linux_resume_one_lwp (event_child, 0, 0, NULL);
+	  resume_one_lwp (event_child, 0, 0, NULL);
 
 	  if (debug_threads)
 	    debug_exit ();
@@ -3372,8 +3354,7 @@  linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
 			lwpid_of (current_thread));
 	}
 
-      linux_resume_one_lwp (event_child, event_child->stepping,
-			    0, NULL);
+      resume_one_lwp (event_child, event_child->stepping, 0, NULL);
 
       if (debug_threads)
 	debug_exit ();
@@ -3429,8 +3410,8 @@  linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
 	}
       else
 	{
-	  linux_resume_one_lwp (event_child, event_child->stepping,
-				WSTOPSIG (w), info_p);
+	  resume_one_lwp (event_child, event_child->stepping,
+			  WSTOPSIG (w), info_p);
 	}
 
       if (debug_threads)
@@ -4039,7 +4020,7 @@  linux_process_target::move_out_of_jump_pad (thread_info *thread)
 			  WSTOPSIG (*wstat), lwpid_of (thread));
 	}
 
-      linux_resume_one_lwp (lwp, 0, 0, NULL);
+      resume_one_lwp (lwp, 0, 0, NULL);
     }
   else
     lwp_suspended_inc (lwp);
@@ -4117,10 +4098,8 @@  enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info)
   lwp->pending_signals = p_sig;
 }
 
-/* Install breakpoints for software single stepping.  */
-
-static void
-install_software_single_step_breakpoints (struct lwp_info *lwp)
+void
+linux_process_target::install_software_single_step_breakpoints (lwp_info *lwp)
 {
   struct thread_info *thread = get_lwp_thread (lwp);
   struct regcache *regcache = get_thread_regcache (thread, 1);
@@ -4134,12 +4113,8 @@  install_software_single_step_breakpoints (struct lwp_info *lwp)
     set_single_step_breakpoint (pc, current_ptid);
 }
 
-/* Single step via hardware or software single step.
-   Return 1 if hardware single stepping, 0 if software single stepping
-   or can't single step.  */
-
-static int
-single_step (struct lwp_info* lwp)
+int
+linux_process_target::single_step (lwp_info* lwp)
 {
   int step = 0;
 
@@ -4174,12 +4149,9 @@  lwp_signal_can_be_delivered (struct lwp_info *lwp)
 	  == fast_tpoint_collect_result::not_collecting);
 }
 
-/* Resume execution of LWP.  If STEP is nonzero, single-step it.  If
-   SIGNAL is nonzero, give it that signal.  */
-
-static void
-linux_resume_one_lwp_throw (struct lwp_info *lwp,
-			    int step, int signal, siginfo_t *info)
+void
+linux_process_target::resume_one_lwp_throw (lwp_info *lwp, int step,
+					    int signal, siginfo_t *info)
 {
   struct thread_info *thread = get_lwp_thread (lwp);
   struct thread_info *saved_thread;
@@ -4416,16 +4388,13 @@  check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
   return 0;
 }
 
-/* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
-   disappears while we try to resume it.  */
-
-static void
-linux_resume_one_lwp (struct lwp_info *lwp,
-		      int step, int signal, siginfo_t *info)
+void
+linux_process_target::resume_one_lwp (lwp_info *lwp, int step, int signal,
+				      siginfo_t *info)
 {
   try
     {
-      linux_resume_one_lwp_throw (lwp, step, signal, info);
+      resume_one_lwp_throw (lwp, step, signal, info);
     }
   catch (const gdb_exception_error &ex)
     {
@@ -4546,11 +4515,8 @@  linux_set_resume_request (thread_info *thread, thread_resume *resume, size_t n)
   lwp->resume = NULL;
 }
 
-/* find_thread callback for linux_resume.  Return true if this lwp has an
-   interesting status pending.  */
-
-static bool
-resume_status_pending_p (thread_info *thread)
+bool
+linux_process_target::resume_status_pending (thread_info *thread)
 {
   struct lwp_info *lwp = get_thread_lwp (thread);
 
@@ -4559,16 +4525,11 @@  resume_status_pending_p (thread_info *thread)
   if (lwp->resume == NULL)
     return false;
 
-  return thread_still_has_status_pending_p (thread);
+  return thread_still_has_status_pending (thread);
 }
 
-/* Return 1 if this lwp that GDB wants running is stopped at an
-   internal breakpoint that we need to step over.  It assumes that any
-   required STOP_PC adjustment has already been propagated to the
-   inferior's regcache.  */
-
-static bool
-need_step_over_p (thread_info *thread)
+bool
+linux_process_target::thread_needs_step_over (thread_info *thread)
 {
   struct lwp_info *lwp = get_thread_lwp (thread);
   struct thread_info *saved_thread;
@@ -4739,7 +4700,7 @@  linux_process_target::start_step_over (lwp_info *lwp)
 
   current_thread = saved_thread;
 
-  linux_resume_one_lwp (lwp, step, 0, NULL);
+  resume_one_lwp (lwp, step, 0, NULL);
 
   /* Require next event from this LWP.  */
   step_over_bkpt = thread->id;
@@ -4814,21 +4775,9 @@  linux_process_target::complete_ongoing_step_over ()
     }
 }
 
-/* This function is called once per thread.  We check the thread's resume
-   request, which will tell us whether to resume, step, or leave the thread
-   stopped; and what signal, if any, it should be sent.
-
-   For threads which we aren't explicitly told otherwise, we preserve
-   the stepping flag; this is used for stepping over gdbserver-placed
-   breakpoints.
-
-   If pending_flags was set in any thread, we queue any needed
-   signals, since we won't actually resume.  We already have a pending
-   event to report, so we don't need to preserve any step requests;
-   they should be re-issued if necessary.  */
-
-static void
-linux_resume_one_thread (thread_info *thread, bool leave_all_stopped)
+void
+linux_process_target::resume_one_thread (thread_info *thread,
+					 bool leave_all_stopped)
 {
   struct lwp_info *lwp = get_thread_lwp (thread);
   int leave_pending;
@@ -4955,7 +4904,10 @@  linux_process_target::resume (thread_resume *resume_info, size_t n)
      before considering to start a step-over (in all-stop).  */
   bool any_pending = false;
   if (!non_stop)
-    any_pending = find_thread (resume_status_pending_p) != NULL;
+    any_pending = find_thread ([this] (thread_info *thread)
+		    {
+		      return resume_status_pending (thread);
+		    }) != nullptr;
 
   /* If there is a thread which would otherwise be resumed, which is
      stopped at a breakpoint that needs stepping over, then don't
@@ -4964,7 +4916,10 @@  linux_process_target::resume (thread_resume *resume_info, size_t n)
      to queue any signals that would otherwise be delivered or
      queued.  */
   if (!any_pending && supports_breakpoints ())
-    need_step_over = find_thread (need_step_over_p);
+    need_step_over = find_thread ([this] (thread_info *thread)
+		       {
+			 return thread_needs_step_over (thread);
+		       });
 
   bool leave_all_stopped = (need_step_over != NULL || any_pending);
 
@@ -4983,7 +4938,7 @@  linux_process_target::resume (thread_resume *resume_info, size_t n)
      otherwise deliver.  */
   for_each_thread ([&] (thread_info *thread)
     {
-      linux_resume_one_thread (thread, leave_all_stopped);
+      resume_one_thread (thread, leave_all_stopped);
     });
 
   if (need_step_over)
@@ -5001,17 +4956,8 @@  linux_process_target::resume (thread_resume *resume_info, size_t n)
     async_file_mark ();
 }
 
-/* This function is called once per thread.  We check the thread's
-   last resume request, which will tell us whether to resume, step, or
-   leave the thread stopped.  Any signal the client requested to be
-   delivered has already been enqueued at this point.
-
-   If any thread that GDB wants running is stopped at an internal
-   breakpoint that needs stepping over, we start a step-over operation
-   on that particular thread, and leave all others stopped.  */
-
-static void
-proceed_one_lwp (thread_info *thread, lwp_info *except)
+void
+linux_process_target::proceed_one_lwp (thread_info *thread, lwp_info *except)
 {
   struct lwp_info *lwp = get_thread_lwp (thread);
   int step;
@@ -5104,11 +5050,12 @@  proceed_one_lwp (thread_info *thread, lwp_info *except)
   else
     step = 0;
 
-  linux_resume_one_lwp (lwp, step, 0, NULL);
+  resume_one_lwp (lwp, step, 0, NULL);
 }
 
-static void
-unsuspend_and_proceed_one_lwp (thread_info *thread, lwp_info *except)
+void
+linux_process_target::unsuspend_and_proceed_one_lwp (thread_info *thread,
+						     lwp_info *except)
 {
   struct lwp_info *lwp = get_thread_lwp (thread);
 
@@ -5132,7 +5079,10 @@  linux_process_target::proceed_all_lwps ()
 
   if (supports_breakpoints ())
     {
-      need_step_over = find_thread (need_step_over_p);
+      need_step_over = find_thread ([this] (thread_info *thread)
+			 {
+			   return thread_needs_step_over (thread);
+			 });
 
       if (need_step_over != NULL)
 	{
@@ -5149,7 +5099,7 @@  linux_process_target::proceed_all_lwps ()
   if (debug_threads)
     debug_printf ("Proceeding, no step-over needed\n");
 
-  for_each_thread ([] (thread_info *thread)
+  for_each_thread ([this] (thread_info *thread)
     {
       proceed_one_lwp (thread, NULL);
     });
@@ -5362,7 +5312,7 @@  regsets_store_inferior_registers (struct regsets_info *regsets_info,
 	      /* At this point, ESRCH should mean the process is
 		 already gone, in which case we simply ignore attempts
 		 to change its registers.  See also the related
-		 comment in linux_resume_one_lwp.  */
+		 comment in resume_one_lwp.  */
 	      free (buf);
 	      return 0;
 	    }
@@ -5509,7 +5459,7 @@  linux_process_target::store_register (const usrregs_info *usrregs,
 	  /* At this point, ESRCH should mean the process is
 	     already gone, in which case we simply ignore attempts
 	     to change its registers.  See also the related
-	     comment in linux_resume_one_lwp.  */
+	     comment in resume_one_lwp.  */
 	  if (errno == ESRCH)
 	    return;
 
diff --git a/gdbserver/linux-low.h b/gdbserver/linux-low.h
index 7ac9086fb99..4f5502b4640 100644
--- a/gdbserver/linux-low.h
+++ b/gdbserver/linux-low.h
@@ -580,6 +580,84 @@  class linux_process_target : public process_stratum_target
   void usr_store_inferior_registers (const regs_info *regs_info,
 				     regcache *regcache, int regno, int all);
 
+  /* Return the PC as read from the regcache of LWP, without any
+     adjustment.  */
+  CORE_ADDR get_pc (lwp_info *lwp);
+
+  /* Called when the LWP stopped for a signal/trap.  If it stopped for a
+     trap check what caused it (breakpoint, watchpoint, trace, etc.),
+     and save the result in the LWP's stop_reason field.  If it stopped
+     for a breakpoint, decrement the PC if necessary on the lwp's
+     architecture.  Returns true if we now have the LWP's stop PC.  */
+  bool save_stop_reason (lwp_info *lwp);
+
+  /* Resume execution of LWP.  If STEP is nonzero, single-step it.  If
+     SIGNAL is nonzero, give it that signal.  */
+  void resume_one_lwp_throw (lwp_info *lwp, int step, int signal,
+			     siginfo_t *info);
+
+  /* Like resume_one_lwp_throw, but no error is thrown if the LWP
+     disappears while we try to resume it.  */
+  void resume_one_lwp (lwp_info *lwp, int step, int signal, siginfo_t *info);
+
+  /* This function is called once per thread.  We check the thread's
+     last resume request, which will tell us whether to resume, step, or
+     leave the thread stopped.  Any signal the client requested to be
+     delivered has already been enqueued at this point.
+
+     If any thread that GDB wants running is stopped at an internal
+     breakpoint that needs stepping over, we start a step-over operation
+     on that particular thread, and leave all others stopped.  */
+  void proceed_one_lwp (thread_info *thread, lwp_info *except);
+
+  /* This function is called once per thread.  We check the thread's
+     resume request, which will tell us whether to resume, step, or
+     leave the thread stopped; and what signal, if any, it should be
+     sent.
+
+     For threads which we aren't explicitly told otherwise, we preserve
+     the stepping flag; this is used for stepping over gdbserver-placed
+     breakpoints.
+
+     If pending_flags was set in any thread, we queue any needed
+     signals, since we won't actually resume.  We already have a pending
+     event to report, so we don't need to preserve any step requests;
+     they should be re-issued if necessary.  */
+  void resume_one_thread (thread_info *thread, bool leave_all_stopped);
+
+  /* Return true if this lwp has an interesting status pending.  */
+  bool status_pending_p_callback (thread_info *thread, ptid_t ptid);
+
+  /* Resume LWPs that are currently stopped without any pending status
+     to report, but are resumed from the core's perspective.  */
+  void resume_stopped_resumed_lwps (thread_info *thread);
+
+  /* Unsuspend THREAD, except EXCEPT, and proceed.  */
+  void unsuspend_and_proceed_one_lwp (thread_info *thread, lwp_info *except);
+
+  /* Return true if this lwp still has an interesting status pending.
+     If not (e.g., it had stopped for a breakpoint that is gone), return
+     false.  */
+  bool thread_still_has_status_pending (thread_info *thread);
+
+  /* Return true if this lwp is to-be-resumed and has an interesting
+     status pending.  */
+  bool resume_status_pending (thread_info *thread);
+
+  /* Return true if this lwp that GDB wants running is stopped at an
+     internal breakpoint that we need to step over.  It assumes that
+     any required STOP_PC adjustment has already been propagated to
+     the inferior's regcache.  */
+  bool thread_needs_step_over (thread_info *thread);
+
+  /* Single step via hardware or software single step.
+     Return 1 if hardware single stepping, 0 if software single stepping
+     or can't single step.  */
+  int single_step (lwp_info* lwp);
+
+  /* Install breakpoints for software single stepping.  */
+  void install_software_single_step_breakpoints (lwp_info *lwp);
+
 protected:
   /* The architecture-specific "low" methods are listed below.  */