X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbserver%2Flinux-low.h;h=b99236f7d93a2a723338be2dfa3f995d5887aa54;hb=0747795c085d3b2a35da6bb474f32c58ce1b70c8;hp=65d68a3496250ec5c74e84e127f268fe2c27b015;hpb=6a271cae85843023ce9c046c040b643158d85054;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/gdbserver/linux-low.h b/gdb/gdbserver/linux-low.h
index 65d68a3496..b99236f7d9 100644
--- a/gdb/gdbserver/linux-low.h
+++ b/gdb/gdbserver/linux-low.h
@@ -1,6 +1,5 @@
/* Internal interfaces for the GNU/Linux specific target code for gdbserver.
- Copyright (C) 2002, 2004, 2005, 2007, 2008, 2009, 2010
- Free Software Foundation, Inc.
+ Copyright (C) 2002-2019 Free Software Foundation, Inc.
This file is part of GDB.
@@ -17,12 +16,20 @@
You should have received a copy of the GNU General Public License
along with this program. If not, see . */
-#ifdef HAVE_THREAD_DB_H
-#include
-#endif
+#include "nat/linux-nat.h"
+#include "nat/gdb_thread_db.h"
+#include
+#include "gdbthread.h"
#include "gdb_proc_service.h"
+/* Included for ptrace type definitions. */
+#include "nat/linux-ptrace.h"
+#include "target/waitstatus.h" /* For enum target_stop_reason. */
+#include "tracepoint.h"
+
+#define PTRACE_XFER_TYPE long
+
#ifdef HAVE_LINUX_REGSETS
typedef void (*regset_fill_func) (struct regcache *, void *);
typedef void (*regset_store_func) (struct regcache *, const void *);
@@ -32,6 +39,11 @@ enum regset_type {
EXTENDED_REGS,
};
+/* The arch's regsets array initializer must be terminated with a NULL
+ regset. */
+#define NULL_REGSET \
+ { 0, 0, 0, -1, (enum regset_type) -1, NULL, NULL }
+
struct regset_info
{
int get_request, set_request;
@@ -43,10 +55,60 @@ struct regset_info
regset_fill_func fill_function;
regset_store_func store_function;
};
-extern struct regset_info target_regsets[];
+
+/* Aggregation of all the supported regsets of a given
+ architecture/mode. */
+
+struct regsets_info
+{
+ /* The regsets array. */
+ struct regset_info *regsets;
+
+ /* The number of regsets in the REGSETS array. */
+ int num_regsets;
+
+ /* If we get EIO on a regset, do not try it again. Note the set of
+ supported regsets may depend on processor mode on biarch
+ machines. This is a (lazily allocated) array holding one boolean
+ byte (0/1) per regset, with each element corresponding to the
+ regset in the REGSETS array above at the same offset. */
+ char *disabled_regsets;
+};
+
#endif
-struct siginfo;
+/* Mapping between the general-purpose registers in `struct user'
+ format and GDB's register array layout. */
+
+struct usrregs_info
+{
+ /* The number of registers accessible. */
+ int num_regs;
+
+ /* The registers map. */
+ int *regmap;
+};
+
+/* All info needed to access an architecture/mode's registers. */
+
+struct regs_info
+{
+ /* Regset support bitmap: 1 for registers that are transferred as a part
+ of a regset, 0 for ones that need to be handled individually. This
+ can be NULL if all registers are transferred with regsets or regsets
+ are not supported. */
+ unsigned char *regset_bitmap;
+
+ /* Info used when accessing registers with PTRACE_PEEKUSER /
+ PTRACE_POKEUSER. This can be NULL if all registers are
+ transferred with regsets .*/
+ struct usrregs_info *usrregs;
+
+#ifdef HAVE_LINUX_REGSETS
+ /* Info used when accessing registers with regsets. */
+ struct regsets_info *regsets_info;
+#endif
+};
struct process_info_private
{
@@ -56,6 +118,9 @@ struct process_info_private
/* libthread_db-specific additions. Not NULL if this process has loaded
thread_db, and it is active. */
struct thread_db *thread_db;
+
+ /* &_r_debug. 0 if not yet determined. -1 if no PT_DYNAMIC in Phdrs. */
+ CORE_ADDR r_debug;
};
struct lwp_info;
@@ -65,27 +130,44 @@ struct linux_target_ops
/* Architecture-specific setup. */
void (*arch_setup) (void);
- int num_regs;
- int *regmap;
+ const struct regs_info *(*regs_info) (void);
int (*cannot_fetch_register) (int);
/* Returns 0 if we can store the register, 1 if we can not
store the register, and 2 if failure to store the register
is acceptable. */
int (*cannot_store_register) (int);
+
+ /* Hook to fetch a register in some non-standard way. Used for
+ example by backends that have read-only registers with hardcoded
+ values (e.g., IA64's gr0/fr0/fr1). Returns true if register
+ REGNO was supplied, false if not, and we should fallback to the
+ standard ptrace methods. */
+ int (*fetch_register) (struct regcache *regcache, int regno);
+
CORE_ADDR (*get_pc) (struct regcache *regcache);
void (*set_pc) (struct regcache *regcache, CORE_ADDR newpc);
- const unsigned char *breakpoint;
- int breakpoint_len;
- CORE_ADDR (*breakpoint_reinsert_addr) (void);
+
+ /* See target.h for details. */
+ int (*breakpoint_kind_from_pc) (CORE_ADDR *pcptr);
+
+ /* See target.h for details. */
+ const gdb_byte *(*sw_breakpoint_from_kind) (int kind, int *size);
+
+ /* Find the next possible PCs after the current instruction executes. */
+ std::vector (*get_next_pcs) (struct regcache *regcache);
int decr_pc_after_break;
int (*breakpoint_at) (CORE_ADDR pc);
/* Breakpoint and watchpoint related functions. See target.h for
comments. */
- int (*insert_point) (char type, CORE_ADDR addr, int len);
- int (*remove_point) (char type, CORE_ADDR addr, int len);
+ int (*supports_z_point_type) (char z_type);
+ int (*insert_point) (enum raw_bkpt_type type, CORE_ADDR addr,
+ int size, struct raw_breakpoint *bp);
+ int (*remove_point) (enum raw_bkpt_type type, CORE_ADDR addr,
+ int size, struct raw_breakpoint *bp);
+
int (*stopped_by_watchpoint) (void);
CORE_ADDR (*stopped_data_address) (void);
@@ -100,23 +182,34 @@ struct linux_target_ops
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) (struct siginfo *native, void *inf, int direction);
+ 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. */
- struct arch_lwp_info * (*new_thread) (void);
+ 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) (const char *);
+ void (*process_qsupported) (char **, int count);
/* Returns true if the low target supports tracepoints. */
int (*supports_tracepoints) (void);
@@ -132,31 +225,58 @@ struct linux_target_ops
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);
+ 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 (*breakpoint_kind_from_current_state) (CORE_ADDR *pcptr);
+
+ /* 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;
-#define ptid_of(proc) ((proc)->head.id)
-#define pid_of(proc) ptid_get_pid ((proc)->head.id)
-#define lwpid_of(proc) ptid_get_lwp ((proc)->head.id)
+#define get_thread_lwp(thr) ((struct lwp_info *) (thread_target_data (thr)))
+#define get_lwp_thread(lwp) ((lwp)->thread)
+
+/* This struct is recorded in the target_data field of struct thread_info.
-#define get_lwp(inf) ((struct lwp_info *)(inf))
-#define get_thread_lwp(thr) (get_lwp (inferior_target_data (thr)))
-#define get_lwp_thread(proc) ((struct thread_info *) \
- find_inferior_id (&all_threads, \
- get_lwp (proc)->head.id))
+ On linux ``all_threads'' is keyed by the LWP ID, which we use as the
+ GDB protocol representation of the thread ID. Threads also have
+ a "process ID" (poorly named) which is (presently) the same as the
+ LWP ID.
+
+ There is also ``all_processes'' is keyed by the "overall process ID",
+ which GNU/Linux calls tgid, "thread group ID". */
struct lwp_info
{
- struct inferior_list_entry head;
+ /* Backlink to the parent object. */
+ struct thread_info *thread;
/* If this flag is set, the next SIGSTOP will be ignored (the
process will be immediately resumed). This means that either we
@@ -174,16 +294,31 @@ struct lwp_info
event already received in a wait()). */
int stopped;
- /* If this flag is set, the lwp is known to be dead already (exit
- event already received in a wait(), and is cached in
- status_pending). */
- int dead;
+ /* Signal whether we are in a SYSCALL_ENTRY or
+ in a SYSCALL_RETURN event.
+ Values:
+ - TARGET_WAITKIND_SYSCALL_ENTRY
+ - TARGET_WAITKIND_SYSCALL_RETURN */
+ enum target_waitkind syscall_state;
/* When stopped is set, the last wait status recorded for this lwp. */
int last_status;
- /* When stopped is set, this is where the lwp stopped, with
- decr_pc_after_break already accounted for. */
+ /* If WAITSTATUS->KIND != TARGET_WAITKIND_IGNORE, the waitstatus for
+ this LWP's last event, to pass to GDB without any further
+ processing. This is used to store extended ptrace event
+ information or exit status until it can be reported to GDB. */
+ struct target_waitstatus waitstatus;
+
+ /* A pointer to the fork child/parent relative. Valid only while
+ the parent fork event is not reported to higher layers. Used to
+ avoid wildcard vCont actions resuming a fork child before GDB is
+ notified about the parent's fork event. */
+ struct lwp_info *fork_relative;
+
+ /* When stopped is set, this is where the lwp last stopped, with
+ decr_pc_after_break already accounted for. If the LWP is
+ running, this is the address at which the lwp was resumed. */
CORE_ADDR stop_pc;
/* If this flag is set, STATUS_PENDING is a waitstatus that has not yet
@@ -191,9 +326,9 @@ struct lwp_info
int status_pending_p;
int status_pending;
- /* STOPPED_BY_WATCHPOINT is non-zero if this LWP stopped with a data
- watchpoint trap. */
- int stopped_by_watchpoint;
+ /* The reason the LWP last stopped, if we need to track it
+ (breakpoint, watchpoint, etc.) */
+ enum target_stop_reason stop_reason;
/* On architectures where it is possible to know the data address of
a triggered watchpoint, STOPPED_DATA_ADDRESS is non-zero, and
@@ -209,6 +344,12 @@ struct lwp_info
level on this process was a single-step. */
int stepping;
+ /* Range to single step within. This is a copy of the step range
+ passed along the last resume request. See 'struct
+ thread_resume'. */
+ CORE_ADDR step_range_start; /* Inclusive */
+ CORE_ADDR step_range_end; /* Exclusive */
+
/* If this flag is set, we need to set the event request flags the
next time we see this LWP stop. */
int must_set_ptrace_flags;
@@ -221,12 +362,11 @@ struct lwp_info
and then processed and cleared in linux_resume_one_lwp. */
struct thread_resume *resume;
- /* True if it is known that this lwp is presently collecting a fast
- tracepoint (it is in the jump pad or in some code that will
- return to the jump pad. Normally, we won't care about this, but
- we will if a signal arrives to this lwp while it is
- collecting. */
- int collecting_fast_tracepoint;
+ /* Information bout this lwp's fast tracepoint collection status (is it
+ currently stopped in the jump pad, and if so, before or at/after the
+ relocated instruction). Normally, we won't care about this, but we will
+ if a signal arrives to this lwp while it is collecting. */
+ fast_tpoint_collect_result collecting_fast_tracepoint;
/* If this is non-zero, it points to a chain of signals which need
to be reported to GDB. These were deferred because the thread
@@ -237,35 +377,56 @@ struct lwp_info
a exit-jump-pad-quickly breakpoint. This is it. */
struct breakpoint *exit_jump_pad_bkpt;
- /* True if the LWP was seen stop at an internal breakpoint and needs
- stepping over later when it is resumed. */
- int need_step_over;
-
+#ifdef USE_THREAD_DB
int thread_known;
-#ifdef HAVE_THREAD_DB_H
/* The thread handle, used for e.g. TLS access. Only valid if
THREAD_KNOWN is set. */
td_thrhandle_t th;
+
+ /* The pthread_t handle. */
+ thread_t thread_handle;
#endif
/* Arch-specific additions. */
struct arch_lwp_info *arch_private;
};
-extern struct inferior_list all_lwps;
+int linux_pid_exe_is_elf_64_file (int pid, unsigned int *machine);
-char *linux_child_pid_to_exec_file (int pid);
-int elf_64_file_p (const char *file);
+/* Attach to PTID. Returns 0 on success, non-zero otherwise (an
+ errno). */
+int linux_attach_lwp (ptid_t ptid);
-void linux_attach_lwp (unsigned long pid);
struct lwp_info *find_lwp_pid (ptid_t ptid);
-int linux_get_thread_area (int lwpid, CORE_ADDR *area);
+/* For linux_stop_lwp see nat/linux-nat.h. */
+
+#ifdef HAVE_LINUX_REGSETS
+void initialize_regsets_info (struct regsets_info *regsets_info);
+#endif
+
+void initialize_low_arch (void);
+
+void linux_set_pc_32bit (struct regcache *regcache, CORE_ADDR pc);
+CORE_ADDR linux_get_pc_32bit (struct regcache *regcache);
+
+void linux_set_pc_64bit (struct regcache *regcache, CORE_ADDR pc);
+CORE_ADDR linux_get_pc_64bit (struct regcache *regcache);
/* From thread-db.c */
-int thread_db_init (int use_events);
+int thread_db_init (void);
void thread_db_detach (struct process_info *);
void thread_db_mourn (struct process_info *);
int thread_db_handle_monitor_command (char *);
int thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
CORE_ADDR load_module, CORE_ADDR *address);
int thread_db_look_up_one_symbol (const char *name, CORE_ADDR *addrp);
+
+/* Called from linux-low.c when a clone event is detected. Upon entry,
+ both the clone and the parent should be stopped. This function does
+ whatever is required have the clone under thread_db's control. */
+
+void thread_db_notice_clone (struct thread_info *parent_thr, ptid_t child_ptid);
+
+bool thread_db_thread_handle (ptid_t ptid, gdb_byte **handle, int *handle_len);
+
+extern int have_ptrace_getregset;