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 "nat/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 -1, -1, -1, -1, -1, -1, -1, -1, /* k0 ... k7 (AVX512) */
106 -1, -1, -1, -1, -1, -1, -1, -1, /* zmm0 ... zmm7 (AVX512) */
107 ORIG_RAX * 8 /* "orig_eax" */
111 /* Transfering the general-purpose registers between GDB, inferiors
114 /* Fill GDB's register cache with the general-purpose register values
118 supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
120 amd64_supply_native_gregset (regcache, gregsetp, -1);
123 /* Fill register REGNUM (if it is a general-purpose register) in
124 *GREGSETP with the value in GDB's register cache. If REGNUM is -1,
125 do this for all registers. */
128 fill_gregset (const struct regcache *regcache,
129 elf_gregset_t *gregsetp, int regnum)
131 amd64_collect_native_gregset (regcache, gregsetp, regnum);
134 /* Transfering floating-point registers between GDB, inferiors and cores. */
136 /* Fill GDB's register cache with the floating-point and SSE register
137 values in *FPREGSETP. */
140 supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
142 amd64_supply_fxsave (regcache, -1, fpregsetp);
145 /* Fill register REGNUM (if it is a floating-point or SSE register) in
146 *FPREGSETP with the value in GDB's register cache. If REGNUM is
147 -1, do this for all registers. */
150 fill_fpregset (const struct regcache *regcache,
151 elf_fpregset_t *fpregsetp, int regnum)
153 amd64_collect_fxsave (regcache, regnum, fpregsetp);
157 /* Transferring arbitrary registers between GDB and inferior. */
159 /* Fetch register REGNUM from the child process. If REGNUM is -1, do
160 this for all registers (including the floating point and SSE
164 amd64_linux_fetch_inferior_registers (struct target_ops *ops,
165 struct regcache *regcache, int regnum)
167 struct gdbarch *gdbarch = get_regcache_arch (regcache);
170 /* GNU/Linux LWP ID's are process ID's. */
171 tid = ptid_get_lwp (inferior_ptid);
173 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
175 if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
179 if (ptrace (PTRACE_GETREGS, tid, 0, (long) ®s) < 0)
180 perror_with_name (_("Couldn't get registers"));
182 amd64_supply_native_gregset (regcache, ®s, -1);
187 if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum))
189 elf_fpregset_t fpregs;
191 if (have_ptrace_getregset)
193 char xstateregs[I386_XSTATE_MAX_SIZE];
196 iov.iov_base = xstateregs;
197 iov.iov_len = sizeof (xstateregs);
198 if (ptrace (PTRACE_GETREGSET, tid,
199 (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
200 perror_with_name (_("Couldn't get extended state status"));
202 amd64_supply_xsave (regcache, -1, xstateregs);
206 if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
207 perror_with_name (_("Couldn't get floating point status"));
209 amd64_supply_fxsave (regcache, -1, &fpregs);
214 /* Store register REGNUM back into the child process. If REGNUM is
215 -1, do this for all registers (including the floating-point and SSE
219 amd64_linux_store_inferior_registers (struct target_ops *ops,
220 struct regcache *regcache, int regnum)
222 struct gdbarch *gdbarch = get_regcache_arch (regcache);
225 /* GNU/Linux LWP ID's are process ID's. */
226 tid = ptid_get_lwp (inferior_ptid);
228 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
230 if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
234 if (ptrace (PTRACE_GETREGS, tid, 0, (long) ®s) < 0)
235 perror_with_name (_("Couldn't get registers"));
237 amd64_collect_native_gregset (regcache, ®s, regnum);
239 if (ptrace (PTRACE_SETREGS, tid, 0, (long) ®s) < 0)
240 perror_with_name (_("Couldn't write registers"));
246 if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum))
248 elf_fpregset_t fpregs;
250 if (have_ptrace_getregset)
252 char xstateregs[I386_XSTATE_MAX_SIZE];
255 iov.iov_base = xstateregs;
256 iov.iov_len = sizeof (xstateregs);
257 if (ptrace (PTRACE_GETREGSET, tid,
258 (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
259 perror_with_name (_("Couldn't get extended state status"));
261 amd64_collect_xsave (regcache, regnum, xstateregs, 0);
263 if (ptrace (PTRACE_SETREGSET, tid,
264 (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
265 perror_with_name (_("Couldn't write extended state status"));
269 if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
270 perror_with_name (_("Couldn't get floating point status"));
272 amd64_collect_fxsave (regcache, regnum, &fpregs);
274 if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0)
275 perror_with_name (_("Couldn't write floating point status"));
280 /* Support for debug registers. */
283 x86_linux_dr_get (ptid_t ptid, int regnum)
288 tid = ptid_get_lwp (ptid);
290 tid = ptid_get_pid (ptid);
293 value = ptrace (PTRACE_PEEKUSER, tid,
294 offsetof (struct user, u_debugreg[regnum]), 0);
296 perror_with_name (_("Couldn't read debug register"));
301 /* Set debug register REGNUM to VALUE in only the one LWP of PTID. */
304 x86_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
308 tid = ptid_get_lwp (ptid);
310 tid = ptid_get_pid (ptid);
313 ptrace (PTRACE_POKEUSER, tid,
314 offsetof (struct user, u_debugreg[regnum]), value);
316 perror_with_name (_("Couldn't write debug register"));
319 /* Return the inferior's debug register REGNUM. */
322 x86_linux_dr_get_addr (int regnum)
324 /* DR6 and DR7 are retrieved with some other way. */
325 gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
327 return x86_linux_dr_get (inferior_ptid, regnum);
330 /* Return the inferior's DR7 debug control register. */
333 x86_linux_dr_get_control (void)
335 return x86_linux_dr_get (inferior_ptid, DR_CONTROL);
338 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID. */
341 x86_linux_dr_get_status (void)
343 return x86_linux_dr_get (inferior_ptid, DR_STATUS);
346 /* Callback for iterate_over_lwps. Update the debug registers of
350 update_debug_registers_callback (struct lwp_info *lwp, void *arg)
352 if (lwp->arch_private == NULL)
353 lwp->arch_private = XCNEW (struct arch_lwp_info);
355 /* The actual update is done later just before resuming the lwp, we
356 just mark that the registers need updating. */
357 lwp->arch_private->debug_registers_changed = 1;
359 /* If the lwp isn't stopped, force it to momentarily pause, so we
360 can update its debug registers. */
362 linux_stop_lwp (lwp);
364 /* Continue the iteration. */
368 /* Set DR_CONTROL to CONTROL in all LWPs of the current inferior. */
371 x86_linux_dr_set_control (unsigned long control)
373 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
375 iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
378 /* Set address REGNUM (zero based) to ADDR in all LWPs of the current
382 x86_linux_dr_set_addr (int regnum, CORE_ADDR addr)
384 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
386 gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
388 iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
391 /* Called when resuming a thread.
392 If the debug regs have changed, update the thread's copies. */
395 x86_linux_prepare_to_resume (struct lwp_info *lwp)
397 int clear_status = 0;
399 /* NULL means this is the main thread still going through the shell,
400 or, no watchpoint has been set yet. In that case, there's
402 if (lwp->arch_private == NULL)
405 if (lwp->arch_private->debug_registers_changed)
407 struct i386_debug_reg_state *state
408 = i386_debug_reg_state (ptid_get_pid (lwp->ptid));
411 /* On Linux kernel before 2.6.33 commit
412 72f674d203cd230426437cdcf7dd6f681dad8b0d
413 if you enable a breakpoint by the DR_CONTROL bits you need to have
414 already written the corresponding DR_FIRSTADDR...DR_LASTADDR registers.
416 Ensure DR_CONTROL gets written as the very last register here. */
418 /* Clear DR_CONTROL first. In some cases, setting DR0-3 to a
419 value that doesn't match what is enabled in DR_CONTROL
420 results in EINVAL. */
421 x86_linux_dr_set (lwp->ptid, DR_CONTROL, 0);
423 for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++)
424 if (state->dr_ref_count[i] > 0)
426 x86_linux_dr_set (lwp->ptid, i, state->dr_mirror[i]);
428 /* If we're setting a watchpoint, any change the inferior
429 had done itself to the debug registers needs to be
430 discarded, otherwise, i386_stopped_data_address can get
435 /* If DR_CONTROL is supposed to be zero, we've already set it
437 if (state->dr_control_mirror != 0)
438 x86_linux_dr_set (lwp->ptid, DR_CONTROL, state->dr_control_mirror);
440 lwp->arch_private->debug_registers_changed = 0;
443 if (clear_status || lwp->stopped_by_watchpoint)
444 x86_linux_dr_set (lwp->ptid, DR_STATUS, 0);
448 x86_linux_new_thread (struct lwp_info *lp)
450 struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
452 info->debug_registers_changed = 1;
454 lp->arch_private = info;
457 /* linux_nat_new_fork hook. */
460 x86_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
463 struct i386_debug_reg_state *parent_state;
464 struct i386_debug_reg_state *child_state;
466 /* NULL means no watchpoint has ever been set in the parent. In
467 that case, there's nothing to do. */
468 if (parent->arch_private == NULL)
471 /* Linux kernel before 2.6.33 commit
472 72f674d203cd230426437cdcf7dd6f681dad8b0d
473 will inherit hardware debug registers from parent
474 on fork/vfork/clone. Newer Linux kernels create such tasks with
475 zeroed debug registers.
477 GDB core assumes the child inherits the watchpoints/hw
478 breakpoints of the parent, and will remove them all from the
479 forked off process. Copy the debug registers mirrors into the
480 new process so that all breakpoints and watchpoints can be
481 removed together. The debug registers mirror will become zeroed
482 in the end before detaching the forked off process, thus making
483 this compatible with older Linux kernels too. */
485 parent_pid = ptid_get_pid (parent->ptid);
486 parent_state = i386_debug_reg_state (parent_pid);
487 child_state = i386_debug_reg_state (child_pid);
488 *child_state = *parent_state;
493 /* Helper for ps_get_thread_area. Sets BASE_ADDR to a pointer to
494 the thread local storage (or its descriptor) and returns PS_OK
495 on success. Returns PS_ERR on failure. */
498 x86_linux_get_thread_area (pid_t pid, void *addr, unsigned int *base_addr)
500 /* NOTE: cagney/2003-08-26: The definition of this buffer is found
501 in the kernel header <asm-i386/ldt.h>. It, after padding, is 4 x
502 4 byte integers in size: `entry_number', `base_addr', `limit',
503 and a bunch of status bits.
505 The values returned by this ptrace call should be part of the
506 regcache buffer, and ps_get_thread_area should channel its
507 request through the regcache. That way remote targets could
508 provide the value using the remote protocol and not this direct
511 Is this function needed? I'm guessing that the `base' is the
512 address of a descriptor that libthread_db uses to find the
513 thread local address base that GDB needs. Perhaps that
514 descriptor is defined by the ABI. Anyway, given that
515 libthread_db calls this function without prompting (gdb
516 requesting tls base) I guess it needs info in there anyway. */
517 unsigned int desc[4];
519 /* This code assumes that "int" is 32 bits and that
520 GET_THREAD_AREA returns no more than 4 int values. */
521 gdb_assert (sizeof (int) == 4);
523 #ifndef PTRACE_GET_THREAD_AREA
524 #define PTRACE_GET_THREAD_AREA 25
527 if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, &desc) < 0)
530 *base_addr = desc[1];
534 /* This function is called by libthread_db as part of its handling of
535 a request for a thread's local storage address. */
538 ps_get_thread_area (const struct ps_prochandle *ph,
539 lwpid_t lwpid, int idx, void **base)
541 if (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 32)
543 unsigned int base_addr;
546 result = x86_linux_get_thread_area (lwpid, (void *) (long) idx,
550 /* Extend the value to 64 bits. Here it's assumed that
551 a "long" and a "void *" are the same. */
552 (*base) = (void *) (long) base_addr;
558 /* This definition comes from prctl.h, but some kernels may not
560 #ifndef PTRACE_ARCH_PRCTL
561 #define PTRACE_ARCH_PRCTL 30
563 /* FIXME: ezannoni-2003-07-09 see comment above about include
564 file order. We could be getting bogus values for these two. */
565 gdb_assert (FS < ELF_NGREG);
566 gdb_assert (GS < ELF_NGREG);
570 #ifdef HAVE_STRUCT_USER_REGS_STRUCT_FS_BASE
572 /* PTRACE_ARCH_PRCTL is obsolete since 2.6.25, where the
573 fs_base and gs_base fields of user_regs_struct can be
577 fs = ptrace (PTRACE_PEEKUSER, lwpid,
578 offsetof (struct user_regs_struct, fs_base), 0);
586 if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0)
590 #ifdef HAVE_STRUCT_USER_REGS_STRUCT_GS_BASE
594 gs = ptrace (PTRACE_PEEKUSER, lwpid,
595 offsetof (struct user_regs_struct, gs_base), 0);
603 if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0)
606 default: /* Should not happen. */
610 return PS_ERR; /* ptrace failed. */
614 static void (*super_post_startup_inferior) (struct target_ops *self,
618 x86_linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
620 i386_cleanup_dregs ();
621 super_post_startup_inferior (self, ptid);
625 /* When GDB is built as a 64-bit application on linux, the
626 PTRACE_GETSIGINFO data is always presented in 64-bit layout. Since
627 debugging a 32-bit inferior with a 64-bit GDB should look the same
628 as debugging it with a 32-bit GDB, we do the 32-bit <-> 64-bit
629 conversion in-place ourselves. */
631 /* These types below (compat_*) define a siginfo type that is layout
632 compatible with the siginfo type exported by the 32-bit userspace
635 typedef int compat_int_t;
636 typedef unsigned int compat_uptr_t;
638 typedef int compat_time_t;
639 typedef int compat_timer_t;
640 typedef int compat_clock_t;
642 struct compat_timeval
644 compat_time_t tv_sec;
648 typedef union compat_sigval
650 compat_int_t sival_int;
651 compat_uptr_t sival_ptr;
654 typedef struct compat_siginfo
662 int _pad[((128 / sizeof (int)) - 3)];
671 /* POSIX.1b timers */
676 compat_sigval_t _sigval;
679 /* POSIX.1b signals */
684 compat_sigval_t _sigval;
693 compat_clock_t _utime;
694 compat_clock_t _stime;
697 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
712 /* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes. */
713 typedef struct compat_x32_clock
717 } compat_x32_clock_t;
719 typedef struct compat_x32_siginfo
727 int _pad[((128 / sizeof (int)) - 3)];
736 /* POSIX.1b timers */
741 compat_sigval_t _sigval;
744 /* POSIX.1b signals */
749 compat_sigval_t _sigval;
758 compat_x32_clock_t _utime;
759 compat_x32_clock_t _stime;
762 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
775 } compat_x32_siginfo_t;
777 #define cpt_si_pid _sifields._kill._pid
778 #define cpt_si_uid _sifields._kill._uid
779 #define cpt_si_timerid _sifields._timer._tid
780 #define cpt_si_overrun _sifields._timer._overrun
781 #define cpt_si_status _sifields._sigchld._status
782 #define cpt_si_utime _sifields._sigchld._utime
783 #define cpt_si_stime _sifields._sigchld._stime
784 #define cpt_si_ptr _sifields._rt._sigval.sival_ptr
785 #define cpt_si_addr _sifields._sigfault._addr
786 #define cpt_si_band _sifields._sigpoll._band
787 #define cpt_si_fd _sifields._sigpoll._fd
789 /* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
790 In their place is si_timer1,si_timer2. */
792 #define si_timerid si_timer1
795 #define si_overrun si_timer2
799 compat_siginfo_from_siginfo (compat_siginfo_t *to, siginfo_t *from)
801 memset (to, 0, sizeof (*to));
803 to->si_signo = from->si_signo;
804 to->si_errno = from->si_errno;
805 to->si_code = from->si_code;
807 if (to->si_code == SI_TIMER)
809 to->cpt_si_timerid = from->si_timerid;
810 to->cpt_si_overrun = from->si_overrun;
811 to->cpt_si_ptr = (intptr_t) from->si_ptr;
813 else if (to->si_code == SI_USER)
815 to->cpt_si_pid = from->si_pid;
816 to->cpt_si_uid = from->si_uid;
818 else if (to->si_code < 0)
820 to->cpt_si_pid = from->si_pid;
821 to->cpt_si_uid = from->si_uid;
822 to->cpt_si_ptr = (intptr_t) from->si_ptr;
826 switch (to->si_signo)
829 to->cpt_si_pid = from->si_pid;
830 to->cpt_si_uid = from->si_uid;
831 to->cpt_si_status = from->si_status;
832 to->cpt_si_utime = from->si_utime;
833 to->cpt_si_stime = from->si_stime;
839 to->cpt_si_addr = (intptr_t) from->si_addr;
842 to->cpt_si_band = from->si_band;
843 to->cpt_si_fd = from->si_fd;
846 to->cpt_si_pid = from->si_pid;
847 to->cpt_si_uid = from->si_uid;
848 to->cpt_si_ptr = (intptr_t) from->si_ptr;
855 siginfo_from_compat_siginfo (siginfo_t *to, compat_siginfo_t *from)
857 memset (to, 0, sizeof (*to));
859 to->si_signo = from->si_signo;
860 to->si_errno = from->si_errno;
861 to->si_code = from->si_code;
863 if (to->si_code == SI_TIMER)
865 to->si_timerid = from->cpt_si_timerid;
866 to->si_overrun = from->cpt_si_overrun;
867 to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
869 else if (to->si_code == SI_USER)
871 to->si_pid = from->cpt_si_pid;
872 to->si_uid = from->cpt_si_uid;
876 to->si_pid = from->cpt_si_pid;
877 to->si_uid = from->cpt_si_uid;
878 to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
882 switch (to->si_signo)
885 to->si_pid = from->cpt_si_pid;
886 to->si_uid = from->cpt_si_uid;
887 to->si_status = from->cpt_si_status;
888 to->si_utime = from->cpt_si_utime;
889 to->si_stime = from->cpt_si_stime;
895 to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
898 to->si_band = from->cpt_si_band;
899 to->si_fd = from->cpt_si_fd;
902 to->si_pid = from->cpt_si_pid;
903 to->si_uid = from->cpt_si_uid;
904 to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
911 compat_x32_siginfo_from_siginfo (compat_x32_siginfo_t *to,
914 memset (to, 0, sizeof (*to));
916 to->si_signo = from->si_signo;
917 to->si_errno = from->si_errno;
918 to->si_code = from->si_code;
920 if (to->si_code == SI_TIMER)
922 to->cpt_si_timerid = from->si_timerid;
923 to->cpt_si_overrun = from->si_overrun;
924 to->cpt_si_ptr = (intptr_t) from->si_ptr;
926 else if (to->si_code == SI_USER)
928 to->cpt_si_pid = from->si_pid;
929 to->cpt_si_uid = from->si_uid;
931 else if (to->si_code < 0)
933 to->cpt_si_pid = from->si_pid;
934 to->cpt_si_uid = from->si_uid;
935 to->cpt_si_ptr = (intptr_t) from->si_ptr;
939 switch (to->si_signo)
942 to->cpt_si_pid = from->si_pid;
943 to->cpt_si_uid = from->si_uid;
944 to->cpt_si_status = from->si_status;
945 memcpy (&to->cpt_si_utime, &from->si_utime,
946 sizeof (to->cpt_si_utime));
947 memcpy (&to->cpt_si_stime, &from->si_stime,
948 sizeof (to->cpt_si_stime));
954 to->cpt_si_addr = (intptr_t) from->si_addr;
957 to->cpt_si_band = from->si_band;
958 to->cpt_si_fd = from->si_fd;
961 to->cpt_si_pid = from->si_pid;
962 to->cpt_si_uid = from->si_uid;
963 to->cpt_si_ptr = (intptr_t) from->si_ptr;
970 siginfo_from_compat_x32_siginfo (siginfo_t *to,
971 compat_x32_siginfo_t *from)
973 memset (to, 0, sizeof (*to));
975 to->si_signo = from->si_signo;
976 to->si_errno = from->si_errno;
977 to->si_code = from->si_code;
979 if (to->si_code == SI_TIMER)
981 to->si_timerid = from->cpt_si_timerid;
982 to->si_overrun = from->cpt_si_overrun;
983 to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
985 else if (to->si_code == SI_USER)
987 to->si_pid = from->cpt_si_pid;
988 to->si_uid = from->cpt_si_uid;
992 to->si_pid = from->cpt_si_pid;
993 to->si_uid = from->cpt_si_uid;
994 to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
998 switch (to->si_signo)
1001 to->si_pid = from->cpt_si_pid;
1002 to->si_uid = from->cpt_si_uid;
1003 to->si_status = from->cpt_si_status;
1004 memcpy (&to->si_utime, &from->cpt_si_utime,
1005 sizeof (to->si_utime));
1006 memcpy (&to->si_stime, &from->cpt_si_stime,
1007 sizeof (to->si_stime));
1013 to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
1016 to->si_band = from->cpt_si_band;
1017 to->si_fd = from->cpt_si_fd;
1020 to->si_pid = from->cpt_si_pid;
1021 to->si_uid = from->cpt_si_uid;
1022 to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
1028 /* Convert a native/host siginfo object, into/from the siginfo in the
1029 layout of the inferiors' architecture. Returns true if any
1030 conversion was done; false otherwise. If DIRECTION is 1, then copy
1031 from INF to NATIVE. If DIRECTION is 0, copy from NATIVE to
1035 amd64_linux_siginfo_fixup (siginfo_t *native, gdb_byte *inf, int direction)
1037 struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
1039 /* Is the inferior 32-bit? If so, then do fixup the siginfo
1041 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
1043 gdb_assert (sizeof (siginfo_t) == sizeof (compat_siginfo_t));
1046 compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, native);
1048 siginfo_from_compat_siginfo (native, (struct compat_siginfo *) inf);
1052 /* No fixup for native x32 GDB. */
1053 else if (gdbarch_addr_bit (gdbarch) == 32 && sizeof (void *) == 8)
1055 gdb_assert (sizeof (siginfo_t) == sizeof (compat_x32_siginfo_t));
1058 compat_x32_siginfo_from_siginfo ((struct compat_x32_siginfo *) inf,
1061 siginfo_from_compat_x32_siginfo (native,
1062 (struct compat_x32_siginfo *) inf);
1071 /* Value of CS segment register:
1073 32bit process: 0x23 */
1074 #define AMD64_LINUX_USER64_CS 0x33
1076 /* Value of DS segment register:
1078 X32 process: 0x2b */
1079 #define AMD64_LINUX_X32_DS 0x2b
1082 /* Get Linux/x86 target description from running target. */
1084 static const struct target_desc *
1085 x86_linux_read_description (struct target_ops *ops)
1092 static uint64_t xcr0;
1093 uint64_t xcr0_features_bits;
1095 /* GNU/Linux LWP ID's are process ID's. */
1096 tid = ptid_get_lwp (inferior_ptid);
1098 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
1105 /* Get CS register. */
1107 cs = ptrace (PTRACE_PEEKUSER, tid,
1108 offsetof (struct user_regs_struct, cs), 0);
1110 perror_with_name (_("Couldn't get CS register"));
1112 is_64bit = cs == AMD64_LINUX_USER64_CS;
1114 /* Get DS register. */
1116 ds = ptrace (PTRACE_PEEKUSER, tid,
1117 offsetof (struct user_regs_struct, ds), 0);
1119 perror_with_name (_("Couldn't get DS register"));
1121 is_x32 = ds == AMD64_LINUX_X32_DS;
1123 if (sizeof (void *) == 4 && is_64bit && !is_x32)
1124 error (_("Can't debug 64-bit process with 32-bit GDB"));
1126 #elif HAVE_PTRACE_GETFPXREGS
1127 if (have_ptrace_getfpxregs == -1)
1129 elf_fpxregset_t fpxregs;
1131 if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
1133 have_ptrace_getfpxregs = 0;
1134 have_ptrace_getregset = 0;
1135 return tdesc_i386_mmx_linux;
1140 if (have_ptrace_getregset == -1)
1142 uint64_t xstateregs[(I386_XSTATE_SSE_SIZE / sizeof (uint64_t))];
1145 iov.iov_base = xstateregs;
1146 iov.iov_len = sizeof (xstateregs);
1148 /* Check if PTRACE_GETREGSET works. */
1149 if (ptrace (PTRACE_GETREGSET, tid,
1150 (unsigned int) NT_X86_XSTATE, &iov) < 0)
1151 have_ptrace_getregset = 0;
1154 have_ptrace_getregset = 1;
1156 /* Get XCR0 from XSAVE extended state. */
1157 xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
1158 / sizeof (uint64_t))];
1162 /* Check the native XCR0 only if PTRACE_GETREGSET is available. If
1163 PTRACE_GETREGSET is not available then set xcr0_features_bits to
1164 zero so that the "no-features" descriptions are returned by the
1166 if (have_ptrace_getregset)
1167 xcr0_features_bits = xcr0 & I386_XSTATE_ALL_MASK;
1169 xcr0_features_bits = 0;
1174 switch (xcr0_features_bits)
1176 case I386_XSTATE_MPX_AVX512_MASK:
1177 case I386_XSTATE_AVX512_MASK:
1179 return tdesc_x32_avx512_linux;
1181 return tdesc_amd64_avx512_linux;
1182 case I386_XSTATE_MPX_MASK:
1184 return tdesc_x32_avx_linux; /* No MPX on x32 using AVX. */
1186 return tdesc_amd64_mpx_linux;
1187 case I386_XSTATE_AVX_MASK:
1189 return tdesc_x32_avx_linux;
1191 return tdesc_amd64_avx_linux;
1194 return tdesc_x32_linux;
1196 return tdesc_amd64_linux;
1202 switch (xcr0_features_bits)
1204 case I386_XSTATE_MPX_AVX512_MASK:
1205 case I386_XSTATE_AVX512_MASK:
1206 return tdesc_i386_avx512_linux;
1207 case I386_XSTATE_MPX_MASK:
1208 return tdesc_i386_mpx_linux;
1209 case I386_XSTATE_AVX_MASK:
1210 return tdesc_i386_avx_linux;
1212 return tdesc_i386_linux;
1216 gdb_assert_not_reached ("failed to return tdesc");
1219 /* Enable branch tracing. */
1221 static struct btrace_target_info *
1222 x86_linux_enable_btrace (struct target_ops *self, ptid_t ptid)
1224 struct btrace_target_info *tinfo;
1225 struct gdbarch *gdbarch;
1228 tinfo = linux_enable_btrace (ptid);
1231 error (_("Could not enable branch tracing for %s: %s."),
1232 target_pid_to_str (ptid), safe_strerror (errno));
1234 /* Fill in the size of a pointer in bits. */
1235 gdbarch = target_thread_architecture (ptid);
1236 tinfo->ptr_bits = gdbarch_ptr_bit (gdbarch);
1241 /* Disable branch tracing. */
1244 x86_linux_disable_btrace (struct target_ops *self,
1245 struct btrace_target_info *tinfo)
1247 enum btrace_error errcode = linux_disable_btrace (tinfo);
1249 if (errcode != BTRACE_ERR_NONE)
1250 error (_("Could not disable branch tracing."));
1253 /* Teardown branch tracing. */
1256 x86_linux_teardown_btrace (struct target_ops *self,
1257 struct btrace_target_info *tinfo)
1259 /* Ignore errors. */
1260 linux_disable_btrace (tinfo);
1263 static enum btrace_error
1264 x86_linux_read_btrace (struct target_ops *self,
1265 VEC (btrace_block_s) **data,
1266 struct btrace_target_info *btinfo,
1267 enum btrace_read_type type)
1269 return linux_read_btrace (data, btinfo, type);
1272 /* Create an x86 GNU/Linux target. */
1274 static struct target_ops *
1275 x86_linux_create_target (void)
1277 /* Fill in the generic GNU/Linux methods. */
1278 struct target_ops *t = linux_target ();
1280 /* Initialize the debug register function vectors. */
1281 i386_use_watchpoints (t);
1282 i386_dr_low.set_control = x86_linux_dr_set_control;
1283 i386_dr_low.set_addr = x86_linux_dr_set_addr;
1284 i386_dr_low.get_addr = x86_linux_dr_get_addr;
1285 i386_dr_low.get_status = x86_linux_dr_get_status;
1286 i386_dr_low.get_control = x86_linux_dr_get_control;
1287 i386_set_debug_register_length (sizeof (void *));
1289 /* Override the GNU/Linux inferior startup hook. */
1290 super_post_startup_inferior = t->to_post_startup_inferior;
1291 t->to_post_startup_inferior = x86_linux_child_post_startup_inferior;
1293 /* Add the description reader. */
1294 t->to_read_description = x86_linux_read_description;
1296 /* Add btrace methods. */
1297 t->to_supports_btrace = linux_supports_btrace;
1298 t->to_enable_btrace = x86_linux_enable_btrace;
1299 t->to_disable_btrace = x86_linux_disable_btrace;
1300 t->to_teardown_btrace = x86_linux_teardown_btrace;
1301 t->to_read_btrace = x86_linux_read_btrace;
1306 /* Add an x86 GNU/Linux target. */
1309 x86_linux_add_target (struct target_ops *t)
1311 linux_nat_add_target (t);
1312 linux_nat_set_new_thread (t, x86_linux_new_thread);
1313 linux_nat_set_new_fork (t, x86_linux_new_fork);
1314 linux_nat_set_forget_process (t, i386_forget_process);
1315 linux_nat_set_prepare_to_resume (t, x86_linux_prepare_to_resume);
1318 /* Provide a prototype to silence -Wmissing-prototypes. */
1319 void _initialize_amd64_linux_nat (void);
1322 _initialize_amd64_linux_nat (void)
1324 struct target_ops *t;
1326 amd64_native_gregset32_reg_offset = amd64_linux_gregset32_reg_offset;
1327 amd64_native_gregset32_num_regs = I386_LINUX_NUM_REGS;
1328 amd64_native_gregset64_reg_offset = amd64_linux_gregset_reg_offset;
1329 amd64_native_gregset64_num_regs = AMD64_LINUX_NUM_REGS;
1331 gdb_assert (ARRAY_SIZE (amd64_linux_gregset32_reg_offset)
1332 == amd64_native_gregset32_num_regs);
1334 /* Create a generic x86 GNU/Linux target. */
1335 t = x86_linux_create_target ();
1337 /* Add our register access methods. */
1338 t->to_fetch_registers = amd64_linux_fetch_inferior_registers;
1339 t->to_store_registers = amd64_linux_store_inferior_registers;
1341 /* Add the target. */
1342 x86_linux_add_target (t);
1344 /* Add our siginfo layout converter. */
1345 linux_nat_set_siginfo_fixup (t, amd64_linux_siginfo_fixup);