/* Internal interfaces for the GNU/Linux specific target code for gdbserver.
- Copyright (C) 2002-2014 Free Software Foundation, Inc.
+ Copyright (C) 2002-2016 Free Software Foundation, Inc.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
-#include "gdb_thread_db.h"
+#include "nat/linux-nat.h"
+#include "nat/gdb_thread_db.h"
#include <signal.h>
#include "gdbthread.h"
#include "gdb_proc_service.h"
/* Included for ptrace type definitions. */
-#include "linux-ptrace.h"
+#include "nat/linux-ptrace.h"
+#include "target/waitstatus.h" /* For enum target_stop_reason. */
#define PTRACE_XFER_TYPE long
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;
/* &_r_debug. 0 if not yet determined. -1 if no PT_DYNAMIC in Phdrs. */
CORE_ADDR r_debug;
-
- /* This flag is true iff we've just created or attached to the first
- LWP of this process but it has not stopped yet. As soon as it
- does, we need to call the low target's arch_setup callback. */
- int new_inferior;
};
struct lwp_info;
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. */
+ VEC (CORE_ADDR) *(*get_next_pcs) (CORE_ADDR pc, 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);
/* 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, 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);
/* 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. Fill *SYSRET with the
+ return code. Only to be called when inferior is stopped
+ due to SYSCALL_SIGTRAP. */
+ void (*get_syscall_trapinfo) (struct regcache *regcache,
+ int *sysno, int *sysret);
};
extern struct linux_target_ops the_low_target;
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;
+
+ /* 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
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
int linux_pid_exe_is_elf_64_file (int pid, unsigned int *machine);
-void linux_attach_lwp (unsigned long pid);
+/* Attach to PTID. Returns 0 on success, non-zero otherwise (an
+ errno). */
+int linux_attach_lwp (ptid_t ptid);
+
struct lwp_info *find_lwp_pid (ptid_t ptid);
-void linux_stop_lwp (struct lwp_info *lwp);
+/* For linux_stop_lwp see nat/linux-nat.h. */
#ifdef HAVE_LINUX_REGSETS
void initialize_regsets_info (struct regsets_info *regsets_info);
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);
+
/* 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);
+
+extern int have_ptrace_getregset;
projects / deliverable / binutils-gdb.git / blobdiff