X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Famd64-linux-nat.c;h=f4a12db176d4148d81f55ce586cd9b3dbc485495;hb=9d5777a34cbf1c1497e1c76f455381a643dfd2b1;hp=4f7a8eaaeee56f919046686b467173b318d937a8;hpb=9b254dd1ce46c19dde1dde5b8d1e22e862dfacce;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/amd64-linux-nat.c b/gdb/amd64-linux-nat.c index 4f7a8eaaee..f4a12db176 100644 --- a/gdb/amd64-linux-nat.c +++ b/gdb/amd64-linux-nat.c @@ -1,7 +1,6 @@ /* Native-dependent code for GNU/Linux x86-64. - Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 - Free Software Foundation, Inc. + Copyright (C) 2001-2012 Free Software Foundation, Inc. Contributed by Jiri Smid, SuSE Labs. This file is part of GDB. @@ -23,21 +22,25 @@ #include "inferior.h" #include "gdbcore.h" #include "regcache.h" +#include "regset.h" #include "linux-nat.h" #include "amd64-linux-tdep.h" #include "gdb_assert.h" #include "gdb_string.h" +#include "elf/common.h" +#include #include #include #include #include +#include #include /* FIXME ezannoni-2003-07-09: we need to be included after because the latter redefines FS and GS for no apparent reason, and those definitions don't match the ones that libpthread_db uses, which come from . */ -/* ezannoni-2003-07-09: I think this is fixed. The extraneous defs have +/* ezannoni-2003-07-09: I think this is fixed. The extraneous defs have been removed from ptrace.h in the kernel. However, better safe than sorry. */ #include @@ -50,31 +53,27 @@ #include "amd64-tdep.h" #include "i386-linux-tdep.h" #include "amd64-nat.h" +#include "i386-nat.h" +#include "i386-xstate.h" -/* Mapping between the general-purpose registers in GNU/Linux x86-64 - `struct user' format and GDB's register cache layout. */ - -static int amd64_linux_gregset64_reg_offset[] = -{ - RAX * 8, RBX * 8, /* %rax, %rbx */ - RCX * 8, RDX * 8, /* %rcx, %rdx */ - RSI * 8, RDI * 8, /* %rsi, %rdi */ - RBP * 8, RSP * 8, /* %rbp, %rsp */ - R8 * 8, R9 * 8, /* %r8 ... */ - R10 * 8, R11 * 8, - R12 * 8, R13 * 8, - R14 * 8, R15 * 8, /* ... %r15 */ - RIP * 8, EFLAGS * 8, /* %rip, %eflags */ - CS * 8, SS * 8, /* %cs, %ss */ - DS * 8, ES * 8, /* %ds, %es */ - FS * 8, GS * 8, /* %fs, %gs */ - -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, - ORIG_RAX * 8 +#ifndef PTRACE_GETREGSET +#define PTRACE_GETREGSET 0x4204 +#endif + +#ifndef PTRACE_SETREGSET +#define PTRACE_SETREGSET 0x4205 +#endif + +/* Per-thread arch-specific data we want to keep. */ + +struct arch_lwp_info +{ + /* Non-zero if our copy differs from what's recorded in the thread. */ + int debug_registers_changed; }; - + +/* Does the current host support PTRACE_GETREGSET? */ +static int have_ptrace_getregset = -1; /* Mapping between the general-purpose registers in GNU/Linux x86-64 `struct user' format and GDB's register cache layout for GNU/Linux @@ -98,6 +97,7 @@ static int amd64_linux_gregset32_reg_offset[] = -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, ORIG_RAX * 8 /* "orig_eax" */ }; @@ -155,8 +155,10 @@ fill_fpregset (const struct regcache *regcache, registers). */ static void -amd64_linux_fetch_inferior_registers (struct regcache *regcache, int regnum) +amd64_linux_fetch_inferior_registers (struct target_ops *ops, + struct regcache *regcache, int regnum) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); int tid; /* GNU/Linux LWP ID's are process ID's. */ @@ -164,7 +166,7 @@ amd64_linux_fetch_inferior_registers (struct regcache *regcache, int regnum) if (tid == 0) tid = PIDGET (inferior_ptid); /* Not a threaded program. */ - if (regnum == -1 || amd64_native_gregset_supplies_p (regnum)) + if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum)) { elf_gregset_t regs; @@ -176,14 +178,30 @@ amd64_linux_fetch_inferior_registers (struct regcache *regcache, int regnum) return; } - if (regnum == -1 || !amd64_native_gregset_supplies_p (regnum)) + if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum)) { elf_fpregset_t fpregs; - if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0) - perror_with_name (_("Couldn't get floating point status")); + if (have_ptrace_getregset) + { + char xstateregs[I386_XSTATE_MAX_SIZE]; + struct iovec iov; + + iov.iov_base = xstateregs; + iov.iov_len = sizeof (xstateregs); + if (ptrace (PTRACE_GETREGSET, tid, + (unsigned int) NT_X86_XSTATE, (long) &iov) < 0) + perror_with_name (_("Couldn't get extended state status")); + + amd64_supply_xsave (regcache, -1, xstateregs); + } + else + { + if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0) + perror_with_name (_("Couldn't get floating point status")); - amd64_supply_fxsave (regcache, -1, &fpregs); + amd64_supply_fxsave (regcache, -1, &fpregs); + } } } @@ -192,8 +210,10 @@ amd64_linux_fetch_inferior_registers (struct regcache *regcache, int regnum) registers). */ static void -amd64_linux_store_inferior_registers (struct regcache *regcache, int regnum) +amd64_linux_store_inferior_registers (struct target_ops *ops, + struct regcache *regcache, int regnum) { + struct gdbarch *gdbarch = get_regcache_arch (regcache); int tid; /* GNU/Linux LWP ID's are process ID's. */ @@ -201,7 +221,7 @@ amd64_linux_store_inferior_registers (struct regcache *regcache, int regnum) if (tid == 0) tid = PIDGET (inferior_ptid); /* Not a threaded program. */ - if (regnum == -1 || amd64_native_gregset_supplies_p (regnum)) + if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum)) { elf_gregset_t regs; @@ -217,26 +237,42 @@ amd64_linux_store_inferior_registers (struct regcache *regcache, int regnum) return; } - if (regnum == -1 || !amd64_native_gregset_supplies_p (regnum)) + if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum)) { elf_fpregset_t fpregs; - if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0) - perror_with_name (_("Couldn't get floating point status")); + if (have_ptrace_getregset) + { + char xstateregs[I386_XSTATE_MAX_SIZE]; + struct iovec iov; + + iov.iov_base = xstateregs; + iov.iov_len = sizeof (xstateregs); + if (ptrace (PTRACE_GETREGSET, tid, + (unsigned int) NT_X86_XSTATE, (long) &iov) < 0) + perror_with_name (_("Couldn't get extended state status")); - amd64_collect_fxsave (regcache, regnum, &fpregs); + amd64_collect_xsave (regcache, regnum, xstateregs, 0); - if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0) - perror_with_name (_("Couldn't write floating point status")); + if (ptrace (PTRACE_SETREGSET, tid, + (unsigned int) NT_X86_XSTATE, (long) &iov) < 0) + perror_with_name (_("Couldn't write extended state status")); + } + else + { + if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0) + perror_with_name (_("Couldn't get floating point status")); - return; + amd64_collect_fxsave (regcache, regnum, &fpregs); + + if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0) + perror_with_name (_("Couldn't write floating point status")); + } } } /* Support for debug registers. */ -static unsigned long amd64_linux_dr[DR_CONTROL + 1]; - static unsigned long amd64_linux_dr_get (ptid_t ptid, int regnum) { @@ -247,24 +283,17 @@ amd64_linux_dr_get (ptid_t ptid, int regnum) if (tid == 0) tid = PIDGET (ptid); - /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the - ptrace call fails breaks debugging remote targets. The correct - way to fix this is to add the hardware breakpoint and watchpoint - stuff to the target vector. For now, just return zero if the - ptrace call fails. */ errno = 0; value = ptrace (PTRACE_PEEKUSER, tid, offsetof (struct user, u_debugreg[regnum]), 0); if (errno != 0) -#if 0 perror_with_name (_("Couldn't read debug register")); -#else - return 0; -#endif return value; } +/* Set debug register REGNUM to VALUE in only the one LWP of PTID. */ + static void amd64_linux_dr_set (ptid_t ptid, int regnum, unsigned long value) { @@ -281,51 +310,129 @@ amd64_linux_dr_set (ptid_t ptid, int regnum, unsigned long value) perror_with_name (_("Couldn't write debug register")); } -void -amd64_linux_dr_set_control (unsigned long control) +/* Return the inferior's debug register REGNUM. */ + +static CORE_ADDR +amd64_linux_dr_get_addr (int regnum) { - struct lwp_info *lp; - ptid_t ptid; + /* DR6 and DR7 are retrieved with some other way. */ + gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR); - amd64_linux_dr[DR_CONTROL] = control; - ALL_LWPS (lp, ptid) - amd64_linux_dr_set (ptid, DR_CONTROL, control); + return amd64_linux_dr_get (inferior_ptid, regnum); } -void -amd64_linux_dr_set_addr (int regnum, CORE_ADDR addr) +/* Return the inferior's DR7 debug control register. */ + +static unsigned long +amd64_linux_dr_get_control (void) { - struct lwp_info *lp; - ptid_t ptid; + return amd64_linux_dr_get (inferior_ptid, DR_CONTROL); +} - gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR); +/* Get DR_STATUS from only the one LWP of INFERIOR_PTID. */ - amd64_linux_dr[DR_FIRSTADDR + regnum] = addr; - ALL_LWPS (lp, ptid) - amd64_linux_dr_set (ptid, DR_FIRSTADDR + regnum, addr); +static unsigned long +amd64_linux_dr_get_status (void) +{ + return amd64_linux_dr_get (inferior_ptid, DR_STATUS); } -void -amd64_linux_dr_reset_addr (int regnum) +/* Callback for linux_nat_iterate_watchpoint_lwps. Update the debug registers + of LWP. */ + +static int +update_debug_registers_callback (struct lwp_info *lwp, void *arg) { - amd64_linux_dr_set_addr (regnum, 0); + if (lwp->arch_private == NULL) + lwp->arch_private = XCNEW (struct arch_lwp_info); + + /* The actual update is done later just before resuming the lwp, we + just mark that the registers need updating. */ + lwp->arch_private->debug_registers_changed = 1; + + /* If the lwp isn't stopped, force it to momentarily pause, so we + can update its debug registers. */ + if (!lwp->stopped) + linux_stop_lwp (lwp); + + /* Continue the iteration. */ + return 0; } -unsigned long -amd64_linux_dr_get_status (void) +/* Set DR_CONTROL to CONTROL in all LWPs of the current inferior. */ + +static void +amd64_linux_dr_set_control (unsigned long control) { - return amd64_linux_dr_get (inferior_ptid, DR_STATUS); + linux_nat_iterate_watchpoint_lwps (update_debug_registers_callback, NULL); +} + +/* Set address REGNUM (zero based) to ADDR in all LWPs of the current + inferior. */ + +static void +amd64_linux_dr_set_addr (int regnum, CORE_ADDR addr) +{ + gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR); + + linux_nat_iterate_watchpoint_lwps (update_debug_registers_callback, NULL); +} + +/* Called when resuming a thread. + If the debug regs have changed, update the thread's copies. */ + +static void +amd64_linux_prepare_to_resume (struct lwp_info *lwp) +{ + int clear_status = 0; + + /* NULL means this is the main thread still going through the shell, + or, no watchpoint has been set yet. In that case, there's + nothing to do. */ + if (lwp->arch_private == NULL) + return; + + if (lwp->arch_private->debug_registers_changed) + { + struct i386_debug_reg_state *state = i386_debug_reg_state (); + int i; + + /* On Linux kernel before 2.6.33 commit + 72f674d203cd230426437cdcf7dd6f681dad8b0d + if you enable a breakpoint by the DR_CONTROL bits you need to have + already written the corresponding DR_FIRSTADDR...DR_LASTADDR registers. + + Ensure DR_CONTROL gets written as the very last register here. */ + + for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++) + if (state->dr_ref_count[i] > 0) + { + amd64_linux_dr_set (lwp->ptid, i, state->dr_mirror[i]); + + /* If we're setting a watchpoint, any change the inferior + had done itself to the debug registers needs to be + discarded, otherwise, i386_stopped_data_address can get + confused. */ + clear_status = 1; + } + + amd64_linux_dr_set (lwp->ptid, DR_CONTROL, state->dr_control_mirror); + + lwp->arch_private->debug_registers_changed = 0; + } + + if (clear_status || lwp->stopped_by_watchpoint) + amd64_linux_dr_set (lwp->ptid, DR_STATUS, 0); } static void -amd64_linux_new_thread (ptid_t ptid) +amd64_linux_new_thread (struct lwp_info *lp) { - int i; + struct arch_lwp_info *info = XCNEW (struct arch_lwp_info); - for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++) - amd64_linux_dr_set (ptid, i, amd64_linux_dr[i]); + info->debug_registers_changed = 1; - amd64_linux_dr_set (ptid, DR_CONTROL, amd64_linux_dr[DR_CONTROL]); + lp->arch_private = info; } @@ -336,7 +443,7 @@ ps_err_e ps_get_thread_area (const struct ps_prochandle *ph, lwpid_t lwpid, int idx, void **base) { - if (gdbarch_ptr_bit (current_gdbarch) == 32) + if (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 32) { /* The full structure is found in . The second integer is the LDT's base_address and that is used to locate @@ -373,10 +480,39 @@ ps_get_thread_area (const struct ps_prochandle *ph, switch (idx) { case FS: +#ifdef HAVE_STRUCT_USER_REGS_STRUCT_FS_BASE + { + /* PTRACE_ARCH_PRCTL is obsolete since 2.6.25, where the + fs_base and gs_base fields of user_regs_struct can be + used directly. */ + unsigned long fs; + errno = 0; + fs = ptrace (PTRACE_PEEKUSER, lwpid, + offsetof (struct user_regs_struct, fs_base), 0); + if (errno == 0) + { + *base = (void *) fs; + return PS_OK; + } + } +#endif if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0) return PS_OK; break; case GS: +#ifdef HAVE_STRUCT_USER_REGS_STRUCT_GS_BASE + { + unsigned long gs; + errno = 0; + gs = ptrace (PTRACE_PEEKUSER, lwpid, + offsetof (struct user_regs_struct, gs_base), 0); + if (errno == 0) + { + *base = (void *) gs; + return PS_OK; + } + } +#endif if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0) return PS_OK; break; @@ -398,6 +534,551 @@ amd64_linux_child_post_startup_inferior (ptid_t ptid) } +/* When GDB is built as a 64-bit application on linux, the + PTRACE_GETSIGINFO data is always presented in 64-bit layout. Since + debugging a 32-bit inferior with a 64-bit GDB should look the same + as debugging it with a 32-bit GDB, we do the 32-bit <-> 64-bit + conversion in-place ourselves. */ + +/* These types below (compat_*) define a siginfo type that is layout + compatible with the siginfo type exported by the 32-bit userspace + support. */ + +typedef int compat_int_t; +typedef unsigned int compat_uptr_t; + +typedef int compat_time_t; +typedef int compat_timer_t; +typedef int compat_clock_t; + +struct compat_timeval +{ + compat_time_t tv_sec; + int tv_usec; +}; + +typedef union compat_sigval +{ + compat_int_t sival_int; + compat_uptr_t sival_ptr; +} compat_sigval_t; + +typedef struct compat_siginfo +{ + int si_signo; + int si_errno; + int si_code; + + union + { + int _pad[((128 / sizeof (int)) - 3)]; + + /* kill() */ + struct + { + unsigned int _pid; + unsigned int _uid; + } _kill; + + /* POSIX.1b timers */ + struct + { + compat_timer_t _tid; + int _overrun; + compat_sigval_t _sigval; + } _timer; + + /* POSIX.1b signals */ + struct + { + unsigned int _pid; + unsigned int _uid; + compat_sigval_t _sigval; + } _rt; + + /* SIGCHLD */ + struct + { + unsigned int _pid; + unsigned int _uid; + int _status; + compat_clock_t _utime; + compat_clock_t _stime; + } _sigchld; + + /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */ + struct + { + unsigned int _addr; + } _sigfault; + + /* SIGPOLL */ + struct + { + int _band; + int _fd; + } _sigpoll; + } _sifields; +} compat_siginfo_t; + +/* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes. */ +typedef struct compat_x32_clock +{ + int lower; + int upper; +} compat_x32_clock_t; + +typedef struct compat_x32_siginfo +{ + int si_signo; + int si_errno; + int si_code; + + union + { + int _pad[((128 / sizeof (int)) - 3)]; + + /* kill() */ + struct + { + unsigned int _pid; + unsigned int _uid; + } _kill; + + /* POSIX.1b timers */ + struct + { + compat_timer_t _tid; + int _overrun; + compat_sigval_t _sigval; + } _timer; + + /* POSIX.1b signals */ + struct + { + unsigned int _pid; + unsigned int _uid; + compat_sigval_t _sigval; + } _rt; + + /* SIGCHLD */ + struct + { + unsigned int _pid; + unsigned int _uid; + int _status; + compat_x32_clock_t _utime; + compat_x32_clock_t _stime; + } _sigchld; + + /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */ + struct + { + unsigned int _addr; + } _sigfault; + + /* SIGPOLL */ + struct + { + int _band; + int _fd; + } _sigpoll; + } _sifields; +} compat_x32_siginfo_t; + +#define cpt_si_pid _sifields._kill._pid +#define cpt_si_uid _sifields._kill._uid +#define cpt_si_timerid _sifields._timer._tid +#define cpt_si_overrun _sifields._timer._overrun +#define cpt_si_status _sifields._sigchld._status +#define cpt_si_utime _sifields._sigchld._utime +#define cpt_si_stime _sifields._sigchld._stime +#define cpt_si_ptr _sifields._rt._sigval.sival_ptr +#define cpt_si_addr _sifields._sigfault._addr +#define cpt_si_band _sifields._sigpoll._band +#define cpt_si_fd _sifields._sigpoll._fd + +/* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun. + In their place is si_timer1,si_timer2. */ +#ifndef si_timerid +#define si_timerid si_timer1 +#endif +#ifndef si_overrun +#define si_overrun si_timer2 +#endif + +static void +compat_siginfo_from_siginfo (compat_siginfo_t *to, siginfo_t *from) +{ + memset (to, 0, sizeof (*to)); + + to->si_signo = from->si_signo; + to->si_errno = from->si_errno; + to->si_code = from->si_code; + + if (to->si_code == SI_TIMER) + { + to->cpt_si_timerid = from->si_timerid; + to->cpt_si_overrun = from->si_overrun; + to->cpt_si_ptr = (intptr_t) from->si_ptr; + } + else if (to->si_code == SI_USER) + { + to->cpt_si_pid = from->si_pid; + to->cpt_si_uid = from->si_uid; + } + else if (to->si_code < 0) + { + to->cpt_si_pid = from->si_pid; + to->cpt_si_uid = from->si_uid; + to->cpt_si_ptr = (intptr_t) from->si_ptr; + } + else + { + switch (to->si_signo) + { + case SIGCHLD: + to->cpt_si_pid = from->si_pid; + to->cpt_si_uid = from->si_uid; + to->cpt_si_status = from->si_status; + to->cpt_si_utime = from->si_utime; + to->cpt_si_stime = from->si_stime; + break; + case SIGILL: + case SIGFPE: + case SIGSEGV: + case SIGBUS: + to->cpt_si_addr = (intptr_t) from->si_addr; + break; + case SIGPOLL: + to->cpt_si_band = from->si_band; + to->cpt_si_fd = from->si_fd; + break; + default: + to->cpt_si_pid = from->si_pid; + to->cpt_si_uid = from->si_uid; + to->cpt_si_ptr = (intptr_t) from->si_ptr; + break; + } + } +} + +static void +siginfo_from_compat_siginfo (siginfo_t *to, compat_siginfo_t *from) +{ + memset (to, 0, sizeof (*to)); + + to->si_signo = from->si_signo; + to->si_errno = from->si_errno; + to->si_code = from->si_code; + + if (to->si_code == SI_TIMER) + { + to->si_timerid = from->cpt_si_timerid; + to->si_overrun = from->cpt_si_overrun; + to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr; + } + else if (to->si_code == SI_USER) + { + to->si_pid = from->cpt_si_pid; + to->si_uid = from->cpt_si_uid; + } + if (to->si_code < 0) + { + to->si_pid = from->cpt_si_pid; + to->si_uid = from->cpt_si_uid; + to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr; + } + else + { + switch (to->si_signo) + { + case SIGCHLD: + to->si_pid = from->cpt_si_pid; + to->si_uid = from->cpt_si_uid; + to->si_status = from->cpt_si_status; + to->si_utime = from->cpt_si_utime; + to->si_stime = from->cpt_si_stime; + break; + case SIGILL: + case SIGFPE: + case SIGSEGV: + case SIGBUS: + to->si_addr = (void *) (intptr_t) from->cpt_si_addr; + break; + case SIGPOLL: + to->si_band = from->cpt_si_band; + to->si_fd = from->cpt_si_fd; + break; + default: + to->si_pid = from->cpt_si_pid; + to->si_uid = from->cpt_si_uid; + to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr; + break; + } + } +} + +static void +compat_x32_siginfo_from_siginfo (compat_x32_siginfo_t *to, + siginfo_t *from) +{ + memset (to, 0, sizeof (*to)); + + to->si_signo = from->si_signo; + to->si_errno = from->si_errno; + to->si_code = from->si_code; + + if (to->si_code == SI_TIMER) + { + to->cpt_si_timerid = from->si_timerid; + to->cpt_si_overrun = from->si_overrun; + to->cpt_si_ptr = (intptr_t) from->si_ptr; + } + else if (to->si_code == SI_USER) + { + to->cpt_si_pid = from->si_pid; + to->cpt_si_uid = from->si_uid; + } + else if (to->si_code < 0) + { + to->cpt_si_pid = from->si_pid; + to->cpt_si_uid = from->si_uid; + to->cpt_si_ptr = (intptr_t) from->si_ptr; + } + else + { + switch (to->si_signo) + { + case SIGCHLD: + to->cpt_si_pid = from->si_pid; + to->cpt_si_uid = from->si_uid; + to->cpt_si_status = from->si_status; + memcpy (&to->cpt_si_utime, &from->si_utime, + sizeof (to->cpt_si_utime)); + memcpy (&to->cpt_si_stime, &from->si_stime, + sizeof (to->cpt_si_stime)); + break; + case SIGILL: + case SIGFPE: + case SIGSEGV: + case SIGBUS: + to->cpt_si_addr = (intptr_t) from->si_addr; + break; + case SIGPOLL: + to->cpt_si_band = from->si_band; + to->cpt_si_fd = from->si_fd; + break; + default: + to->cpt_si_pid = from->si_pid; + to->cpt_si_uid = from->si_uid; + to->cpt_si_ptr = (intptr_t) from->si_ptr; + break; + } + } +} + +static void +siginfo_from_compat_x32_siginfo (siginfo_t *to, + compat_x32_siginfo_t *from) +{ + memset (to, 0, sizeof (*to)); + + to->si_signo = from->si_signo; + to->si_errno = from->si_errno; + to->si_code = from->si_code; + + if (to->si_code == SI_TIMER) + { + to->si_timerid = from->cpt_si_timerid; + to->si_overrun = from->cpt_si_overrun; + to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr; + } + else if (to->si_code == SI_USER) + { + to->si_pid = from->cpt_si_pid; + to->si_uid = from->cpt_si_uid; + } + if (to->si_code < 0) + { + to->si_pid = from->cpt_si_pid; + to->si_uid = from->cpt_si_uid; + to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr; + } + else + { + switch (to->si_signo) + { + case SIGCHLD: + to->si_pid = from->cpt_si_pid; + to->si_uid = from->cpt_si_uid; + to->si_status = from->cpt_si_status; + memcpy (&to->si_utime, &from->cpt_si_utime, + sizeof (to->si_utime)); + memcpy (&to->si_stime, &from->cpt_si_stime, + sizeof (to->si_stime)); + break; + case SIGILL: + case SIGFPE: + case SIGSEGV: + case SIGBUS: + to->si_addr = (void *) (intptr_t) from->cpt_si_addr; + break; + case SIGPOLL: + to->si_band = from->cpt_si_band; + to->si_fd = from->cpt_si_fd; + break; + default: + to->si_pid = from->cpt_si_pid; + to->si_uid = from->cpt_si_uid; + to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr; + break; + } + } +} + +/* Convert a native/host siginfo object, into/from the siginfo in the + layout of the inferiors' architecture. 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. */ + +static int +amd64_linux_siginfo_fixup (siginfo_t *native, gdb_byte *inf, int direction) +{ + struct gdbarch *gdbarch = get_frame_arch (get_current_frame ()); + + /* Is the inferior 32-bit? If so, then do fixup the siginfo + object. */ + if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32) + { + gdb_assert (sizeof (siginfo_t) == sizeof (compat_siginfo_t)); + + if (direction == 0) + compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, native); + else + siginfo_from_compat_siginfo (native, (struct compat_siginfo *) inf); + + return 1; + } + /* No fixup for native x32 GDB. */ + else if (gdbarch_addr_bit (gdbarch) == 32 && sizeof (void *) == 8) + { + gdb_assert (sizeof (siginfo_t) == sizeof (compat_x32_siginfo_t)); + + if (direction == 0) + compat_x32_siginfo_from_siginfo ((struct compat_x32_siginfo *) inf, + native); + else + siginfo_from_compat_x32_siginfo (native, + (struct compat_x32_siginfo *) inf); + + return 1; + } + else + return 0; +} + +/* Get Linux/x86 target description from running target. + + Value of CS segment register: + 1. 64bit process: 0x33. + 2. 32bit process: 0x23. + + Value of DS segment register: + 1. LP64 process: 0x0. + 2. X32 process: 0x2b. + */ + +#define AMD64_LINUX_USER64_CS 0x33 +#define AMD64_LINUX_X32_DS 0x2b + +static const struct target_desc * +amd64_linux_read_description (struct target_ops *ops) +{ + unsigned long cs; + unsigned long ds; + int tid; + int is_64bit; + int is_x32; + static uint64_t xcr0; + + /* GNU/Linux LWP ID's are process ID's. */ + tid = TIDGET (inferior_ptid); + if (tid == 0) + tid = PIDGET (inferior_ptid); /* Not a threaded program. */ + + /* Get CS register. */ + errno = 0; + cs = ptrace (PTRACE_PEEKUSER, tid, + offsetof (struct user_regs_struct, cs), 0); + if (errno != 0) + perror_with_name (_("Couldn't get CS register")); + + is_64bit = cs == AMD64_LINUX_USER64_CS; + + /* Get DS register. */ + errno = 0; + ds = ptrace (PTRACE_PEEKUSER, tid, + offsetof (struct user_regs_struct, ds), 0); + if (errno != 0) + perror_with_name (_("Couldn't get DS register")); + + is_x32 = ds == AMD64_LINUX_X32_DS; + + if (sizeof (void *) == 4 && is_64bit && !is_x32) + error (_("Can't debug 64-bit process with 32-bit GDB")); + + if (have_ptrace_getregset == -1) + { + uint64_t xstateregs[(I386_XSTATE_SSE_SIZE / sizeof (uint64_t))]; + struct iovec iov; + + iov.iov_base = xstateregs; + iov.iov_len = sizeof (xstateregs); + + /* Check if PTRACE_GETREGSET works. */ + if (ptrace (PTRACE_GETREGSET, tid, + (unsigned int) NT_X86_XSTATE, (long) &iov) < 0) + have_ptrace_getregset = 0; + else + { + have_ptrace_getregset = 1; + + /* Get XCR0 from XSAVE extended state. */ + xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET + / sizeof (uint64_t))]; + } + } + + /* Check the native XCR0 only if PTRACE_GETREGSET is available. */ + if (have_ptrace_getregset + && (xcr0 & I386_XSTATE_AVX_MASK) == I386_XSTATE_AVX_MASK) + { + if (is_64bit) + { + if (is_x32) + return tdesc_x32_avx_linux; + else + return tdesc_amd64_avx_linux; + } + else + return tdesc_i386_avx_linux; + } + else + { + if (is_64bit) + { + if (is_x32) + return tdesc_x32_linux; + else + return tdesc_amd64_linux; + } + else + return tdesc_i386_linux; + } +} + /* Provide a prototype to silence -Wmissing-prototypes. */ void _initialize_amd64_linux_nat (void); @@ -408,17 +1089,24 @@ _initialize_amd64_linux_nat (void) amd64_native_gregset32_reg_offset = amd64_linux_gregset32_reg_offset; amd64_native_gregset32_num_regs = I386_LINUX_NUM_REGS; - amd64_native_gregset64_reg_offset = amd64_linux_gregset64_reg_offset; + amd64_native_gregset64_reg_offset = amd64_linux_gregset_reg_offset; amd64_native_gregset64_num_regs = AMD64_LINUX_NUM_REGS; gdb_assert (ARRAY_SIZE (amd64_linux_gregset32_reg_offset) == amd64_native_gregset32_num_regs); - gdb_assert (ARRAY_SIZE (amd64_linux_gregset64_reg_offset) - == amd64_native_gregset64_num_regs); /* Fill in the generic GNU/Linux methods. */ t = linux_target (); + i386_use_watchpoints (t); + + i386_dr_low.set_control = amd64_linux_dr_set_control; + i386_dr_low.set_addr = amd64_linux_dr_set_addr; + i386_dr_low.get_addr = amd64_linux_dr_get_addr; + i386_dr_low.get_status = amd64_linux_dr_get_status; + i386_dr_low.get_control = amd64_linux_dr_get_control; + i386_set_debug_register_length (8); + /* Override the GNU/Linux inferior startup hook. */ super_post_startup_inferior = t->to_post_startup_inferior; t->to_post_startup_inferior = amd64_linux_child_post_startup_inferior; @@ -427,7 +1115,11 @@ _initialize_amd64_linux_nat (void) t->to_fetch_registers = amd64_linux_fetch_inferior_registers; t->to_store_registers = amd64_linux_store_inferior_registers; + t->to_read_description = amd64_linux_read_description; + /* Register the target. */ linux_nat_add_target (t); linux_nat_set_new_thread (t, amd64_linux_new_thread); + linux_nat_set_siginfo_fixup (t, amd64_linux_siginfo_fixup); + linux_nat_set_prepare_to_resume (t, amd64_linux_prepare_to_resume); }