+ /* 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);
+
+ /* Return true if THREAD is doing hardware single step. */
+ bool maybe_hw_step (thread_info *thread);
+
+ /* Install breakpoints for software single stepping. */
+ void install_software_single_step_breakpoints (lwp_info *lwp);
+
+ /* Fetch the possibly triggered data watchpoint info and store it in
+ CHILD.
+
+ On some archs, like x86, that use debug registers to set
+ watchpoints, it's possible that the way to know which watched
+ address trapped, is to check the register that is used to select
+ which address to watch. Problem is, between setting the watchpoint
+ and reading back which data address trapped, the user may change
+ the set of watchpoints, and, as a consequence, GDB changes the
+ debug registers in the inferior. To avoid reading back a stale
+ stopped-data-address when that happens, we cache in LP the fact
+ that a watchpoint trapped, and the corresponding data address, as
+ soon as we see CHILD stop with a SIGTRAP. If GDB changes the debug
+ registers meanwhile, we have the cached data we can rely on. */
+ bool check_stopped_by_watchpoint (lwp_info *child);
+
+ /* Convert a native/host siginfo object, into/from the siginfo in the
+ layout of the inferiors' architecture. */
+ void siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo,
+ int direction);
+
+ /* Add a process to the common process list, and set its private
+ data. */
+ process_info *add_linux_process (int pid, int attached);
+
+ /* Add a new thread. */
+ lwp_info *add_lwp (ptid_t ptid);
+
+ /* Delete a thread. */
+ void delete_lwp (lwp_info *lwp);
+
+public: /* Make this public because it's used from outside. */
+ /* Attach to an inferior process. Returns 0 on success, ERRNO on
+ error. */
+ int attach_lwp (ptid_t ptid);
+
+private: /* Back to private. */
+ /* Detach from LWP. */
+ void detach_one_lwp (lwp_info *lwp);
+
+ /* Detect zombie thread group leaders, and "exit" them. We can't
+ reap their exits until all other threads in the group have
+ exited. */
+ void check_zombie_leaders ();
+
+ /* Convenience function that is called when the kernel reports an exit
+ event. This decides whether to report the event to GDB as a
+ process exit event, a thread exit event, or to suppress the
+ event. */
+ ptid_t filter_exit_event (lwp_info *event_child,
+ target_waitstatus *ourstatus);
+
+ /* Returns true if THREAD is stopped in a jump pad, and we can't
+ move it out, because we need to report the stop event to GDB. For
+ example, if the user puts a breakpoint in the jump pad, it's
+ because she wants to debug it. */
+ bool stuck_in_jump_pad (thread_info *thread);
+
+ /* Convenience wrapper. Returns information about LWP's fast tracepoint
+ collection status. */
+ fast_tpoint_collect_result linux_fast_tracepoint_collecting
+ (lwp_info *lwp, fast_tpoint_collect_status *status);
+
+ /* This function should only be called if LWP got a SYSCALL_SIGTRAP.
+ Fill *SYSNO with the syscall nr trapped. */
+ void get_syscall_trapinfo (lwp_info *lwp, int *sysno);
+
+ /* Returns true if GDB is interested in the event_child syscall.
+ Only to be called when stopped reason is SYSCALL_SIGTRAP. */
+ bool gdb_catch_this_syscall (lwp_info *event_child);
+