X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdbserver%2Flinux-low.h;h=5fed2ee2ca205ef7e3d3e0cc4c608be7c855043e;hb=9a17a136439c200b13a69d453f38824b7edc522c;hp=0fdd8ceb9457facc0ec58a549928d9d6c1af26ed;hpb=9db9aa232ac37e4dca92733678748adc1bfc7ef0;p=deliverable%2Fbinutils-gdb.git diff --git a/gdbserver/linux-low.h b/gdbserver/linux-low.h index 0fdd8ceb94..5fed2ee2ca 100644 --- a/gdbserver/linux-low.h +++ b/gdbserver/linux-low.h @@ -129,97 +129,6 @@ struct process_info_private struct lwp_info; -struct linux_target_ops -{ - int (*stopped_by_watchpoint) (void); - CORE_ADDR (*stopped_data_address) (void); - - /* Hooks to reformat register data for PEEKUSR/POKEUSR (in particular - for registers smaller than an xfer unit). */ - void (*collect_ptrace_register) (struct regcache *regcache, - int regno, char *buf); - void (*supply_ptrace_register) (struct regcache *regcache, - int regno, const char *buf); - - /* Hook to convert from target format to ptrace format and back. - Returns true if any conversion was done; false otherwise. - If DIRECTION is 1, then copy from INF to NATIVE. - If DIRECTION is 0, copy from NATIVE to INF. */ - int (*siginfo_fixup) (siginfo_t *native, gdb_byte *inf, int direction); - - /* Hook to call when a new process is created or attached to. - If extra per-process architecture-specific data is needed, - allocate it here. */ - struct arch_process_info * (*new_process) (void); - - /* Hook to call when a process is being deleted. If extra per-process - architecture-specific data is needed, delete it here. */ - void (*delete_process) (struct arch_process_info *info); - - /* Hook to call when a new thread is detected. - If extra per-thread architecture-specific data is needed, - allocate it here. */ - void (*new_thread) (struct lwp_info *); - - /* Hook to call when a thread is being deleted. If extra per-thread - architecture-specific data is needed, delete it here. */ - void (*delete_thread) (struct arch_lwp_info *); - - /* Hook to call, if any, when a new fork is attached. */ - void (*new_fork) (struct process_info *parent, struct process_info *child); - - /* Hook to call prior to resuming a thread. */ - void (*prepare_to_resume) (struct lwp_info *); - - /* Hook to support target specific qSupported. */ - void (*process_qsupported) (char **, int count); - - /* Returns true if the low target supports tracepoints. */ - int (*supports_tracepoints) (void); - - /* Fill ADDRP with the thread area address of LWPID. Returns 0 on - success, -1 on failure. */ - int (*get_thread_area) (int lwpid, CORE_ADDR *addrp); - - /* Install a fast tracepoint jump pad. See target.h for - comments. */ - int (*install_fast_tracepoint_jump_pad) (CORE_ADDR tpoint, CORE_ADDR tpaddr, - CORE_ADDR collector, - CORE_ADDR lockaddr, - ULONGEST orig_size, - CORE_ADDR *jump_entry, - CORE_ADDR *trampoline, - ULONGEST *trampoline_size, - unsigned char *jjump_pad_insn, - ULONGEST *jjump_pad_insn_size, - CORE_ADDR *adjusted_insn_addr, - CORE_ADDR *adjusted_insn_addr_end, - char *err); - - /* Return the bytecode operations vector for the current inferior. - Returns NULL if bytecode compilation is not supported. */ - struct emit_ops *(*emit_ops) (void); - - /* Return the minimum length of an instruction that can be safely overwritten - for use as a fast tracepoint. */ - int (*get_min_fast_tracepoint_insn_len) (void); - - /* Returns true if the low target supports range stepping. */ - int (*supports_range_stepping) (void); - - /* See target.h. */ - int (*supports_hardware_single_step) (void); - - /* Fill *SYSNO with the syscall nr trapped. Only to be called when - inferior is stopped due to SYSCALL_SIGTRAP. */ - void (*get_syscall_trapinfo) (struct regcache *regcache, int *sysno); - - /* See target.h. */ - int (*get_ipa_tdesc_idx) (void); -}; - -extern struct linux_target_ops the_low_target; - /* Target ops definitions for a Linux target. */ class linux_process_target : public process_stratum_target @@ -339,10 +248,6 @@ public: unsigned char *myaddr, unsigned int len) override; #endif - void process_qsupported (char **features, int count) override; - - bool supports_tracepoints () override; - CORE_ADDR read_pc (regcache *regcache) override; void write_pc (regcache *regcache, CORE_ADDR pc) override; @@ -357,26 +262,6 @@ public: void stabilize_threads () override; - bool supports_fast_tracepoints () override; - - int install_fast_tracepoint_jump_pad (CORE_ADDR tpoint, - CORE_ADDR tpaddr, - CORE_ADDR collector, - CORE_ADDR lockaddr, - ULONGEST orig_size, - CORE_ADDR *jump_entry, - CORE_ADDR *trampoline, - ULONGEST *trampoline_size, - unsigned char *jjump_pad_insn, - ULONGEST *jjump_pad_insn_size, - CORE_ADDR *adjusted_insn_addr, - CORE_ADDR *adjusted_insn_addr_end, - char *err) override; - - int get_min_fast_tracepoint_insn_len () override; - - struct emit_ops *emit_ops () override; - bool supports_disable_randomization () override; bool supports_qxfer_libraries_svr4 () override; @@ -426,8 +311,6 @@ public: bool supports_catch_syscall () override; - int get_ipa_tdesc_idx () override; - /* Return the information to access registers. This has public visibility because proc-service uses it. */ virtual const regs_info *get_regs_info () = 0; @@ -501,6 +384,12 @@ private: 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. */ @@ -619,9 +508,83 @@ private: 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. */ @@ -665,6 +628,64 @@ protected: virtual int low_remove_point (raw_bkpt_type type, CORE_ADDR addr, int size, raw_breakpoint *bp); + virtual bool low_stopped_by_watchpoint (); + + virtual CORE_ADDR low_stopped_data_address (); + + /* Hooks to reformat register data for PEEKUSR/POKEUSR (in particular + for registers smaller than an xfer unit). */ + virtual void low_collect_ptrace_register (regcache *regcache, int regno, + char *buf); + + virtual void low_supply_ptrace_register (regcache *regcache, int regno, + const char *buf); + + /* Hook to convert from target format to ptrace format and back. + Returns true if any conversion was done; false otherwise. + If DIRECTION is 1, then copy from INF to NATIVE. + If DIRECTION is 0, copy from NATIVE to INF. */ + virtual bool low_siginfo_fixup (siginfo_t *native, gdb_byte *inf, + int direction); + + /* Hook to call when a new process is created or attached to. + If extra per-process architecture-specific data is needed, + allocate it here. */ + virtual arch_process_info *low_new_process (); + + /* Hook to call when a process is being deleted. If extra per-process + architecture-specific data is needed, delete it here. */ + virtual void low_delete_process (arch_process_info *info); + + /* Hook to call when a new thread is detected. + If extra per-thread architecture-specific data is needed, + allocate it here. */ + virtual void low_new_thread (lwp_info *); + + /* Hook to call when a thread is being deleted. If extra per-thread + architecture-specific data is needed, delete it here. */ + virtual void low_delete_thread (arch_lwp_info *); + + /* Hook to call, if any, when a new fork is attached. */ + virtual void low_new_fork (process_info *parent, process_info *child); + + /* Hook to call prior to resuming a thread. */ + virtual void low_prepare_to_resume (lwp_info *lwp); + + /* Fill ADDRP with the thread area address of LWPID. Returns 0 on + success, -1 on failure. */ + virtual int low_get_thread_area (int lwpid, CORE_ADDR *addrp); + + /* Returns true if the low target supports range stepping. */ + virtual bool low_supports_range_stepping (); + + /* Return true if the target supports catch syscall. Such targets + override the low_get_syscall_trapinfo method below. */ + virtual bool low_supports_catch_syscall (); + + /* Fill *SYSNO with the syscall nr trapped. Only to be called when + inferior is stopped due to SYSCALL_SIGTRAP. */ + virtual void low_get_syscall_trapinfo (regcache *regcache, int *sysno); + /* How many bytes the PC should be decremented after a break. */ virtual int low_decr_pc_after_break (); };