1 /* Native-dependent code for GNU/Linux x86 (i386 and x86-64).
3 Copyright (C) 1999-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "elf/common.h"
23 #include "gdb_proc_service.h"
24 #include <sys/ptrace.h>
26 #include <sys/procfs.h>
30 #include "linux-nat.h"
32 #include "i386-linux-nat.h"
34 #include "x86-linux-nat.h"
35 #include "i386-linux-tdep.h"
37 #include "amd64-linux-tdep.h"
39 #include "x86-xstate.h"
40 #include "nat/linux-btrace.h"
41 #include "nat/linux-nat.h"
43 /* Per-thread arch-specific data we want to keep. */
47 /* Non-zero if our copy differs from what's recorded in the thread. */
48 int debug_registers_changed
;
51 /* Does the current host support PTRACE_GETREGSET? */
52 int have_ptrace_getregset
= -1;
55 /* Return the offset of REGNUM in the u_debugreg field of struct
59 u_debugreg_offset (int regnum
)
61 return (offsetof (struct user
, u_debugreg
)
62 + sizeof (((struct user
*) 0)->u_debugreg
[0]) * regnum
);
65 /* Support for debug registers. */
67 /* Get debug register REGNUM value from only the one LWP of PTID. */
70 x86_linux_dr_get (ptid_t ptid
, int regnum
)
75 gdb_assert (ptid_lwp_p (ptid
));
76 tid
= ptid_get_lwp (ptid
);
79 value
= ptrace (PTRACE_PEEKUSER
, tid
, u_debugreg_offset (regnum
), 0);
82 perror_with_name (_("Couldn't read debug register"));
87 /* Set debug register REGNUM to VALUE in only the one LWP of PTID. */
90 x86_linux_dr_set (ptid_t ptid
, int regnum
, unsigned long value
)
94 gdb_assert (ptid_lwp_p (ptid
));
95 tid
= ptid_get_lwp (ptid
);
98 ptrace (PTRACE_POKEUSER
, tid
, u_debugreg_offset (regnum
), value
);
100 perror_with_name (_("Couldn't write debug register"));
103 /* Return the inferior's debug register REGNUM. */
106 x86_linux_dr_get_addr (int regnum
)
108 /* DR6 and DR7 are retrieved with some other way. */
109 gdb_assert (DR_FIRSTADDR
<= regnum
&& regnum
<= DR_LASTADDR
);
111 return x86_linux_dr_get (current_lwp_ptid (), regnum
);
114 /* Return the inferior's DR7 debug control register. */
117 x86_linux_dr_get_control (void)
119 return x86_linux_dr_get (current_lwp_ptid (), DR_CONTROL
);
122 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID. */
125 x86_linux_dr_get_status (void)
127 return x86_linux_dr_get (current_lwp_ptid (), DR_STATUS
);
130 /* Callback for iterate_over_lwps. Update the debug registers of
134 update_debug_registers_callback (struct lwp_info
*lwp
, void *arg
)
136 if (lwp
->arch_private
== NULL
)
137 lwp
->arch_private
= XCNEW (struct arch_lwp_info
);
139 /* The actual update is done later just before resuming the lwp, we
140 just mark that the registers need updating. */
141 lwp
->arch_private
->debug_registers_changed
= 1;
143 /* If the lwp isn't stopped, force it to momentarily pause, so we
144 can update its debug registers. */
145 if (!lwp_is_stopped (lwp
))
146 linux_stop_lwp (lwp
);
148 /* Continue the iteration. */
152 /* Set DR_CONTROL to CONTROL in all LWPs of the current inferior. */
155 x86_linux_dr_set_control (unsigned long control
)
157 ptid_t pid_ptid
= pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
159 iterate_over_lwps (pid_ptid
, update_debug_registers_callback
, NULL
);
162 /* Set address REGNUM (zero based) to ADDR in all LWPs of the current
166 x86_linux_dr_set_addr (int regnum
, CORE_ADDR addr
)
168 ptid_t pid_ptid
= pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
170 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
172 iterate_over_lwps (pid_ptid
, update_debug_registers_callback
, NULL
);
175 /* Called when resuming a thread.
176 If the debug regs have changed, update the thread's copies. */
179 x86_linux_prepare_to_resume (struct lwp_info
*lwp
)
181 ptid_t ptid
= ptid_of_lwp (lwp
);
182 int clear_status
= 0;
184 /* NULL means this is the main thread still going through the shell,
185 or, no watchpoint has been set yet. In that case, there's
187 if (lwp
->arch_private
== NULL
)
190 if (lwp
->arch_private
->debug_registers_changed
)
192 struct x86_debug_reg_state
*state
193 = x86_debug_reg_state (ptid_get_pid (ptid
));
196 /* On Linux kernel before 2.6.33 commit
197 72f674d203cd230426437cdcf7dd6f681dad8b0d
198 if you enable a breakpoint by the DR_CONTROL bits you need to have
199 already written the corresponding DR_FIRSTADDR...DR_LASTADDR registers.
201 Ensure DR_CONTROL gets written as the very last register here. */
203 /* Clear DR_CONTROL first. In some cases, setting DR0-3 to a
204 value that doesn't match what is enabled in DR_CONTROL
205 results in EINVAL. */
206 x86_linux_dr_set (ptid
, DR_CONTROL
, 0);
208 ALL_DEBUG_ADDRESS_REGISTERS (i
)
209 if (state
->dr_ref_count
[i
] > 0)
211 x86_linux_dr_set (ptid
, i
, state
->dr_mirror
[i
]);
213 /* If we're setting a watchpoint, any change the inferior
214 had done itself to the debug registers needs to be
215 discarded, otherwise, x86_stopped_data_address can get
220 /* If DR_CONTROL is supposed to be zero, we've already set it
222 if (state
->dr_control_mirror
!= 0)
223 x86_linux_dr_set (ptid
, DR_CONTROL
, state
->dr_control_mirror
);
225 lwp
->arch_private
->debug_registers_changed
= 0;
229 || lwp_stop_reason (lwp
) == TARGET_STOPPED_BY_WATCHPOINT
)
230 x86_linux_dr_set (ptid
, DR_STATUS
, 0);
234 x86_linux_new_thread (struct lwp_info
*lp
)
236 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
238 info
->debug_registers_changed
= 1;
240 lp
->arch_private
= info
;
244 /* linux_nat_new_fork hook. */
247 x86_linux_new_fork (struct lwp_info
*parent
, pid_t child_pid
)
250 struct x86_debug_reg_state
*parent_state
;
251 struct x86_debug_reg_state
*child_state
;
253 /* NULL means no watchpoint has ever been set in the parent. In
254 that case, there's nothing to do. */
255 if (parent
->arch_private
== NULL
)
258 /* Linux kernel before 2.6.33 commit
259 72f674d203cd230426437cdcf7dd6f681dad8b0d
260 will inherit hardware debug registers from parent
261 on fork/vfork/clone. Newer Linux kernels create such tasks with
262 zeroed debug registers.
264 GDB core assumes the child inherits the watchpoints/hw
265 breakpoints of the parent, and will remove them all from the
266 forked off process. Copy the debug registers mirrors into the
267 new process so that all breakpoints and watchpoints can be
268 removed together. The debug registers mirror will become zeroed
269 in the end before detaching the forked off process, thus making
270 this compatible with older Linux kernels too. */
272 parent_pid
= ptid_get_pid (parent
->ptid
);
273 parent_state
= x86_debug_reg_state (parent_pid
);
274 child_state
= x86_debug_reg_state (child_pid
);
275 *child_state
= *parent_state
;
279 static void (*super_post_startup_inferior
) (struct target_ops
*self
,
283 x86_linux_child_post_startup_inferior (struct target_ops
*self
, ptid_t ptid
)
285 x86_cleanup_dregs ();
286 super_post_startup_inferior (self
, ptid
);
290 /* Value of CS segment register:
292 32bit process: 0x23 */
293 #define AMD64_LINUX_USER64_CS 0x33
295 /* Value of DS segment register:
298 #define AMD64_LINUX_X32_DS 0x2b
301 /* Get Linux/x86 target description from running target. */
303 static const struct target_desc
*
304 x86_linux_read_description (struct target_ops
*ops
)
311 static uint64_t xcr0
;
312 uint64_t xcr0_features_bits
;
314 /* GNU/Linux LWP ID's are process ID's. */
315 tid
= ptid_get_lwp (inferior_ptid
);
317 tid
= ptid_get_pid (inferior_ptid
); /* Not a threaded program. */
324 /* Get CS register. */
326 cs
= ptrace (PTRACE_PEEKUSER
, tid
,
327 offsetof (struct user_regs_struct
, cs
), 0);
329 perror_with_name (_("Couldn't get CS register"));
331 is_64bit
= cs
== AMD64_LINUX_USER64_CS
;
333 /* Get DS register. */
335 ds
= ptrace (PTRACE_PEEKUSER
, tid
,
336 offsetof (struct user_regs_struct
, ds
), 0);
338 perror_with_name (_("Couldn't get DS register"));
340 is_x32
= ds
== AMD64_LINUX_X32_DS
;
342 if (sizeof (void *) == 4 && is_64bit
&& !is_x32
)
343 error (_("Can't debug 64-bit process with 32-bit GDB"));
345 #elif HAVE_PTRACE_GETFPXREGS
346 if (have_ptrace_getfpxregs
== -1)
348 elf_fpxregset_t fpxregs
;
350 if (ptrace (PTRACE_GETFPXREGS
, tid
, 0, (int) &fpxregs
) < 0)
352 have_ptrace_getfpxregs
= 0;
353 have_ptrace_getregset
= 0;
354 return tdesc_i386_mmx_linux
;
359 if (have_ptrace_getregset
== -1)
361 uint64_t xstateregs
[(X86_XSTATE_SSE_SIZE
/ sizeof (uint64_t))];
364 iov
.iov_base
= xstateregs
;
365 iov
.iov_len
= sizeof (xstateregs
);
367 /* Check if PTRACE_GETREGSET works. */
368 if (ptrace (PTRACE_GETREGSET
, tid
,
369 (unsigned int) NT_X86_XSTATE
, &iov
) < 0)
370 have_ptrace_getregset
= 0;
373 have_ptrace_getregset
= 1;
375 /* Get XCR0 from XSAVE extended state. */
376 xcr0
= xstateregs
[(I386_LINUX_XSAVE_XCR0_OFFSET
377 / sizeof (uint64_t))];
381 /* Check the native XCR0 only if PTRACE_GETREGSET is available. If
382 PTRACE_GETREGSET is not available then set xcr0_features_bits to
383 zero so that the "no-features" descriptions are returned by the
385 if (have_ptrace_getregset
)
386 xcr0_features_bits
= xcr0
& X86_XSTATE_ALL_MASK
;
388 xcr0_features_bits
= 0;
393 switch (xcr0_features_bits
)
395 case X86_XSTATE_MPX_AVX512_MASK
:
396 case X86_XSTATE_AVX512_MASK
:
398 return tdesc_x32_avx512_linux
;
400 return tdesc_amd64_avx512_linux
;
401 case X86_XSTATE_MPX_MASK
:
403 return tdesc_x32_avx_linux
; /* No MPX on x32 using AVX. */
405 return tdesc_amd64_mpx_linux
;
406 case X86_XSTATE_AVX_MASK
:
408 return tdesc_x32_avx_linux
;
410 return tdesc_amd64_avx_linux
;
413 return tdesc_x32_linux
;
415 return tdesc_amd64_linux
;
421 switch (xcr0_features_bits
)
423 case X86_XSTATE_MPX_AVX512_MASK
:
424 case X86_XSTATE_AVX512_MASK
:
425 return tdesc_i386_avx512_linux
;
426 case X86_XSTATE_MPX_MASK
:
427 return tdesc_i386_mpx_linux
;
428 case X86_XSTATE_AVX_MASK
:
429 return tdesc_i386_avx_linux
;
431 return tdesc_i386_linux
;
435 gdb_assert_not_reached ("failed to return tdesc");
439 /* Enable branch tracing. */
441 static struct btrace_target_info
*
442 x86_linux_enable_btrace (struct target_ops
*self
, ptid_t ptid
,
443 const struct btrace_config
*conf
)
445 struct btrace_target_info
*tinfo
;
446 struct gdbarch
*gdbarch
;
449 tinfo
= linux_enable_btrace (ptid
, conf
);
452 error (_("Could not enable branch tracing for %s: %s."),
453 target_pid_to_str (ptid
), safe_strerror (errno
));
455 /* Fill in the size of a pointer in bits. */
456 if (tinfo
->ptr_bits
== 0)
458 gdbarch
= target_thread_architecture (ptid
);
459 tinfo
->ptr_bits
= gdbarch_ptr_bit (gdbarch
);
464 /* Disable branch tracing. */
467 x86_linux_disable_btrace (struct target_ops
*self
,
468 struct btrace_target_info
*tinfo
)
470 enum btrace_error errcode
= linux_disable_btrace (tinfo
);
472 if (errcode
!= BTRACE_ERR_NONE
)
473 error (_("Could not disable branch tracing."));
476 /* Teardown branch tracing. */
479 x86_linux_teardown_btrace (struct target_ops
*self
,
480 struct btrace_target_info
*tinfo
)
483 linux_disable_btrace (tinfo
);
486 static enum btrace_error
487 x86_linux_read_btrace (struct target_ops
*self
,
488 struct btrace_data
*data
,
489 struct btrace_target_info
*btinfo
,
490 enum btrace_read_type type
)
492 return linux_read_btrace (data
, btinfo
, type
);
495 /* See to_btrace_conf in target.h. */
497 static const struct btrace_config
*
498 x86_linux_btrace_conf (struct target_ops
*self
,
499 const struct btrace_target_info
*btinfo
)
501 return linux_btrace_conf (btinfo
);
506 /* Helper for ps_get_thread_area. Sets BASE_ADDR to a pointer to
507 the thread local storage (or its descriptor) and returns PS_OK
508 on success. Returns PS_ERR on failure. */
511 x86_linux_get_thread_area (pid_t pid
, void *addr
, unsigned int *base_addr
)
513 /* NOTE: cagney/2003-08-26: The definition of this buffer is found
514 in the kernel header <asm-i386/ldt.h>. It, after padding, is 4 x
515 4 byte integers in size: `entry_number', `base_addr', `limit',
516 and a bunch of status bits.
518 The values returned by this ptrace call should be part of the
519 regcache buffer, and ps_get_thread_area should channel its
520 request through the regcache. That way remote targets could
521 provide the value using the remote protocol and not this direct
524 Is this function needed? I'm guessing that the `base' is the
525 address of a descriptor that libthread_db uses to find the
526 thread local address base that GDB needs. Perhaps that
527 descriptor is defined by the ABI. Anyway, given that
528 libthread_db calls this function without prompting (gdb
529 requesting tls base) I guess it needs info in there anyway. */
530 unsigned int desc
[4];
532 /* This code assumes that "int" is 32 bits and that
533 GET_THREAD_AREA returns no more than 4 int values. */
534 gdb_assert (sizeof (int) == 4);
536 #ifndef PTRACE_GET_THREAD_AREA
537 #define PTRACE_GET_THREAD_AREA 25
540 if (ptrace (PTRACE_GET_THREAD_AREA
, pid
, addr
, &desc
) < 0)
543 *base_addr
= desc
[1];
548 /* Create an x86 GNU/Linux target. */
551 x86_linux_create_target (void)
553 /* Fill in the generic GNU/Linux methods. */
554 struct target_ops
*t
= linux_target ();
556 /* Initialize the debug register function vectors. */
557 x86_use_watchpoints (t
);
558 x86_dr_low
.set_control
= x86_linux_dr_set_control
;
559 x86_dr_low
.set_addr
= x86_linux_dr_set_addr
;
560 x86_dr_low
.get_addr
= x86_linux_dr_get_addr
;
561 x86_dr_low
.get_status
= x86_linux_dr_get_status
;
562 x86_dr_low
.get_control
= x86_linux_dr_get_control
;
563 x86_set_debug_register_length (sizeof (void *));
565 /* Override the GNU/Linux inferior startup hook. */
566 super_post_startup_inferior
= t
->to_post_startup_inferior
;
567 t
->to_post_startup_inferior
= x86_linux_child_post_startup_inferior
;
569 /* Add the description reader. */
570 t
->to_read_description
= x86_linux_read_description
;
572 /* Add btrace methods. */
573 t
->to_supports_btrace
= linux_supports_btrace
;
574 t
->to_enable_btrace
= x86_linux_enable_btrace
;
575 t
->to_disable_btrace
= x86_linux_disable_btrace
;
576 t
->to_teardown_btrace
= x86_linux_teardown_btrace
;
577 t
->to_read_btrace
= x86_linux_read_btrace
;
578 t
->to_btrace_conf
= x86_linux_btrace_conf
;
583 /* Add an x86 GNU/Linux target. */
586 x86_linux_add_target (struct target_ops
*t
)
588 linux_nat_add_target (t
);
589 linux_nat_set_new_thread (t
, x86_linux_new_thread
);
590 linux_nat_set_new_fork (t
, x86_linux_new_fork
);
591 linux_nat_set_forget_process (t
, x86_forget_process
);
592 linux_nat_set_prepare_to_resume (t
, x86_linux_prepare_to_resume
);