1 /* Native-dependent code for GNU/Linux x86 (i386 and x86-64).
3 Copyright (C) 1999-2014 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>
29 #include "linux-nat.h"
31 #include "i386-linux-nat.h"
33 #include "x86-linux-nat.h"
34 #include "i386-linux-tdep.h"
36 #include "amd64-linux-tdep.h"
38 #include "x86-xstate.h"
39 #include "nat/linux-btrace.h"
41 /* Per-thread arch-specific data we want to keep. */
45 /* Non-zero if our copy differs from what's recorded in the thread. */
46 int debug_registers_changed
;
49 /* Does the current host support PTRACE_GETREGSET? */
50 int have_ptrace_getregset
= -1;
53 /* Support for debug registers. */
55 /* Get debug register REGNUM value from only the one LWP of PTID. */
58 x86_linux_dr_get (ptid_t ptid
, int regnum
)
63 gdb_assert (ptid_lwp_p (ptid
));
64 tid
= ptid_get_lwp (ptid
);
67 value
= ptrace (PTRACE_PEEKUSER
, tid
,
68 offsetof (struct user
, u_debugreg
[regnum
]), 0);
70 perror_with_name (_("Couldn't read debug register"));
75 /* Set debug register REGNUM to VALUE in only the one LWP of PTID. */
78 x86_linux_dr_set (ptid_t ptid
, int regnum
, unsigned long value
)
82 gdb_assert (ptid_lwp_p (ptid
));
83 tid
= ptid_get_lwp (ptid
);
86 ptrace (PTRACE_POKEUSER
, tid
,
87 offsetof (struct user
, u_debugreg
[regnum
]), value
);
89 perror_with_name (_("Couldn't write debug register"));
92 /* Return the inferior's debug register REGNUM. */
95 x86_linux_dr_get_addr (int regnum
)
97 /* DR6 and DR7 are retrieved with some other way. */
98 gdb_assert (DR_FIRSTADDR
<= regnum
&& regnum
<= DR_LASTADDR
);
100 return x86_linux_dr_get (inferior_ptid
, regnum
);
103 /* Return the inferior's DR7 debug control register. */
106 x86_linux_dr_get_control (void)
108 return x86_linux_dr_get (inferior_ptid
, DR_CONTROL
);
111 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID. */
114 x86_linux_dr_get_status (void)
116 return x86_linux_dr_get (inferior_ptid
, DR_STATUS
);
119 /* Callback for iterate_over_lwps. Update the debug registers of
123 update_debug_registers_callback (struct lwp_info
*lwp
, void *arg
)
125 if (lwp
->arch_private
== NULL
)
126 lwp
->arch_private
= XCNEW (struct arch_lwp_info
);
128 /* The actual update is done later just before resuming the lwp, we
129 just mark that the registers need updating. */
130 lwp
->arch_private
->debug_registers_changed
= 1;
132 /* If the lwp isn't stopped, force it to momentarily pause, so we
133 can update its debug registers. */
135 linux_stop_lwp (lwp
);
137 /* Continue the iteration. */
141 /* Set DR_CONTROL to CONTROL in all LWPs of the current inferior. */
144 x86_linux_dr_set_control (unsigned long control
)
146 ptid_t pid_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
148 iterate_over_lwps (pid_ptid
, update_debug_registers_callback
, NULL
);
151 /* Set address REGNUM (zero based) to ADDR in all LWPs of the current
155 x86_linux_dr_set_addr (int regnum
, CORE_ADDR addr
)
157 ptid_t pid_ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
159 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
161 iterate_over_lwps (pid_ptid
, update_debug_registers_callback
, NULL
);
164 /* Called when resuming a thread.
165 If the debug regs have changed, update the thread's copies. */
168 x86_linux_prepare_to_resume (struct lwp_info
*lwp
)
170 int clear_status
= 0;
172 /* NULL means this is the main thread still going through the shell,
173 or, no watchpoint has been set yet. In that case, there's
175 if (lwp
->arch_private
== NULL
)
178 if (lwp
->arch_private
->debug_registers_changed
)
180 struct x86_debug_reg_state
*state
181 = x86_debug_reg_state (ptid_get_pid (lwp
->ptid
));
184 /* On Linux kernel before 2.6.33 commit
185 72f674d203cd230426437cdcf7dd6f681dad8b0d
186 if you enable a breakpoint by the DR_CONTROL bits you need to have
187 already written the corresponding DR_FIRSTADDR...DR_LASTADDR registers.
189 Ensure DR_CONTROL gets written as the very last register here. */
191 /* Clear DR_CONTROL first. In some cases, setting DR0-3 to a
192 value that doesn't match what is enabled in DR_CONTROL
193 results in EINVAL. */
194 x86_linux_dr_set (lwp
->ptid
, DR_CONTROL
, 0);
196 ALL_DEBUG_ADDRESS_REGISTERS (i
)
197 if (state
->dr_ref_count
[i
] > 0)
199 x86_linux_dr_set (lwp
->ptid
, i
, state
->dr_mirror
[i
]);
201 /* If we're setting a watchpoint, any change the inferior
202 had done itself to the debug registers needs to be
203 discarded, otherwise, x86_stopped_data_address can get
208 /* If DR_CONTROL is supposed to be zero, we've already set it
210 if (state
->dr_control_mirror
!= 0)
211 x86_linux_dr_set (lwp
->ptid
, DR_CONTROL
, state
->dr_control_mirror
);
213 lwp
->arch_private
->debug_registers_changed
= 0;
216 if (clear_status
|| lwp
->stopped_by_watchpoint
)
217 x86_linux_dr_set (lwp
->ptid
, DR_STATUS
, 0);
221 x86_linux_new_thread (struct lwp_info
*lp
)
223 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
225 info
->debug_registers_changed
= 1;
227 lp
->arch_private
= info
;
231 /* linux_nat_new_fork hook. */
234 x86_linux_new_fork (struct lwp_info
*parent
, pid_t child_pid
)
237 struct x86_debug_reg_state
*parent_state
;
238 struct x86_debug_reg_state
*child_state
;
240 /* NULL means no watchpoint has ever been set in the parent. In
241 that case, there's nothing to do. */
242 if (parent
->arch_private
== NULL
)
245 /* Linux kernel before 2.6.33 commit
246 72f674d203cd230426437cdcf7dd6f681dad8b0d
247 will inherit hardware debug registers from parent
248 on fork/vfork/clone. Newer Linux kernels create such tasks with
249 zeroed debug registers.
251 GDB core assumes the child inherits the watchpoints/hw
252 breakpoints of the parent, and will remove them all from the
253 forked off process. Copy the debug registers mirrors into the
254 new process so that all breakpoints and watchpoints can be
255 removed together. The debug registers mirror will become zeroed
256 in the end before detaching the forked off process, thus making
257 this compatible with older Linux kernels too. */
259 parent_pid
= ptid_get_pid (parent
->ptid
);
260 parent_state
= x86_debug_reg_state (parent_pid
);
261 child_state
= x86_debug_reg_state (child_pid
);
262 *child_state
= *parent_state
;
266 static void (*super_post_startup_inferior
) (struct target_ops
*self
,
270 x86_linux_child_post_startup_inferior (struct target_ops
*self
, ptid_t ptid
)
272 x86_cleanup_dregs ();
273 super_post_startup_inferior (self
, ptid
);
277 /* Value of CS segment register:
279 32bit process: 0x23 */
280 #define AMD64_LINUX_USER64_CS 0x33
282 /* Value of DS segment register:
285 #define AMD64_LINUX_X32_DS 0x2b
288 /* Get Linux/x86 target description from running target. */
290 static const struct target_desc
*
291 x86_linux_read_description (struct target_ops
*ops
)
298 static uint64_t xcr0
;
299 uint64_t xcr0_features_bits
;
301 /* GNU/Linux LWP ID's are process ID's. */
302 tid
= ptid_get_lwp (inferior_ptid
);
304 tid
= ptid_get_pid (inferior_ptid
); /* Not a threaded program. */
311 /* Get CS register. */
313 cs
= ptrace (PTRACE_PEEKUSER
, tid
,
314 offsetof (struct user_regs_struct
, cs
), 0);
316 perror_with_name (_("Couldn't get CS register"));
318 is_64bit
= cs
== AMD64_LINUX_USER64_CS
;
320 /* Get DS register. */
322 ds
= ptrace (PTRACE_PEEKUSER
, tid
,
323 offsetof (struct user_regs_struct
, ds
), 0);
325 perror_with_name (_("Couldn't get DS register"));
327 is_x32
= ds
== AMD64_LINUX_X32_DS
;
329 if (sizeof (void *) == 4 && is_64bit
&& !is_x32
)
330 error (_("Can't debug 64-bit process with 32-bit GDB"));
332 #elif HAVE_PTRACE_GETFPXREGS
333 if (have_ptrace_getfpxregs
== -1)
335 elf_fpxregset_t fpxregs
;
337 if (ptrace (PTRACE_GETFPXREGS
, tid
, 0, (int) &fpxregs
) < 0)
339 have_ptrace_getfpxregs
= 0;
340 have_ptrace_getregset
= 0;
341 return tdesc_i386_mmx_linux
;
346 if (have_ptrace_getregset
== -1)
348 uint64_t xstateregs
[(X86_XSTATE_SSE_SIZE
/ sizeof (uint64_t))];
351 iov
.iov_base
= xstateregs
;
352 iov
.iov_len
= sizeof (xstateregs
);
354 /* Check if PTRACE_GETREGSET works. */
355 if (ptrace (PTRACE_GETREGSET
, tid
,
356 (unsigned int) NT_X86_XSTATE
, &iov
) < 0)
357 have_ptrace_getregset
= 0;
360 have_ptrace_getregset
= 1;
362 /* Get XCR0 from XSAVE extended state. */
363 xcr0
= xstateregs
[(I386_LINUX_XSAVE_XCR0_OFFSET
364 / sizeof (uint64_t))];
368 /* Check the native XCR0 only if PTRACE_GETREGSET is available. If
369 PTRACE_GETREGSET is not available then set xcr0_features_bits to
370 zero so that the "no-features" descriptions are returned by the
372 if (have_ptrace_getregset
)
373 xcr0_features_bits
= xcr0
& X86_XSTATE_ALL_MASK
;
375 xcr0_features_bits
= 0;
380 switch (xcr0_features_bits
)
382 case X86_XSTATE_MPX_AVX512_MASK
:
383 case X86_XSTATE_AVX512_MASK
:
385 return tdesc_x32_avx512_linux
;
387 return tdesc_amd64_avx512_linux
;
388 case X86_XSTATE_MPX_MASK
:
390 return tdesc_x32_avx_linux
; /* No MPX on x32 using AVX. */
392 return tdesc_amd64_mpx_linux
;
393 case X86_XSTATE_AVX_MASK
:
395 return tdesc_x32_avx_linux
;
397 return tdesc_amd64_avx_linux
;
400 return tdesc_x32_linux
;
402 return tdesc_amd64_linux
;
408 switch (xcr0_features_bits
)
410 case X86_XSTATE_MPX_AVX512_MASK
:
411 case X86_XSTATE_AVX512_MASK
:
412 return tdesc_i386_avx512_linux
;
413 case X86_XSTATE_MPX_MASK
:
414 return tdesc_i386_mpx_linux
;
415 case X86_XSTATE_AVX_MASK
:
416 return tdesc_i386_avx_linux
;
418 return tdesc_i386_linux
;
422 gdb_assert_not_reached ("failed to return tdesc");
426 /* Enable branch tracing. */
428 static struct btrace_target_info
*
429 x86_linux_enable_btrace (struct target_ops
*self
, ptid_t ptid
)
431 struct btrace_target_info
*tinfo
;
432 struct gdbarch
*gdbarch
;
435 tinfo
= linux_enable_btrace (ptid
);
438 error (_("Could not enable branch tracing for %s: %s."),
439 target_pid_to_str (ptid
), safe_strerror (errno
));
441 /* Fill in the size of a pointer in bits. */
442 gdbarch
= target_thread_architecture (ptid
);
443 tinfo
->ptr_bits
= gdbarch_ptr_bit (gdbarch
);
448 /* Disable branch tracing. */
451 x86_linux_disable_btrace (struct target_ops
*self
,
452 struct btrace_target_info
*tinfo
)
454 enum btrace_error errcode
= linux_disable_btrace (tinfo
);
456 if (errcode
!= BTRACE_ERR_NONE
)
457 error (_("Could not disable branch tracing."));
460 /* Teardown branch tracing. */
463 x86_linux_teardown_btrace (struct target_ops
*self
,
464 struct btrace_target_info
*tinfo
)
467 linux_disable_btrace (tinfo
);
470 static enum btrace_error
471 x86_linux_read_btrace (struct target_ops
*self
,
472 VEC (btrace_block_s
) **data
,
473 struct btrace_target_info
*btinfo
,
474 enum btrace_read_type type
)
476 return linux_read_btrace (data
, btinfo
, type
);
480 /* Helper for ps_get_thread_area. Sets BASE_ADDR to a pointer to
481 the thread local storage (or its descriptor) and returns PS_OK
482 on success. Returns PS_ERR on failure. */
485 x86_linux_get_thread_area (pid_t pid
, void *addr
, unsigned int *base_addr
)
487 /* NOTE: cagney/2003-08-26: The definition of this buffer is found
488 in the kernel header <asm-i386/ldt.h>. It, after padding, is 4 x
489 4 byte integers in size: `entry_number', `base_addr', `limit',
490 and a bunch of status bits.
492 The values returned by this ptrace call should be part of the
493 regcache buffer, and ps_get_thread_area should channel its
494 request through the regcache. That way remote targets could
495 provide the value using the remote protocol and not this direct
498 Is this function needed? I'm guessing that the `base' is the
499 address of a descriptor that libthread_db uses to find the
500 thread local address base that GDB needs. Perhaps that
501 descriptor is defined by the ABI. Anyway, given that
502 libthread_db calls this function without prompting (gdb
503 requesting tls base) I guess it needs info in there anyway. */
504 unsigned int desc
[4];
506 /* This code assumes that "int" is 32 bits and that
507 GET_THREAD_AREA returns no more than 4 int values. */
508 gdb_assert (sizeof (int) == 4);
510 #ifndef PTRACE_GET_THREAD_AREA
511 #define PTRACE_GET_THREAD_AREA 25
514 if (ptrace (PTRACE_GET_THREAD_AREA
, pid
, addr
, &desc
) < 0)
517 *base_addr
= desc
[1];
522 /* Create an x86 GNU/Linux target. */
525 x86_linux_create_target (void)
527 /* Fill in the generic GNU/Linux methods. */
528 struct target_ops
*t
= linux_target ();
530 /* Initialize the debug register function vectors. */
531 x86_use_watchpoints (t
);
532 x86_dr_low
.set_control
= x86_linux_dr_set_control
;
533 x86_dr_low
.set_addr
= x86_linux_dr_set_addr
;
534 x86_dr_low
.get_addr
= x86_linux_dr_get_addr
;
535 x86_dr_low
.get_status
= x86_linux_dr_get_status
;
536 x86_dr_low
.get_control
= x86_linux_dr_get_control
;
537 x86_set_debug_register_length (sizeof (void *));
539 /* Override the GNU/Linux inferior startup hook. */
540 super_post_startup_inferior
= t
->to_post_startup_inferior
;
541 t
->to_post_startup_inferior
= x86_linux_child_post_startup_inferior
;
543 /* Add the description reader. */
544 t
->to_read_description
= x86_linux_read_description
;
546 /* Add btrace methods. */
547 t
->to_supports_btrace
= linux_supports_btrace
;
548 t
->to_enable_btrace
= x86_linux_enable_btrace
;
549 t
->to_disable_btrace
= x86_linux_disable_btrace
;
550 t
->to_teardown_btrace
= x86_linux_teardown_btrace
;
551 t
->to_read_btrace
= x86_linux_read_btrace
;
556 /* Add an x86 GNU/Linux target. */
559 x86_linux_add_target (struct target_ops
*t
)
561 linux_nat_add_target (t
);
562 linux_nat_set_new_thread (t
, x86_linux_new_thread
);
563 linux_nat_set_new_fork (t
, x86_linux_new_fork
);
564 linux_nat_set_forget_process (t
, x86_forget_process
);
565 linux_nat_set_prepare_to_resume (t
, x86_linux_prepare_to_resume
);