1 /* Native-dependent code for GNU/Linux x86-64.
3 Copyright (C) 2001-2014 Free Software Foundation, Inc.
4 Contributed by Jiri Smid, SuSE Labs.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "linux-nat.h"
27 #include "amd64-linux-tdep.h"
28 #include "linux-btrace.h"
31 #include "gdb_assert.h"
33 #include "elf/common.h"
35 #include <sys/ptrace.h>
36 #include <sys/debugreg.h>
37 #include <sys/syscall.h>
38 #include <sys/procfs.h>
40 #include <asm/prctl.h>
41 /* FIXME ezannoni-2003-07-09: we need <sys/reg.h> to be included after
42 <asm/ptrace.h> because the latter redefines FS and GS for no apparent
43 reason, and those definitions don't match the ones that libpthread_db
44 uses, which come from <sys/reg.h>. */
45 /* ezannoni-2003-07-09: I think this is fixed. The extraneous defs have
46 been removed from ptrace.h in the kernel. However, better safe than
48 #include <asm/ptrace.h>
50 #include "gdb_proc_service.h"
52 /* Prototypes for supply_gregset etc. */
55 #include "amd64-tdep.h"
56 #include "i386-linux-tdep.h"
57 #include "amd64-nat.h"
59 #include "i386-xstate.h"
61 #ifndef PTRACE_GETREGSET
62 #define PTRACE_GETREGSET 0x4204
65 #ifndef PTRACE_SETREGSET
66 #define PTRACE_SETREGSET 0x4205
69 /* Per-thread arch-specific data we want to keep. */
73 /* Non-zero if our copy differs from what's recorded in the thread. */
74 int debug_registers_changed;
77 /* Does the current host support PTRACE_GETREGSET? */
78 static int have_ptrace_getregset = -1;
80 /* Mapping between the general-purpose registers in GNU/Linux x86-64
81 `struct user' format and GDB's register cache layout for GNU/Linux
84 Note that most GNU/Linux x86-64 registers are 64-bit, while the
85 GNU/Linux i386 registers are all 32-bit, but since we're
86 little-endian we get away with that. */
88 /* From <sys/reg.h> on GNU/Linux i386. */
89 static int amd64_linux_gregset32_reg_offset[] =
91 RAX * 8, RCX * 8, /* %eax, %ecx */
92 RDX * 8, RBX * 8, /* %edx, %ebx */
93 RSP * 8, RBP * 8, /* %esp, %ebp */
94 RSI * 8, RDI * 8, /* %esi, %edi */
95 RIP * 8, EFLAGS * 8, /* %eip, %eflags */
96 CS * 8, SS * 8, /* %cs, %ss */
97 DS * 8, ES * 8, /* %ds, %es */
98 FS * 8, GS * 8, /* %fs, %gs */
99 -1, -1, -1, -1, -1, -1, -1, -1,
100 -1, -1, -1, -1, -1, -1, -1, -1,
101 -1, -1, -1, -1, -1, -1, -1, -1, -1,
102 -1, -1, -1, -1, -1, -1, -1, -1,
103 -1, -1, -1, -1, /* MPX registers BND0 ... BND3. */
104 -1, -1, /* MPX registers BNDCFGU, BNDSTATUS. */
105 ORIG_RAX * 8, /* "orig_eax" */
109 /* Transfering the general-purpose registers between GDB, inferiors
112 /* Fill GDB's register cache with the general-purpose register values
116 supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
118 amd64_supply_native_gregset (regcache, gregsetp, -1);
121 /* Fill register REGNUM (if it is a general-purpose register) in
122 *GREGSETP with the value in GDB's register cache. If REGNUM is -1,
123 do this for all registers. */
126 fill_gregset (const struct regcache *regcache,
127 elf_gregset_t *gregsetp, int regnum)
129 amd64_collect_native_gregset (regcache, gregsetp, regnum);
132 /* Transfering floating-point registers between GDB, inferiors and cores. */
134 /* Fill GDB's register cache with the floating-point and SSE register
135 values in *FPREGSETP. */
138 supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
140 amd64_supply_fxsave (regcache, -1, fpregsetp);
143 /* Fill register REGNUM (if it is a floating-point or SSE register) in
144 *FPREGSETP with the value in GDB's register cache. If REGNUM is
145 -1, do this for all registers. */
148 fill_fpregset (const struct regcache *regcache,
149 elf_fpregset_t *fpregsetp, int regnum)
151 amd64_collect_fxsave (regcache, regnum, fpregsetp);
155 /* Transferring arbitrary registers between GDB and inferior. */
157 /* Fetch register REGNUM from the child process. If REGNUM is -1, do
158 this for all registers (including the floating point and SSE
162 amd64_linux_fetch_inferior_registers (struct target_ops *ops,
163 struct regcache *regcache, int regnum)
165 struct gdbarch *gdbarch = get_regcache_arch (regcache);
168 /* GNU/Linux LWP ID's are process ID's. */
169 tid = ptid_get_lwp (inferior_ptid);
171 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
173 if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
177 if (ptrace (PTRACE_GETREGS, tid, 0, (long) ®s) < 0)
178 perror_with_name (_("Couldn't get registers"));
180 amd64_supply_native_gregset (regcache, ®s, -1);
185 if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum))
187 elf_fpregset_t fpregs;
189 if (have_ptrace_getregset)
191 char xstateregs[I386_XSTATE_MAX_SIZE];
194 iov.iov_base = xstateregs;
195 iov.iov_len = sizeof (xstateregs);
196 if (ptrace (PTRACE_GETREGSET, tid,
197 (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
198 perror_with_name (_("Couldn't get extended state status"));
200 amd64_supply_xsave (regcache, -1, xstateregs);
204 if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
205 perror_with_name (_("Couldn't get floating point status"));
207 amd64_supply_fxsave (regcache, -1, &fpregs);
212 /* Store register REGNUM back into the child process. If REGNUM is
213 -1, do this for all registers (including the floating-point and SSE
217 amd64_linux_store_inferior_registers (struct target_ops *ops,
218 struct regcache *regcache, int regnum)
220 struct gdbarch *gdbarch = get_regcache_arch (regcache);
223 /* GNU/Linux LWP ID's are process ID's. */
224 tid = ptid_get_lwp (inferior_ptid);
226 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
228 if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
232 if (ptrace (PTRACE_GETREGS, tid, 0, (long) ®s) < 0)
233 perror_with_name (_("Couldn't get registers"));
235 amd64_collect_native_gregset (regcache, ®s, regnum);
237 if (ptrace (PTRACE_SETREGS, tid, 0, (long) ®s) < 0)
238 perror_with_name (_("Couldn't write registers"));
244 if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum))
246 elf_fpregset_t fpregs;
248 if (have_ptrace_getregset)
250 char xstateregs[I386_XSTATE_MAX_SIZE];
253 iov.iov_base = xstateregs;
254 iov.iov_len = sizeof (xstateregs);
255 if (ptrace (PTRACE_GETREGSET, tid,
256 (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
257 perror_with_name (_("Couldn't get extended state status"));
259 amd64_collect_xsave (regcache, regnum, xstateregs, 0);
261 if (ptrace (PTRACE_SETREGSET, tid,
262 (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
263 perror_with_name (_("Couldn't write extended state status"));
267 if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
268 perror_with_name (_("Couldn't get floating point status"));
270 amd64_collect_fxsave (regcache, regnum, &fpregs);
272 if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0)
273 perror_with_name (_("Couldn't write floating point status"));
278 /* Support for debug registers. */
281 amd64_linux_dr_get (ptid_t ptid, int regnum)
286 tid = ptid_get_lwp (ptid);
288 tid = ptid_get_pid (ptid);
291 value = ptrace (PTRACE_PEEKUSER, tid,
292 offsetof (struct user, u_debugreg[regnum]), 0);
294 perror_with_name (_("Couldn't read debug register"));
299 /* Set debug register REGNUM to VALUE in only the one LWP of PTID. */
302 amd64_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
306 tid = ptid_get_lwp (ptid);
308 tid = ptid_get_pid (ptid);
311 ptrace (PTRACE_POKEUSER, tid,
312 offsetof (struct user, u_debugreg[regnum]), value);
314 perror_with_name (_("Couldn't write debug register"));
317 /* Return the inferior's debug register REGNUM. */
320 amd64_linux_dr_get_addr (int regnum)
322 /* DR6 and DR7 are retrieved with some other way. */
323 gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
325 return amd64_linux_dr_get (inferior_ptid, regnum);
328 /* Return the inferior's DR7 debug control register. */
331 amd64_linux_dr_get_control (void)
333 return amd64_linux_dr_get (inferior_ptid, DR_CONTROL);
336 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID. */
339 amd64_linux_dr_get_status (void)
341 return amd64_linux_dr_get (inferior_ptid, DR_STATUS);
344 /* Callback for iterate_over_lwps. Update the debug registers of
348 update_debug_registers_callback (struct lwp_info *lwp, void *arg)
350 if (lwp->arch_private == NULL)
351 lwp->arch_private = XCNEW (struct arch_lwp_info);
353 /* The actual update is done later just before resuming the lwp, we
354 just mark that the registers need updating. */
355 lwp->arch_private->debug_registers_changed = 1;
357 /* If the lwp isn't stopped, force it to momentarily pause, so we
358 can update its debug registers. */
360 linux_stop_lwp (lwp);
362 /* Continue the iteration. */
366 /* Set DR_CONTROL to CONTROL in all LWPs of the current inferior. */
369 amd64_linux_dr_set_control (unsigned long control)
371 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
373 iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
376 /* Set address REGNUM (zero based) to ADDR in all LWPs of the current
380 amd64_linux_dr_set_addr (int regnum, CORE_ADDR addr)
382 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
384 gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
386 iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
389 /* Called when resuming a thread.
390 If the debug regs have changed, update the thread's copies. */
393 amd64_linux_prepare_to_resume (struct lwp_info *lwp)
395 int clear_status = 0;
397 /* NULL means this is the main thread still going through the shell,
398 or, no watchpoint has been set yet. In that case, there's
400 if (lwp->arch_private == NULL)
403 if (lwp->arch_private->debug_registers_changed)
405 struct i386_debug_reg_state *state
406 = i386_debug_reg_state (ptid_get_pid (lwp->ptid));
409 /* On Linux kernel before 2.6.33 commit
410 72f674d203cd230426437cdcf7dd6f681dad8b0d
411 if you enable a breakpoint by the DR_CONTROL bits you need to have
412 already written the corresponding DR_FIRSTADDR...DR_LASTADDR registers.
414 Ensure DR_CONTROL gets written as the very last register here. */
416 for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++)
417 if (state->dr_ref_count[i] > 0)
419 amd64_linux_dr_set (lwp->ptid, i, state->dr_mirror[i]);
421 /* If we're setting a watchpoint, any change the inferior
422 had done itself to the debug registers needs to be
423 discarded, otherwise, i386_stopped_data_address can get
428 amd64_linux_dr_set (lwp->ptid, DR_CONTROL, state->dr_control_mirror);
430 lwp->arch_private->debug_registers_changed = 0;
433 if (clear_status || lwp->stopped_by_watchpoint)
434 amd64_linux_dr_set (lwp->ptid, DR_STATUS, 0);
438 amd64_linux_new_thread (struct lwp_info *lp)
440 struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
442 info->debug_registers_changed = 1;
444 lp->arch_private = info;
447 /* linux_nat_new_fork hook. */
450 amd64_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
453 struct i386_debug_reg_state *parent_state;
454 struct i386_debug_reg_state *child_state;
456 /* NULL means no watchpoint has ever been set in the parent. In
457 that case, there's nothing to do. */
458 if (parent->arch_private == NULL)
461 /* Linux kernel before 2.6.33 commit
462 72f674d203cd230426437cdcf7dd6f681dad8b0d
463 will inherit hardware debug registers from parent
464 on fork/vfork/clone. Newer Linux kernels create such tasks with
465 zeroed debug registers.
467 GDB core assumes the child inherits the watchpoints/hw
468 breakpoints of the parent, and will remove them all from the
469 forked off process. Copy the debug registers mirrors into the
470 new process so that all breakpoints and watchpoints can be
471 removed together. The debug registers mirror will become zeroed
472 in the end before detaching the forked off process, thus making
473 this compatible with older Linux kernels too. */
475 parent_pid = ptid_get_pid (parent->ptid);
476 parent_state = i386_debug_reg_state (parent_pid);
477 child_state = i386_debug_reg_state (child_pid);
478 *child_state = *parent_state;
483 /* This function is called by libthread_db as part of its handling of
484 a request for a thread's local storage address. */
487 ps_get_thread_area (const struct ps_prochandle *ph,
488 lwpid_t lwpid, int idx, void **base)
490 if (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 32)
492 /* The full structure is found in <asm-i386/ldt.h>. The second
493 integer is the LDT's base_address and that is used to locate
494 the thread's local storage. See i386-linux-nat.c more
496 unsigned int desc[4];
498 /* This code assumes that "int" is 32 bits and that
499 GET_THREAD_AREA returns no more than 4 int values. */
500 gdb_assert (sizeof (int) == 4);
501 #ifndef PTRACE_GET_THREAD_AREA
502 #define PTRACE_GET_THREAD_AREA 25
504 if (ptrace (PTRACE_GET_THREAD_AREA,
505 lwpid, (void *) (long) idx, (unsigned long) &desc) < 0)
508 /* Extend the value to 64 bits. Here it's assumed that a "long"
509 and a "void *" are the same. */
510 (*base) = (void *) (long) desc[1];
515 /* This definition comes from prctl.h, but some kernels may not
517 #ifndef PTRACE_ARCH_PRCTL
518 #define PTRACE_ARCH_PRCTL 30
520 /* FIXME: ezannoni-2003-07-09 see comment above about include
521 file order. We could be getting bogus values for these two. */
522 gdb_assert (FS < ELF_NGREG);
523 gdb_assert (GS < ELF_NGREG);
527 #ifdef HAVE_STRUCT_USER_REGS_STRUCT_FS_BASE
529 /* PTRACE_ARCH_PRCTL is obsolete since 2.6.25, where the
530 fs_base and gs_base fields of user_regs_struct can be
534 fs = ptrace (PTRACE_PEEKUSER, lwpid,
535 offsetof (struct user_regs_struct, fs_base), 0);
543 if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0)
547 #ifdef HAVE_STRUCT_USER_REGS_STRUCT_GS_BASE
551 gs = ptrace (PTRACE_PEEKUSER, lwpid,
552 offsetof (struct user_regs_struct, gs_base), 0);
560 if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0)
563 default: /* Should not happen. */
567 return PS_ERR; /* ptrace failed. */
571 static void (*super_post_startup_inferior) (struct target_ops *self,
575 amd64_linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
577 i386_cleanup_dregs ();
578 super_post_startup_inferior (self, ptid);
582 /* When GDB is built as a 64-bit application on linux, the
583 PTRACE_GETSIGINFO data is always presented in 64-bit layout. Since
584 debugging a 32-bit inferior with a 64-bit GDB should look the same
585 as debugging it with a 32-bit GDB, we do the 32-bit <-> 64-bit
586 conversion in-place ourselves. */
588 /* These types below (compat_*) define a siginfo type that is layout
589 compatible with the siginfo type exported by the 32-bit userspace
592 typedef int compat_int_t;
593 typedef unsigned int compat_uptr_t;
595 typedef int compat_time_t;
596 typedef int compat_timer_t;
597 typedef int compat_clock_t;
599 struct compat_timeval
601 compat_time_t tv_sec;
605 typedef union compat_sigval
607 compat_int_t sival_int;
608 compat_uptr_t sival_ptr;
611 typedef struct compat_siginfo
619 int _pad[((128 / sizeof (int)) - 3)];
628 /* POSIX.1b timers */
633 compat_sigval_t _sigval;
636 /* POSIX.1b signals */
641 compat_sigval_t _sigval;
650 compat_clock_t _utime;
651 compat_clock_t _stime;
654 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
669 /* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes. */
670 typedef struct compat_x32_clock
674 } compat_x32_clock_t;
676 typedef struct compat_x32_siginfo
684 int _pad[((128 / sizeof (int)) - 3)];
693 /* POSIX.1b timers */
698 compat_sigval_t _sigval;
701 /* POSIX.1b signals */
706 compat_sigval_t _sigval;
715 compat_x32_clock_t _utime;
716 compat_x32_clock_t _stime;
719 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
732 } compat_x32_siginfo_t;
734 #define cpt_si_pid _sifields._kill._pid
735 #define cpt_si_uid _sifields._kill._uid
736 #define cpt_si_timerid _sifields._timer._tid
737 #define cpt_si_overrun _sifields._timer._overrun
738 #define cpt_si_status _sifields._sigchld._status
739 #define cpt_si_utime _sifields._sigchld._utime
740 #define cpt_si_stime _sifields._sigchld._stime
741 #define cpt_si_ptr _sifields._rt._sigval.sival_ptr
742 #define cpt_si_addr _sifields._sigfault._addr
743 #define cpt_si_band _sifields._sigpoll._band
744 #define cpt_si_fd _sifields._sigpoll._fd
746 /* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
747 In their place is si_timer1,si_timer2. */
749 #define si_timerid si_timer1
752 #define si_overrun si_timer2
756 compat_siginfo_from_siginfo (compat_siginfo_t *to, siginfo_t *from)
758 memset (to, 0, sizeof (*to));
760 to->si_signo = from->si_signo;
761 to->si_errno = from->si_errno;
762 to->si_code = from->si_code;
764 if (to->si_code == SI_TIMER)
766 to->cpt_si_timerid = from->si_timerid;
767 to->cpt_si_overrun = from->si_overrun;
768 to->cpt_si_ptr = (intptr_t) from->si_ptr;
770 else if (to->si_code == SI_USER)
772 to->cpt_si_pid = from->si_pid;
773 to->cpt_si_uid = from->si_uid;
775 else if (to->si_code < 0)
777 to->cpt_si_pid = from->si_pid;
778 to->cpt_si_uid = from->si_uid;
779 to->cpt_si_ptr = (intptr_t) from->si_ptr;
783 switch (to->si_signo)
786 to->cpt_si_pid = from->si_pid;
787 to->cpt_si_uid = from->si_uid;
788 to->cpt_si_status = from->si_status;
789 to->cpt_si_utime = from->si_utime;
790 to->cpt_si_stime = from->si_stime;
796 to->cpt_si_addr = (intptr_t) from->si_addr;
799 to->cpt_si_band = from->si_band;
800 to->cpt_si_fd = from->si_fd;
803 to->cpt_si_pid = from->si_pid;
804 to->cpt_si_uid = from->si_uid;
805 to->cpt_si_ptr = (intptr_t) from->si_ptr;
812 siginfo_from_compat_siginfo (siginfo_t *to, compat_siginfo_t *from)
814 memset (to, 0, sizeof (*to));
816 to->si_signo = from->si_signo;
817 to->si_errno = from->si_errno;
818 to->si_code = from->si_code;
820 if (to->si_code == SI_TIMER)
822 to->si_timerid = from->cpt_si_timerid;
823 to->si_overrun = from->cpt_si_overrun;
824 to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
826 else if (to->si_code == SI_USER)
828 to->si_pid = from->cpt_si_pid;
829 to->si_uid = from->cpt_si_uid;
833 to->si_pid = from->cpt_si_pid;
834 to->si_uid = from->cpt_si_uid;
835 to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
839 switch (to->si_signo)
842 to->si_pid = from->cpt_si_pid;
843 to->si_uid = from->cpt_si_uid;
844 to->si_status = from->cpt_si_status;
845 to->si_utime = from->cpt_si_utime;
846 to->si_stime = from->cpt_si_stime;
852 to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
855 to->si_band = from->cpt_si_band;
856 to->si_fd = from->cpt_si_fd;
859 to->si_pid = from->cpt_si_pid;
860 to->si_uid = from->cpt_si_uid;
861 to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
868 compat_x32_siginfo_from_siginfo (compat_x32_siginfo_t *to,
871 memset (to, 0, sizeof (*to));
873 to->si_signo = from->si_signo;
874 to->si_errno = from->si_errno;
875 to->si_code = from->si_code;
877 if (to->si_code == SI_TIMER)
879 to->cpt_si_timerid = from->si_timerid;
880 to->cpt_si_overrun = from->si_overrun;
881 to->cpt_si_ptr = (intptr_t) from->si_ptr;
883 else if (to->si_code == SI_USER)
885 to->cpt_si_pid = from->si_pid;
886 to->cpt_si_uid = from->si_uid;
888 else if (to->si_code < 0)
890 to->cpt_si_pid = from->si_pid;
891 to->cpt_si_uid = from->si_uid;
892 to->cpt_si_ptr = (intptr_t) from->si_ptr;
896 switch (to->si_signo)
899 to->cpt_si_pid = from->si_pid;
900 to->cpt_si_uid = from->si_uid;
901 to->cpt_si_status = from->si_status;
902 memcpy (&to->cpt_si_utime, &from->si_utime,
903 sizeof (to->cpt_si_utime));
904 memcpy (&to->cpt_si_stime, &from->si_stime,
905 sizeof (to->cpt_si_stime));
911 to->cpt_si_addr = (intptr_t) from->si_addr;
914 to->cpt_si_band = from->si_band;
915 to->cpt_si_fd = from->si_fd;
918 to->cpt_si_pid = from->si_pid;
919 to->cpt_si_uid = from->si_uid;
920 to->cpt_si_ptr = (intptr_t) from->si_ptr;
927 siginfo_from_compat_x32_siginfo (siginfo_t *to,
928 compat_x32_siginfo_t *from)
930 memset (to, 0, sizeof (*to));
932 to->si_signo = from->si_signo;
933 to->si_errno = from->si_errno;
934 to->si_code = from->si_code;
936 if (to->si_code == SI_TIMER)
938 to->si_timerid = from->cpt_si_timerid;
939 to->si_overrun = from->cpt_si_overrun;
940 to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
942 else if (to->si_code == SI_USER)
944 to->si_pid = from->cpt_si_pid;
945 to->si_uid = from->cpt_si_uid;
949 to->si_pid = from->cpt_si_pid;
950 to->si_uid = from->cpt_si_uid;
951 to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
955 switch (to->si_signo)
958 to->si_pid = from->cpt_si_pid;
959 to->si_uid = from->cpt_si_uid;
960 to->si_status = from->cpt_si_status;
961 memcpy (&to->si_utime, &from->cpt_si_utime,
962 sizeof (to->si_utime));
963 memcpy (&to->si_stime, &from->cpt_si_stime,
964 sizeof (to->si_stime));
970 to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
973 to->si_band = from->cpt_si_band;
974 to->si_fd = from->cpt_si_fd;
977 to->si_pid = from->cpt_si_pid;
978 to->si_uid = from->cpt_si_uid;
979 to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
985 /* Convert a native/host siginfo object, into/from the siginfo in the
986 layout of the inferiors' architecture. Returns true if any
987 conversion was done; false otherwise. If DIRECTION is 1, then copy
988 from INF to NATIVE. If DIRECTION is 0, copy from NATIVE to
992 amd64_linux_siginfo_fixup (siginfo_t *native, gdb_byte *inf, int direction)
994 struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
996 /* Is the inferior 32-bit? If so, then do fixup the siginfo
998 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
1000 gdb_assert (sizeof (siginfo_t) == sizeof (compat_siginfo_t));
1003 compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, native);
1005 siginfo_from_compat_siginfo (native, (struct compat_siginfo *) inf);
1009 /* No fixup for native x32 GDB. */
1010 else if (gdbarch_addr_bit (gdbarch) == 32 && sizeof (void *) == 8)
1012 gdb_assert (sizeof (siginfo_t) == sizeof (compat_x32_siginfo_t));
1015 compat_x32_siginfo_from_siginfo ((struct compat_x32_siginfo *) inf,
1018 siginfo_from_compat_x32_siginfo (native,
1019 (struct compat_x32_siginfo *) inf);
1027 /* Get Linux/x86 target description from running target.
1029 Value of CS segment register:
1030 1. 64bit process: 0x33.
1031 2. 32bit process: 0x23.
1033 Value of DS segment register:
1034 1. LP64 process: 0x0.
1035 2. X32 process: 0x2b.
1038 #define AMD64_LINUX_USER64_CS 0x33
1039 #define AMD64_LINUX_X32_DS 0x2b
1041 static const struct target_desc *
1042 amd64_linux_read_description (struct target_ops *ops)
1049 static uint64_t xcr0;
1051 /* GNU/Linux LWP ID's are process ID's. */
1052 tid = ptid_get_lwp (inferior_ptid);
1054 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
1056 /* Get CS register. */
1058 cs = ptrace (PTRACE_PEEKUSER, tid,
1059 offsetof (struct user_regs_struct, cs), 0);
1061 perror_with_name (_("Couldn't get CS register"));
1063 is_64bit = cs == AMD64_LINUX_USER64_CS;
1065 /* Get DS register. */
1067 ds = ptrace (PTRACE_PEEKUSER, tid,
1068 offsetof (struct user_regs_struct, ds), 0);
1070 perror_with_name (_("Couldn't get DS register"));
1072 is_x32 = ds == AMD64_LINUX_X32_DS;
1074 if (sizeof (void *) == 4 && is_64bit && !is_x32)
1075 error (_("Can't debug 64-bit process with 32-bit GDB"));
1077 if (have_ptrace_getregset == -1)
1079 uint64_t xstateregs[(I386_XSTATE_SSE_SIZE / sizeof (uint64_t))];
1082 iov.iov_base = xstateregs;
1083 iov.iov_len = sizeof (xstateregs);
1085 /* Check if PTRACE_GETREGSET works. */
1086 if (ptrace (PTRACE_GETREGSET, tid,
1087 (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
1088 have_ptrace_getregset = 0;
1091 have_ptrace_getregset = 1;
1093 /* Get XCR0 from XSAVE extended state. */
1094 xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
1095 / sizeof (uint64_t))];
1099 /* Check the native XCR0 only if PTRACE_GETREGSET is available. */
1100 if (have_ptrace_getregset && (xcr0 & I386_XSTATE_ALL_MASK))
1102 switch (xcr0 & I386_XSTATE_ALL_MASK)
1104 case I386_XSTATE_MPX_MASK:
1108 return tdesc_x32_avx_linux; /* No MPX on x32 using AVX. */
1110 return tdesc_amd64_mpx_linux;
1113 return tdesc_i386_mpx_linux;
1114 case I386_XSTATE_AVX_MASK:
1118 return tdesc_x32_avx_linux;
1120 return tdesc_amd64_avx_linux;
1123 return tdesc_i386_avx_linux;
1128 return tdesc_x32_linux;
1130 return tdesc_amd64_linux;
1133 return tdesc_i386_linux;
1141 return tdesc_x32_linux;
1143 return tdesc_amd64_linux;
1146 return tdesc_i386_linux;
1150 /* Enable branch tracing. */
1152 static struct btrace_target_info *
1153 amd64_linux_enable_btrace (ptid_t ptid)
1155 struct btrace_target_info *tinfo;
1156 struct gdbarch *gdbarch;
1159 tinfo = linux_enable_btrace (ptid);
1162 error (_("Could not enable branch tracing for %s: %s."),
1163 target_pid_to_str (ptid), safe_strerror (errno));
1165 /* Fill in the size of a pointer in bits. */
1166 gdbarch = target_thread_architecture (ptid);
1167 tinfo->ptr_bits = gdbarch_ptr_bit (gdbarch);
1172 /* Disable branch tracing. */
1175 amd64_linux_disable_btrace (struct btrace_target_info *tinfo)
1177 enum btrace_error errcode = linux_disable_btrace (tinfo);
1179 if (errcode != BTRACE_ERR_NONE)
1180 error (_("Could not disable branch tracing."));
1183 /* Teardown branch tracing. */
1186 amd64_linux_teardown_btrace (struct btrace_target_info *tinfo)
1188 /* Ignore errors. */
1189 linux_disable_btrace (tinfo);
1192 /* Provide a prototype to silence -Wmissing-prototypes. */
1193 void _initialize_amd64_linux_nat (void);
1196 _initialize_amd64_linux_nat (void)
1198 struct target_ops *t;
1200 amd64_native_gregset32_reg_offset = amd64_linux_gregset32_reg_offset;
1201 amd64_native_gregset32_num_regs = I386_LINUX_NUM_REGS;
1202 amd64_native_gregset64_reg_offset = amd64_linux_gregset_reg_offset;
1203 amd64_native_gregset64_num_regs = AMD64_LINUX_NUM_REGS;
1205 gdb_assert (ARRAY_SIZE (amd64_linux_gregset32_reg_offset)
1206 == amd64_native_gregset32_num_regs);
1208 /* Fill in the generic GNU/Linux methods. */
1209 t = linux_target ();
1211 i386_use_watchpoints (t);
1213 i386_dr_low.set_control = amd64_linux_dr_set_control;
1214 i386_dr_low.set_addr = amd64_linux_dr_set_addr;
1215 i386_dr_low.get_addr = amd64_linux_dr_get_addr;
1216 i386_dr_low.get_status = amd64_linux_dr_get_status;
1217 i386_dr_low.get_control = amd64_linux_dr_get_control;
1218 i386_set_debug_register_length (8);
1220 /* Override the GNU/Linux inferior startup hook. */
1221 super_post_startup_inferior = t->to_post_startup_inferior;
1222 t->to_post_startup_inferior = amd64_linux_child_post_startup_inferior;
1224 /* Add our register access methods. */
1225 t->to_fetch_registers = amd64_linux_fetch_inferior_registers;
1226 t->to_store_registers = amd64_linux_store_inferior_registers;
1228 t->to_read_description = amd64_linux_read_description;
1230 /* Add btrace methods. */
1231 t->to_supports_btrace = linux_supports_btrace;
1232 t->to_enable_btrace = amd64_linux_enable_btrace;
1233 t->to_disable_btrace = amd64_linux_disable_btrace;
1234 t->to_teardown_btrace = amd64_linux_teardown_btrace;
1235 t->to_read_btrace = linux_read_btrace;
1237 /* Register the target. */
1238 linux_nat_add_target (t);
1239 linux_nat_set_new_thread (t, amd64_linux_new_thread);
1240 linux_nat_set_new_fork (t, amd64_linux_new_fork);
1241 linux_nat_set_forget_process (t, i386_forget_process);
1242 linux_nat_set_siginfo_fixup (t, amd64_linux_siginfo_fixup);
1243 linux_nat_set_prepare_to_resume (t, amd64_linux_prepare_to_resume);