1 /* Native-dependent code for GNU/Linux x86-64.
3 Copyright (C) 2001-2013 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
) (ptid_t ptid
);
574 amd64_linux_child_post_startup_inferior (ptid_t ptid
)
576 i386_cleanup_dregs ();
577 super_post_startup_inferior (ptid
);
581 /* When GDB is built as a 64-bit application on linux, the
582 PTRACE_GETSIGINFO data is always presented in 64-bit layout. Since
583 debugging a 32-bit inferior with a 64-bit GDB should look the same
584 as debugging it with a 32-bit GDB, we do the 32-bit <-> 64-bit
585 conversion in-place ourselves. */
587 /* These types below (compat_*) define a siginfo type that is layout
588 compatible with the siginfo type exported by the 32-bit userspace
591 typedef int compat_int_t
;
592 typedef unsigned int compat_uptr_t
;
594 typedef int compat_time_t
;
595 typedef int compat_timer_t
;
596 typedef int compat_clock_t
;
598 struct compat_timeval
600 compat_time_t tv_sec
;
604 typedef union compat_sigval
606 compat_int_t sival_int
;
607 compat_uptr_t sival_ptr
;
610 typedef struct compat_siginfo
618 int _pad
[((128 / sizeof (int)) - 3)];
627 /* POSIX.1b timers */
632 compat_sigval_t _sigval
;
635 /* POSIX.1b signals */
640 compat_sigval_t _sigval
;
649 compat_clock_t _utime
;
650 compat_clock_t _stime
;
653 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
668 /* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes. */
669 typedef struct compat_x32_clock
673 } compat_x32_clock_t
;
675 typedef struct compat_x32_siginfo
683 int _pad
[((128 / sizeof (int)) - 3)];
692 /* POSIX.1b timers */
697 compat_sigval_t _sigval
;
700 /* POSIX.1b signals */
705 compat_sigval_t _sigval
;
714 compat_x32_clock_t _utime
;
715 compat_x32_clock_t _stime
;
718 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
731 } compat_x32_siginfo_t
;
733 #define cpt_si_pid _sifields._kill._pid
734 #define cpt_si_uid _sifields._kill._uid
735 #define cpt_si_timerid _sifields._timer._tid
736 #define cpt_si_overrun _sifields._timer._overrun
737 #define cpt_si_status _sifields._sigchld._status
738 #define cpt_si_utime _sifields._sigchld._utime
739 #define cpt_si_stime _sifields._sigchld._stime
740 #define cpt_si_ptr _sifields._rt._sigval.sival_ptr
741 #define cpt_si_addr _sifields._sigfault._addr
742 #define cpt_si_band _sifields._sigpoll._band
743 #define cpt_si_fd _sifields._sigpoll._fd
745 /* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
746 In their place is si_timer1,si_timer2. */
748 #define si_timerid si_timer1
751 #define si_overrun si_timer2
755 compat_siginfo_from_siginfo (compat_siginfo_t
*to
, siginfo_t
*from
)
757 memset (to
, 0, sizeof (*to
));
759 to
->si_signo
= from
->si_signo
;
760 to
->si_errno
= from
->si_errno
;
761 to
->si_code
= from
->si_code
;
763 if (to
->si_code
== SI_TIMER
)
765 to
->cpt_si_timerid
= from
->si_timerid
;
766 to
->cpt_si_overrun
= from
->si_overrun
;
767 to
->cpt_si_ptr
= (intptr_t) from
->si_ptr
;
769 else if (to
->si_code
== SI_USER
)
771 to
->cpt_si_pid
= from
->si_pid
;
772 to
->cpt_si_uid
= from
->si_uid
;
774 else if (to
->si_code
< 0)
776 to
->cpt_si_pid
= from
->si_pid
;
777 to
->cpt_si_uid
= from
->si_uid
;
778 to
->cpt_si_ptr
= (intptr_t) from
->si_ptr
;
782 switch (to
->si_signo
)
785 to
->cpt_si_pid
= from
->si_pid
;
786 to
->cpt_si_uid
= from
->si_uid
;
787 to
->cpt_si_status
= from
->si_status
;
788 to
->cpt_si_utime
= from
->si_utime
;
789 to
->cpt_si_stime
= from
->si_stime
;
795 to
->cpt_si_addr
= (intptr_t) from
->si_addr
;
798 to
->cpt_si_band
= from
->si_band
;
799 to
->cpt_si_fd
= from
->si_fd
;
802 to
->cpt_si_pid
= from
->si_pid
;
803 to
->cpt_si_uid
= from
->si_uid
;
804 to
->cpt_si_ptr
= (intptr_t) from
->si_ptr
;
811 siginfo_from_compat_siginfo (siginfo_t
*to
, compat_siginfo_t
*from
)
813 memset (to
, 0, sizeof (*to
));
815 to
->si_signo
= from
->si_signo
;
816 to
->si_errno
= from
->si_errno
;
817 to
->si_code
= from
->si_code
;
819 if (to
->si_code
== SI_TIMER
)
821 to
->si_timerid
= from
->cpt_si_timerid
;
822 to
->si_overrun
= from
->cpt_si_overrun
;
823 to
->si_ptr
= (void *) (intptr_t) from
->cpt_si_ptr
;
825 else if (to
->si_code
== SI_USER
)
827 to
->si_pid
= from
->cpt_si_pid
;
828 to
->si_uid
= from
->cpt_si_uid
;
832 to
->si_pid
= from
->cpt_si_pid
;
833 to
->si_uid
= from
->cpt_si_uid
;
834 to
->si_ptr
= (void *) (intptr_t) from
->cpt_si_ptr
;
838 switch (to
->si_signo
)
841 to
->si_pid
= from
->cpt_si_pid
;
842 to
->si_uid
= from
->cpt_si_uid
;
843 to
->si_status
= from
->cpt_si_status
;
844 to
->si_utime
= from
->cpt_si_utime
;
845 to
->si_stime
= from
->cpt_si_stime
;
851 to
->si_addr
= (void *) (intptr_t) from
->cpt_si_addr
;
854 to
->si_band
= from
->cpt_si_band
;
855 to
->si_fd
= from
->cpt_si_fd
;
858 to
->si_pid
= from
->cpt_si_pid
;
859 to
->si_uid
= from
->cpt_si_uid
;
860 to
->si_ptr
= (void* ) (intptr_t) from
->cpt_si_ptr
;
867 compat_x32_siginfo_from_siginfo (compat_x32_siginfo_t
*to
,
870 memset (to
, 0, sizeof (*to
));
872 to
->si_signo
= from
->si_signo
;
873 to
->si_errno
= from
->si_errno
;
874 to
->si_code
= from
->si_code
;
876 if (to
->si_code
== SI_TIMER
)
878 to
->cpt_si_timerid
= from
->si_timerid
;
879 to
->cpt_si_overrun
= from
->si_overrun
;
880 to
->cpt_si_ptr
= (intptr_t) from
->si_ptr
;
882 else if (to
->si_code
== SI_USER
)
884 to
->cpt_si_pid
= from
->si_pid
;
885 to
->cpt_si_uid
= from
->si_uid
;
887 else if (to
->si_code
< 0)
889 to
->cpt_si_pid
= from
->si_pid
;
890 to
->cpt_si_uid
= from
->si_uid
;
891 to
->cpt_si_ptr
= (intptr_t) from
->si_ptr
;
895 switch (to
->si_signo
)
898 to
->cpt_si_pid
= from
->si_pid
;
899 to
->cpt_si_uid
= from
->si_uid
;
900 to
->cpt_si_status
= from
->si_status
;
901 memcpy (&to
->cpt_si_utime
, &from
->si_utime
,
902 sizeof (to
->cpt_si_utime
));
903 memcpy (&to
->cpt_si_stime
, &from
->si_stime
,
904 sizeof (to
->cpt_si_stime
));
910 to
->cpt_si_addr
= (intptr_t) from
->si_addr
;
913 to
->cpt_si_band
= from
->si_band
;
914 to
->cpt_si_fd
= from
->si_fd
;
917 to
->cpt_si_pid
= from
->si_pid
;
918 to
->cpt_si_uid
= from
->si_uid
;
919 to
->cpt_si_ptr
= (intptr_t) from
->si_ptr
;
926 siginfo_from_compat_x32_siginfo (siginfo_t
*to
,
927 compat_x32_siginfo_t
*from
)
929 memset (to
, 0, sizeof (*to
));
931 to
->si_signo
= from
->si_signo
;
932 to
->si_errno
= from
->si_errno
;
933 to
->si_code
= from
->si_code
;
935 if (to
->si_code
== SI_TIMER
)
937 to
->si_timerid
= from
->cpt_si_timerid
;
938 to
->si_overrun
= from
->cpt_si_overrun
;
939 to
->si_ptr
= (void *) (intptr_t) from
->cpt_si_ptr
;
941 else if (to
->si_code
== SI_USER
)
943 to
->si_pid
= from
->cpt_si_pid
;
944 to
->si_uid
= from
->cpt_si_uid
;
948 to
->si_pid
= from
->cpt_si_pid
;
949 to
->si_uid
= from
->cpt_si_uid
;
950 to
->si_ptr
= (void *) (intptr_t) from
->cpt_si_ptr
;
954 switch (to
->si_signo
)
957 to
->si_pid
= from
->cpt_si_pid
;
958 to
->si_uid
= from
->cpt_si_uid
;
959 to
->si_status
= from
->cpt_si_status
;
960 memcpy (&to
->si_utime
, &from
->cpt_si_utime
,
961 sizeof (to
->si_utime
));
962 memcpy (&to
->si_stime
, &from
->cpt_si_stime
,
963 sizeof (to
->si_stime
));
969 to
->si_addr
= (void *) (intptr_t) from
->cpt_si_addr
;
972 to
->si_band
= from
->cpt_si_band
;
973 to
->si_fd
= from
->cpt_si_fd
;
976 to
->si_pid
= from
->cpt_si_pid
;
977 to
->si_uid
= from
->cpt_si_uid
;
978 to
->si_ptr
= (void* ) (intptr_t) from
->cpt_si_ptr
;
984 /* Convert a native/host siginfo object, into/from the siginfo in the
985 layout of the inferiors' architecture. Returns true if any
986 conversion was done; false otherwise. If DIRECTION is 1, then copy
987 from INF to NATIVE. If DIRECTION is 0, copy from NATIVE to
991 amd64_linux_siginfo_fixup (siginfo_t
*native
, gdb_byte
*inf
, int direction
)
993 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
995 /* Is the inferior 32-bit? If so, then do fixup the siginfo
997 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
999 gdb_assert (sizeof (siginfo_t
) == sizeof (compat_siginfo_t
));
1002 compat_siginfo_from_siginfo ((struct compat_siginfo
*) inf
, native
);
1004 siginfo_from_compat_siginfo (native
, (struct compat_siginfo
*) inf
);
1008 /* No fixup for native x32 GDB. */
1009 else if (gdbarch_addr_bit (gdbarch
) == 32 && sizeof (void *) == 8)
1011 gdb_assert (sizeof (siginfo_t
) == sizeof (compat_x32_siginfo_t
));
1014 compat_x32_siginfo_from_siginfo ((struct compat_x32_siginfo
*) inf
,
1017 siginfo_from_compat_x32_siginfo (native
,
1018 (struct compat_x32_siginfo
*) inf
);
1026 /* Get Linux/x86 target description from running target.
1028 Value of CS segment register:
1029 1. 64bit process: 0x33.
1030 2. 32bit process: 0x23.
1032 Value of DS segment register:
1033 1. LP64 process: 0x0.
1034 2. X32 process: 0x2b.
1037 #define AMD64_LINUX_USER64_CS 0x33
1038 #define AMD64_LINUX_X32_DS 0x2b
1040 static const struct target_desc
*
1041 amd64_linux_read_description (struct target_ops
*ops
)
1048 static uint64_t xcr0
;
1050 /* GNU/Linux LWP ID's are process ID's. */
1051 tid
= ptid_get_lwp (inferior_ptid
);
1053 tid
= ptid_get_pid (inferior_ptid
); /* Not a threaded program. */
1055 /* Get CS register. */
1057 cs
= ptrace (PTRACE_PEEKUSER
, tid
,
1058 offsetof (struct user_regs_struct
, cs
), 0);
1060 perror_with_name (_("Couldn't get CS register"));
1062 is_64bit
= cs
== AMD64_LINUX_USER64_CS
;
1064 /* Get DS register. */
1066 ds
= ptrace (PTRACE_PEEKUSER
, tid
,
1067 offsetof (struct user_regs_struct
, ds
), 0);
1069 perror_with_name (_("Couldn't get DS register"));
1071 is_x32
= ds
== AMD64_LINUX_X32_DS
;
1073 if (sizeof (void *) == 4 && is_64bit
&& !is_x32
)
1074 error (_("Can't debug 64-bit process with 32-bit GDB"));
1076 if (have_ptrace_getregset
== -1)
1078 uint64_t xstateregs
[(I386_XSTATE_SSE_SIZE
/ sizeof (uint64_t))];
1081 iov
.iov_base
= xstateregs
;
1082 iov
.iov_len
= sizeof (xstateregs
);
1084 /* Check if PTRACE_GETREGSET works. */
1085 if (ptrace (PTRACE_GETREGSET
, tid
,
1086 (unsigned int) NT_X86_XSTATE
, (long) &iov
) < 0)
1087 have_ptrace_getregset
= 0;
1090 have_ptrace_getregset
= 1;
1092 /* Get XCR0 from XSAVE extended state. */
1093 xcr0
= xstateregs
[(I386_LINUX_XSAVE_XCR0_OFFSET
1094 / sizeof (uint64_t))];
1098 /* Check the native XCR0 only if PTRACE_GETREGSET is available. */
1099 if (have_ptrace_getregset
&& (xcr0
& I386_XSTATE_ALL_MASK
))
1101 switch (xcr0
& I386_XSTATE_ALL_MASK
)
1103 case I386_XSTATE_MPX_MASK
:
1107 return tdesc_x32_avx_linux
; /* No MPX on x32 using AVX. */
1109 return tdesc_amd64_mpx_linux
;
1112 return tdesc_i386_mpx_linux
;
1113 case I386_XSTATE_AVX_MASK
:
1117 return tdesc_x32_avx_linux
;
1119 return tdesc_amd64_avx_linux
;
1122 return tdesc_i386_avx_linux
;
1127 return tdesc_x32_linux
;
1129 return tdesc_amd64_linux
;
1132 return tdesc_i386_linux
;
1140 return tdesc_x32_linux
;
1142 return tdesc_amd64_linux
;
1145 return tdesc_i386_linux
;
1149 /* Enable branch tracing. */
1151 static struct btrace_target_info
*
1152 amd64_linux_enable_btrace (ptid_t ptid
)
1154 struct btrace_target_info
*tinfo
;
1155 struct gdbarch
*gdbarch
;
1158 tinfo
= linux_enable_btrace (ptid
);
1161 error (_("Could not enable branch tracing for %s: %s."),
1162 target_pid_to_str (ptid
), safe_strerror (errno
));
1164 /* Fill in the size of a pointer in bits. */
1165 gdbarch
= target_thread_architecture (ptid
);
1166 tinfo
->ptr_bits
= gdbarch_ptr_bit (gdbarch
);
1171 /* Disable branch tracing. */
1174 amd64_linux_disable_btrace (struct btrace_target_info
*tinfo
)
1176 int errcode
= linux_disable_btrace (tinfo
);
1179 error (_("Could not disable branch tracing: %s."), safe_strerror (errcode
));
1182 /* Teardown branch tracing. */
1185 amd64_linux_teardown_btrace (struct btrace_target_info
*tinfo
)
1187 /* Ignore errors. */
1188 linux_disable_btrace (tinfo
);
1191 /* Provide a prototype to silence -Wmissing-prototypes. */
1192 void _initialize_amd64_linux_nat (void);
1195 _initialize_amd64_linux_nat (void)
1197 struct target_ops
*t
;
1199 amd64_native_gregset32_reg_offset
= amd64_linux_gregset32_reg_offset
;
1200 amd64_native_gregset32_num_regs
= I386_LINUX_NUM_REGS
;
1201 amd64_native_gregset64_reg_offset
= amd64_linux_gregset_reg_offset
;
1202 amd64_native_gregset64_num_regs
= AMD64_LINUX_NUM_REGS
;
1204 gdb_assert (ARRAY_SIZE (amd64_linux_gregset32_reg_offset
)
1205 == amd64_native_gregset32_num_regs
);
1207 /* Fill in the generic GNU/Linux methods. */
1208 t
= linux_target ();
1210 i386_use_watchpoints (t
);
1212 i386_dr_low
.set_control
= amd64_linux_dr_set_control
;
1213 i386_dr_low
.set_addr
= amd64_linux_dr_set_addr
;
1214 i386_dr_low
.get_addr
= amd64_linux_dr_get_addr
;
1215 i386_dr_low
.get_status
= amd64_linux_dr_get_status
;
1216 i386_dr_low
.get_control
= amd64_linux_dr_get_control
;
1217 i386_set_debug_register_length (8);
1219 /* Override the GNU/Linux inferior startup hook. */
1220 super_post_startup_inferior
= t
->to_post_startup_inferior
;
1221 t
->to_post_startup_inferior
= amd64_linux_child_post_startup_inferior
;
1223 /* Add our register access methods. */
1224 t
->to_fetch_registers
= amd64_linux_fetch_inferior_registers
;
1225 t
->to_store_registers
= amd64_linux_store_inferior_registers
;
1227 t
->to_read_description
= amd64_linux_read_description
;
1229 /* Add btrace methods. */
1230 t
->to_supports_btrace
= linux_supports_btrace
;
1231 t
->to_enable_btrace
= amd64_linux_enable_btrace
;
1232 t
->to_disable_btrace
= amd64_linux_disable_btrace
;
1233 t
->to_teardown_btrace
= amd64_linux_teardown_btrace
;
1234 t
->to_read_btrace
= linux_read_btrace
;
1236 /* Register the target. */
1237 linux_nat_add_target (t
);
1238 linux_nat_set_new_thread (t
, amd64_linux_new_thread
);
1239 linux_nat_set_new_fork (t
, amd64_linux_new_fork
);
1240 linux_nat_set_forget_process (t
, i386_forget_process
);
1241 linux_nat_set_siginfo_fixup (t
, amd64_linux_siginfo_fixup
);
1242 linux_nat_set_prepare_to_resume (t
, amd64_linux_prepare_to_resume
);