+ void stabilize_threads () override;
+
+ bool supports_disable_randomization () override;
+
+ bool supports_qxfer_libraries_svr4 () override;
+
+ int qxfer_libraries_svr4 (const char *annex,
+ unsigned char *readbuf,
+ unsigned const char *writebuf,
+ CORE_ADDR offset, int len) override;
+
+ bool supports_agent () override;
+
+#ifdef HAVE_LINUX_BTRACE
+ btrace_target_info *enable_btrace (ptid_t ptid,
+ const btrace_config *conf) override;
+
+ int disable_btrace (btrace_target_info *tinfo) override;
+
+ int read_btrace (btrace_target_info *tinfo, buffer *buf,
+ enum btrace_read_type type) override;
+
+ int read_btrace_conf (const btrace_target_info *tinfo,
+ buffer *buf) override;
+#endif
+
+ bool supports_range_stepping () override;
+
+ bool supports_pid_to_exec_file () override;
+
+ char *pid_to_exec_file (int pid) override;
+
+ bool supports_multifs () override;
+
+ int multifs_open (int pid, const char *filename, int flags,
+ mode_t mode) override;
+
+ int multifs_unlink (int pid, const char *filename) override;
+
+ ssize_t multifs_readlink (int pid, const char *filename, char *buf,
+ size_t bufsiz) override;
+
+ const char *thread_name (ptid_t thread) override;
+
+#if USE_THREAD_DB
+ bool thread_handle (ptid_t ptid, gdb_byte **handle,
+ int *handle_len) override;
+#endif
+
+ bool supports_catch_syscall () override;
+
+ /* Return the information to access registers. This has public
+ visibility because proc-service uses it. */
+ virtual const regs_info *get_regs_info () = 0;
+
+private:
+
+ /* Handle a GNU/Linux extended wait response. If we see a clone,
+ fork, or vfork event, we need to add the new LWP to our list
+ (and return 0 so as not to report the trap to higher layers).
+ If we see an exec event, we will modify ORIG_EVENT_LWP to point
+ to a new LWP representing the new program. */
+ int handle_extended_wait (lwp_info **orig_event_lwp, int wstat);
+
+ /* Do low-level handling of the event, and check if we should go on
+ and pass it to caller code. Return the affected lwp if we are, or
+ NULL otherwise. */
+ lwp_info *filter_event (int lwpid, int wstat);
+
+ /* Wait for an event from child(ren) WAIT_PTID, and return any that
+ match FILTER_PTID (leaving others pending). The PTIDs can be:
+ minus_one_ptid, to specify any child; a pid PTID, specifying all
+ lwps of a thread group; or a PTID representing a single lwp. Store
+ the stop status through the status pointer WSTAT. OPTIONS is
+ passed to the waitpid call. Return 0 if no event was found and
+ OPTIONS contains WNOHANG. Return -1 if no unwaited-for children
+ was found. Return the PID of the stopped child otherwise. */
+ int wait_for_event_filtered (ptid_t wait_ptid, ptid_t filter_ptid,
+ int *wstatp, int options);
+
+ /* Wait for an event from child(ren) PTID. PTIDs can be:
+ minus_one_ptid, to specify any child; a pid PTID, specifying all
+ lwps of a thread group; or a PTID representing a single lwp. Store
+ the stop status through the status pointer WSTAT. OPTIONS is
+ passed to the waitpid call. Return 0 if no event was found and
+ OPTIONS contains WNOHANG. Return -1 if no unwaited-for children
+ was found. Return the PID of the stopped child otherwise. */
+ int wait_for_event (ptid_t ptid, int *wstatp, int options);
+
+ /* Wait for all children to stop for the SIGSTOPs we just queued. */
+ void wait_for_sigstop ();
+
+ /* Wait for process, returns status. */
+ ptid_t wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
+ int target_options);
+
+ /* Stop all lwps that aren't stopped yet, except EXCEPT, if not NULL.
+ If SUSPEND, then also increase the suspend count of every LWP,
+ except EXCEPT. */
+ void stop_all_lwps (int suspend, lwp_info *except);
+
+ /* Stopped LWPs that the client wanted to be running, that don't have
+ pending statuses, are set to run again, except for EXCEPT, if not
+ NULL. This undoes a stop_all_lwps call. */
+ void unstop_all_lwps (int unsuspend, lwp_info *except);
+
+ /* Start a step-over operation on LWP. When LWP stopped at a
+ breakpoint, to make progress, we need to remove the breakpoint out
+ of the way. If we let other threads run while we do that, they may
+ pass by the breakpoint location and miss hitting it. To avoid
+ that, a step-over momentarily stops all threads while LWP is
+ single-stepped by either hardware or software while the breakpoint
+ is temporarily uninserted from the inferior. When the single-step
+ finishes, we reinsert the breakpoint, and let all threads that are
+ supposed to be running, run again. */
+ void start_step_over (lwp_info *lwp);
+
+ /* If there's a step over in progress, wait until all threads stop
+ (that is, until the stepping thread finishes its step), and
+ unsuspend all lwps. The stepping thread ends with its status
+ pending, which is processed later when we get back to processing
+ events. */
+ void complete_ongoing_step_over ();
+
+ /* Finish a step-over. Reinsert the breakpoint we had uninserted in
+ start_step_over, if still there, and delete any single-step
+ breakpoints we've set, on non hardware single-step targets.
+ Return true if step over finished. */
+ bool finish_step_over (lwp_info *lwp);
+
+ /* When we finish a step-over, set threads running again. If there's
+ another thread that may need a step-over, now's the time to start
+ it. Eventually, we'll move all threads past their breakpoints. */
+ void proceed_all_lwps ();
+
+ /* The reason we resume in the caller, is because we want to be able
+ to pass lwp->status_pending as WSTAT, and we need to clear
+ status_pending_p before resuming, otherwise, resume_one_lwp
+ refuses to resume. */
+ bool maybe_move_out_of_jump_pad (lwp_info *lwp, int *wstat);
+
+ /* Move THREAD out of the jump pad. */
+ void move_out_of_jump_pad (thread_info *thread);
+
+ /* Call low_arch_setup on THREAD. */
+ void arch_setup_thread (thread_info *thread);
+
+#ifdef HAVE_LINUX_USRREGS
+ /* Fetch one register. */
+ void fetch_register (const usrregs_info *usrregs, regcache *regcache,
+ int regno);
+
+ /* Store one register. */
+ void store_register (const usrregs_info *usrregs, regcache *regcache,
+ int regno);
+#endif
+
+ /* Fetch all registers, or just one, from the child process.
+ If REGNO is -1, do this for all registers, skipping any that are
+ assumed to have been retrieved by regsets_fetch_inferior_registers,
+ unless ALL is non-zero.
+ Otherwise, REGNO specifies which register (so we can save time). */
+ void usr_fetch_inferior_registers (const regs_info *regs_info,
+ regcache *regcache, int regno, int all);
+
+ /* Store our register values back into the inferior.
+ If REGNO is -1, do this for all registers, skipping any that are
+ assumed to have been saved by regsets_store_inferior_registers,
+ unless ALL is non-zero.
+ Otherwise, REGNO specifies which register (so we can save time). */
+ 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);
+
+ /* 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);
+
+protected:
+ /* The architecture-specific "low" methods are listed below. */
+
+ /* Architecture-specific setup for the current thread. */
+ virtual void low_arch_setup () = 0;
+
+ /* Return false if we can fetch/store the register, true if we cannot
+ fetch/store the register. */
+ virtual bool low_cannot_fetch_register (int regno) = 0;
+
+ virtual bool low_cannot_store_register (int regno) = 0;