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"
42 #include "nat/x86-linux.h"
44 /* Per-thread arch-specific data we want to keep. */
48 /* Non-zero if our copy differs from what's recorded in the thread. */
49 int debug_registers_changed;
52 /* Does the current host support PTRACE_GETREGSET? */
53 int have_ptrace_getregset = -1;
56 /* Return the offset of REGNUM in the u_debugreg field of struct
60 u_debugreg_offset (int regnum)
62 return (offsetof (struct user, u_debugreg)
63 + sizeof (((struct user *) 0)->u_debugreg[0]) * regnum);
66 /* Support for debug registers. */
68 /* Get debug register REGNUM value from the LWP specified by PTID. */
71 x86_linux_dr_get (ptid_t ptid, int regnum)
76 gdb_assert (ptid_lwp_p (ptid));
77 tid = ptid_get_lwp (ptid);
80 value = ptrace (PTRACE_PEEKUSER, tid, u_debugreg_offset (regnum), 0);
83 perror_with_name (_("Couldn't read debug register"));
88 /* Set debug register REGNUM to VALUE in the LWP specified by PTID. */
91 x86_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
95 gdb_assert (ptid_lwp_p (ptid));
96 tid = ptid_get_lwp (ptid);
99 ptrace (PTRACE_POKEUSER, tid, u_debugreg_offset (regnum), value);
101 perror_with_name (_("Couldn't write debug register"));
104 /* Return the address stored in the current inferior's debug register
108 x86_linux_dr_get_addr (int regnum)
110 gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
112 return x86_linux_dr_get (current_lwp_ptid (), regnum);
115 /* Return the value stored in the current inferior's debug control
119 x86_linux_dr_get_control (void)
121 return x86_linux_dr_get (current_lwp_ptid (), DR_CONTROL);
124 /* Return the value stored in the current inferior's debug status
128 x86_linux_dr_get_status (void)
130 return x86_linux_dr_get (current_lwp_ptid (), DR_STATUS);
133 /* Callback for iterate_over_lwps. Mark that our local mirror of
134 LWP's debug registers has been changed, and cause LWP to stop if
135 it isn't already. Values are written from our local mirror to
136 the actual debug registers immediately prior to LWP resuming. */
139 update_debug_registers_callback (struct lwp_info *lwp, void *arg)
141 lwp_set_debug_registers_changed (lwp, 1);
143 if (!lwp_is_stopped (lwp))
144 linux_stop_lwp (lwp);
146 /* Continue the iteration. */
150 /* Store CONTROL in the debug control registers of all LWPs of the
154 x86_linux_dr_set_control (unsigned long control)
156 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
158 iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
161 /* Store ADDR in debug register REGNUM of all LWPs of the current
165 x86_linux_dr_set_addr (int regnum, CORE_ADDR addr)
167 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (current_lwp_ptid ()));
169 gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
171 iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
174 /* Called prior to resuming a thread. Updates the thread's debug
175 registers if the values in our local mirror have been changed. */
178 x86_linux_prepare_to_resume (struct lwp_info *lwp)
180 ptid_t ptid = ptid_of_lwp (lwp);
181 int clear_status = 0;
183 if (lwp_debug_registers_changed (lwp))
185 struct x86_debug_reg_state *state
186 = x86_debug_reg_state (ptid_get_pid (ptid));
189 /* Prior to Linux kernel 2.6.33 commit
190 72f674d203cd230426437cdcf7dd6f681dad8b0d, setting DR0-3 to
191 a value that did not match what was enabled in DR_CONTROL
192 resulted in EINVAL. To avoid this we zero DR_CONTROL before
193 writing address registers, only writing DR_CONTROL's actual
194 value once all the addresses are in place. */
195 x86_linux_dr_set (ptid, DR_CONTROL, 0);
197 ALL_DEBUG_ADDRESS_REGISTERS (i)
198 if (state->dr_ref_count[i] > 0)
200 x86_linux_dr_set (ptid, i, state->dr_mirror[i]);
202 /* If we're setting a watchpoint, any change the inferior
203 has made to its debug registers needs to be discarded
204 to avoid x86_stopped_data_address getting confused. */
208 /* If DR_CONTROL is supposed to be zero then it's already set. */
209 if (state->dr_control_mirror != 0)
210 x86_linux_dr_set (ptid, DR_CONTROL, state->dr_control_mirror);
212 lwp_set_debug_registers_changed (lwp, 0);
216 || lwp_stop_reason (lwp) == TARGET_STOPPED_BY_WATCHPOINT)
217 x86_linux_dr_set (ptid, DR_STATUS, 0);
220 /* Called when a new thread is detected. */
223 x86_linux_new_thread (struct lwp_info *lwp)
225 lwp_set_debug_registers_changed (lwp, 1);
229 /* linux_nat_new_fork hook. */
232 x86_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
235 struct x86_debug_reg_state *parent_state;
236 struct x86_debug_reg_state *child_state;
238 /* NULL means no watchpoint has ever been set in the parent. In
239 that case, there's nothing to do. */
240 if (parent->arch_private == NULL)
243 /* Linux kernel before 2.6.33 commit
244 72f674d203cd230426437cdcf7dd6f681dad8b0d
245 will inherit hardware debug registers from parent
246 on fork/vfork/clone. Newer Linux kernels create such tasks with
247 zeroed debug registers.
249 GDB core assumes the child inherits the watchpoints/hw
250 breakpoints of the parent, and will remove them all from the
251 forked off process. Copy the debug registers mirrors into the
252 new process so that all breakpoints and watchpoints can be
253 removed together. The debug registers mirror will become zeroed
254 in the end before detaching the forked off process, thus making
255 this compatible with older Linux kernels too. */
257 parent_pid = ptid_get_pid (parent->ptid);
258 parent_state = x86_debug_reg_state (parent_pid);
259 child_state = x86_debug_reg_state (child_pid);
260 *child_state = *parent_state;
264 static void (*super_post_startup_inferior) (struct target_ops *self,
268 x86_linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
270 x86_cleanup_dregs ();
271 super_post_startup_inferior (self, ptid);
275 /* Value of CS segment register:
277 32bit process: 0x23 */
278 #define AMD64_LINUX_USER64_CS 0x33
280 /* Value of DS segment register:
283 #define AMD64_LINUX_X32_DS 0x2b
286 /* Get Linux/x86 target description from running target. */
288 static const struct target_desc *
289 x86_linux_read_description (struct target_ops *ops)
296 static uint64_t xcr0;
297 uint64_t xcr0_features_bits;
299 /* GNU/Linux LWP ID's are process ID's. */
300 tid = ptid_get_lwp (inferior_ptid);
302 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
309 /* Get CS register. */
311 cs = ptrace (PTRACE_PEEKUSER, tid,
312 offsetof (struct user_regs_struct, cs), 0);
314 perror_with_name (_("Couldn't get CS register"));
316 is_64bit = cs == AMD64_LINUX_USER64_CS;
318 /* Get DS register. */
320 ds = ptrace (PTRACE_PEEKUSER, tid,
321 offsetof (struct user_regs_struct, ds), 0);
323 perror_with_name (_("Couldn't get DS register"));
325 is_x32 = ds == AMD64_LINUX_X32_DS;
327 if (sizeof (void *) == 4 && is_64bit && !is_x32)
328 error (_("Can't debug 64-bit process with 32-bit GDB"));
330 #elif HAVE_PTRACE_GETFPXREGS
331 if (have_ptrace_getfpxregs == -1)
333 elf_fpxregset_t fpxregs;
335 if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
337 have_ptrace_getfpxregs = 0;
338 have_ptrace_getregset = 0;
339 return tdesc_i386_mmx_linux;
344 if (have_ptrace_getregset == -1)
346 uint64_t xstateregs[(X86_XSTATE_SSE_SIZE / sizeof (uint64_t))];
349 iov.iov_base = xstateregs;
350 iov.iov_len = sizeof (xstateregs);
352 /* Check if PTRACE_GETREGSET works. */
353 if (ptrace (PTRACE_GETREGSET, tid,
354 (unsigned int) NT_X86_XSTATE, &iov) < 0)
355 have_ptrace_getregset = 0;
358 have_ptrace_getregset = 1;
360 /* Get XCR0 from XSAVE extended state. */
361 xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
362 / sizeof (uint64_t))];
366 /* Check the native XCR0 only if PTRACE_GETREGSET is available. If
367 PTRACE_GETREGSET is not available then set xcr0_features_bits to
368 zero so that the "no-features" descriptions are returned by the
370 if (have_ptrace_getregset)
371 xcr0_features_bits = xcr0 & X86_XSTATE_ALL_MASK;
373 xcr0_features_bits = 0;
378 switch (xcr0_features_bits)
380 case X86_XSTATE_MPX_AVX512_MASK:
381 case X86_XSTATE_AVX512_MASK:
383 return tdesc_x32_avx512_linux;
385 return tdesc_amd64_avx512_linux;
386 case X86_XSTATE_MPX_MASK:
388 return tdesc_x32_avx_linux; /* No MPX on x32 using AVX. */
390 return tdesc_amd64_mpx_linux;
391 case X86_XSTATE_AVX_MASK:
393 return tdesc_x32_avx_linux;
395 return tdesc_amd64_avx_linux;
398 return tdesc_x32_linux;
400 return tdesc_amd64_linux;
406 switch (xcr0_features_bits)
408 case X86_XSTATE_MPX_AVX512_MASK:
409 case X86_XSTATE_AVX512_MASK:
410 return tdesc_i386_avx512_linux;
411 case X86_XSTATE_MPX_MASK:
412 return tdesc_i386_mpx_linux;
413 case X86_XSTATE_AVX_MASK:
414 return tdesc_i386_avx_linux;
416 return tdesc_i386_linux;
420 gdb_assert_not_reached ("failed to return tdesc");
424 /* Enable branch tracing. */
426 static struct btrace_target_info *
427 x86_linux_enable_btrace (struct target_ops *self, ptid_t ptid,
428 const struct btrace_config *conf)
430 struct btrace_target_info *tinfo;
431 struct gdbarch *gdbarch;
434 tinfo = linux_enable_btrace (ptid, conf);
437 error (_("Could not enable branch tracing for %s: %s."),
438 target_pid_to_str (ptid), safe_strerror (errno));
440 /* Fill in the size of a pointer in bits. */
441 if (tinfo->ptr_bits == 0)
443 gdbarch = target_thread_architecture (ptid);
444 tinfo->ptr_bits = gdbarch_ptr_bit (gdbarch);
449 /* Disable branch tracing. */
452 x86_linux_disable_btrace (struct target_ops *self,
453 struct btrace_target_info *tinfo)
455 enum btrace_error errcode = linux_disable_btrace (tinfo);
457 if (errcode != BTRACE_ERR_NONE)
458 error (_("Could not disable branch tracing."));
461 /* Teardown branch tracing. */
464 x86_linux_teardown_btrace (struct target_ops *self,
465 struct btrace_target_info *tinfo)
468 linux_disable_btrace (tinfo);
471 static enum btrace_error
472 x86_linux_read_btrace (struct target_ops *self,
473 struct btrace_data *data,
474 struct btrace_target_info *btinfo,
475 enum btrace_read_type type)
477 return linux_read_btrace (data, btinfo, type);
480 /* See to_btrace_conf in target.h. */
482 static const struct btrace_config *
483 x86_linux_btrace_conf (struct target_ops *self,
484 const struct btrace_target_info *btinfo)
486 return linux_btrace_conf (btinfo);
491 /* Helper for ps_get_thread_area. Sets BASE_ADDR to a pointer to
492 the thread local storage (or its descriptor) and returns PS_OK
493 on success. Returns PS_ERR on failure. */
496 x86_linux_get_thread_area (pid_t pid, void *addr, unsigned int *base_addr)
498 /* NOTE: cagney/2003-08-26: The definition of this buffer is found
499 in the kernel header <asm-i386/ldt.h>. It, after padding, is 4 x
500 4 byte integers in size: `entry_number', `base_addr', `limit',
501 and a bunch of status bits.
503 The values returned by this ptrace call should be part of the
504 regcache buffer, and ps_get_thread_area should channel its
505 request through the regcache. That way remote targets could
506 provide the value using the remote protocol and not this direct
509 Is this function needed? I'm guessing that the `base' is the
510 address of a descriptor that libthread_db uses to find the
511 thread local address base that GDB needs. Perhaps that
512 descriptor is defined by the ABI. Anyway, given that
513 libthread_db calls this function without prompting (gdb
514 requesting tls base) I guess it needs info in there anyway. */
515 unsigned int desc[4];
517 /* This code assumes that "int" is 32 bits and that
518 GET_THREAD_AREA returns no more than 4 int values. */
519 gdb_assert (sizeof (int) == 4);
521 #ifndef PTRACE_GET_THREAD_AREA
522 #define PTRACE_GET_THREAD_AREA 25
525 if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, &desc) < 0)
528 *base_addr = desc[1];
533 /* Create an x86 GNU/Linux target. */
536 x86_linux_create_target (void)
538 /* Fill in the generic GNU/Linux methods. */
539 struct target_ops *t = linux_target ();
541 /* Initialize the debug register function vectors. */
542 x86_use_watchpoints (t);
543 x86_dr_low.set_control = x86_linux_dr_set_control;
544 x86_dr_low.set_addr = x86_linux_dr_set_addr;
545 x86_dr_low.get_addr = x86_linux_dr_get_addr;
546 x86_dr_low.get_status = x86_linux_dr_get_status;
547 x86_dr_low.get_control = x86_linux_dr_get_control;
548 x86_set_debug_register_length (sizeof (void *));
550 /* Override the GNU/Linux inferior startup hook. */
551 super_post_startup_inferior = t->to_post_startup_inferior;
552 t->to_post_startup_inferior = x86_linux_child_post_startup_inferior;
554 /* Add the description reader. */
555 t->to_read_description = x86_linux_read_description;
557 /* Add btrace methods. */
558 t->to_supports_btrace = linux_supports_btrace;
559 t->to_enable_btrace = x86_linux_enable_btrace;
560 t->to_disable_btrace = x86_linux_disable_btrace;
561 t->to_teardown_btrace = x86_linux_teardown_btrace;
562 t->to_read_btrace = x86_linux_read_btrace;
563 t->to_btrace_conf = x86_linux_btrace_conf;
568 /* Add an x86 GNU/Linux target. */
571 x86_linux_add_target (struct target_ops *t)
573 linux_nat_add_target (t);
574 linux_nat_set_new_thread (t, x86_linux_new_thread);
575 linux_nat_set_new_fork (t, x86_linux_new_fork);
576 linux_nat_set_forget_process (t, x86_forget_process);
577 linux_nat_set_prepare_to_resume (t, x86_linux_prepare_to_resume);