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"
42 /* Per-thread arch-specific data we want to keep. */
46 /* Non-zero if our copy differs from what's recorded in the thread. */
47 int debug_registers_changed;
50 /* Does the current host support PTRACE_GETREGSET? */
51 int have_ptrace_getregset = -1;
54 /* Support for debug registers. */
56 /* Get debug register REGNUM value from only the one LWP of PTID. */
59 x86_linux_dr_get (ptid_t ptid, int regnum)
64 gdb_assert (ptid_lwp_p (ptid));
65 tid = ptid_get_lwp (ptid);
68 value = ptrace (PTRACE_PEEKUSER, tid,
69 offsetof (struct user, u_debugreg[regnum]), 0);
71 perror_with_name (_("Couldn't read debug register"));
76 /* Set debug register REGNUM to VALUE in only the one LWP of PTID. */
79 x86_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
83 gdb_assert (ptid_lwp_p (ptid));
84 tid = ptid_get_lwp (ptid);
87 ptrace (PTRACE_POKEUSER, tid,
88 offsetof (struct user, u_debugreg[regnum]), value);
90 perror_with_name (_("Couldn't write debug register"));
93 /* Return the inferior's debug register REGNUM. */
96 x86_linux_dr_get_addr (int regnum)
98 /* DR6 and DR7 are retrieved with some other way. */
99 gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
101 return x86_linux_dr_get (inferior_ptid, regnum);
104 /* Return the inferior's DR7 debug control register. */
107 x86_linux_dr_get_control (void)
109 return x86_linux_dr_get (inferior_ptid, DR_CONTROL);
112 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID. */
115 x86_linux_dr_get_status (void)
117 return x86_linux_dr_get (inferior_ptid, DR_STATUS);
120 /* Callback for iterate_over_lwps. Update the debug registers of
124 update_debug_registers_callback (struct lwp_info *lwp, void *arg)
126 if (lwp->arch_private == NULL)
127 lwp->arch_private = XCNEW (struct arch_lwp_info);
129 /* The actual update is done later just before resuming the lwp, we
130 just mark that the registers need updating. */
131 lwp->arch_private->debug_registers_changed = 1;
133 /* If the lwp isn't stopped, force it to momentarily pause, so we
134 can update its debug registers. */
136 linux_stop_lwp (lwp);
138 /* Continue the iteration. */
142 /* Set DR_CONTROL to CONTROL in all LWPs of the current inferior. */
145 x86_linux_dr_set_control (unsigned long control)
147 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
149 iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
152 /* Set address REGNUM (zero based) to ADDR in all LWPs of the current
156 x86_linux_dr_set_addr (int regnum, CORE_ADDR addr)
158 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
160 gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
162 iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
165 /* Called when resuming a thread.
166 If the debug regs have changed, update the thread's copies. */
169 x86_linux_prepare_to_resume (struct lwp_info *lwp)
171 int clear_status = 0;
173 /* NULL means this is the main thread still going through the shell,
174 or, no watchpoint has been set yet. In that case, there's
176 if (lwp->arch_private == NULL)
179 if (lwp->arch_private->debug_registers_changed)
181 struct x86_debug_reg_state *state
182 = x86_debug_reg_state (ptid_get_pid (lwp->ptid));
185 /* On Linux kernel before 2.6.33 commit
186 72f674d203cd230426437cdcf7dd6f681dad8b0d
187 if you enable a breakpoint by the DR_CONTROL bits you need to have
188 already written the corresponding DR_FIRSTADDR...DR_LASTADDR registers.
190 Ensure DR_CONTROL gets written as the very last register here. */
192 /* Clear DR_CONTROL first. In some cases, setting DR0-3 to a
193 value that doesn't match what is enabled in DR_CONTROL
194 results in EINVAL. */
195 x86_linux_dr_set (lwp->ptid, DR_CONTROL, 0);
197 ALL_DEBUG_ADDRESS_REGISTERS (i)
198 if (state->dr_ref_count[i] > 0)
200 x86_linux_dr_set (lwp->ptid, i, state->dr_mirror[i]);
202 /* If we're setting a watchpoint, any change the inferior
203 had done itself to the debug registers needs to be
204 discarded, otherwise, x86_stopped_data_address can get
209 /* If DR_CONTROL is supposed to be zero, we've already set it
211 if (state->dr_control_mirror != 0)
212 x86_linux_dr_set (lwp->ptid, DR_CONTROL, state->dr_control_mirror);
214 lwp->arch_private->debug_registers_changed = 0;
217 if (clear_status || lwp->stop_reason == LWP_STOPPED_BY_WATCHPOINT)
218 x86_linux_dr_set (lwp->ptid, DR_STATUS, 0);
222 x86_linux_new_thread (struct lwp_info *lp)
224 struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
226 info->debug_registers_changed = 1;
228 lp->arch_private = info;
232 /* linux_nat_new_fork hook. */
235 x86_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
238 struct x86_debug_reg_state *parent_state;
239 struct x86_debug_reg_state *child_state;
241 /* NULL means no watchpoint has ever been set in the parent. In
242 that case, there's nothing to do. */
243 if (parent->arch_private == NULL)
246 /* Linux kernel before 2.6.33 commit
247 72f674d203cd230426437cdcf7dd6f681dad8b0d
248 will inherit hardware debug registers from parent
249 on fork/vfork/clone. Newer Linux kernels create such tasks with
250 zeroed debug registers.
252 GDB core assumes the child inherits the watchpoints/hw
253 breakpoints of the parent, and will remove them all from the
254 forked off process. Copy the debug registers mirrors into the
255 new process so that all breakpoints and watchpoints can be
256 removed together. The debug registers mirror will become zeroed
257 in the end before detaching the forked off process, thus making
258 this compatible with older Linux kernels too. */
260 parent_pid = ptid_get_pid (parent->ptid);
261 parent_state = x86_debug_reg_state (parent_pid);
262 child_state = x86_debug_reg_state (child_pid);
263 *child_state = *parent_state;
267 static void (*super_post_startup_inferior) (struct target_ops *self,
271 x86_linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
273 x86_cleanup_dregs ();
274 super_post_startup_inferior (self, ptid);
278 /* Value of CS segment register:
280 32bit process: 0x23 */
281 #define AMD64_LINUX_USER64_CS 0x33
283 /* Value of DS segment register:
286 #define AMD64_LINUX_X32_DS 0x2b
289 /* Get Linux/x86 target description from running target. */
291 static const struct target_desc *
292 x86_linux_read_description (struct target_ops *ops)
299 static uint64_t xcr0;
300 uint64_t xcr0_features_bits;
302 /* GNU/Linux LWP ID's are process ID's. */
303 tid = ptid_get_lwp (inferior_ptid);
305 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
312 /* Get CS register. */
314 cs = ptrace (PTRACE_PEEKUSER, tid,
315 offsetof (struct user_regs_struct, cs), 0);
317 perror_with_name (_("Couldn't get CS register"));
319 is_64bit = cs == AMD64_LINUX_USER64_CS;
321 /* Get DS register. */
323 ds = ptrace (PTRACE_PEEKUSER, tid,
324 offsetof (struct user_regs_struct, ds), 0);
326 perror_with_name (_("Couldn't get DS register"));
328 is_x32 = ds == AMD64_LINUX_X32_DS;
330 if (sizeof (void *) == 4 && is_64bit && !is_x32)
331 error (_("Can't debug 64-bit process with 32-bit GDB"));
333 #elif HAVE_PTRACE_GETFPXREGS
334 if (have_ptrace_getfpxregs == -1)
336 elf_fpxregset_t fpxregs;
338 if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
340 have_ptrace_getfpxregs = 0;
341 have_ptrace_getregset = 0;
342 return tdesc_i386_mmx_linux;
347 if (have_ptrace_getregset == -1)
349 uint64_t xstateregs[(X86_XSTATE_SSE_SIZE / sizeof (uint64_t))];
352 iov.iov_base = xstateregs;
353 iov.iov_len = sizeof (xstateregs);
355 /* Check if PTRACE_GETREGSET works. */
356 if (ptrace (PTRACE_GETREGSET, tid,
357 (unsigned int) NT_X86_XSTATE, &iov) < 0)
358 have_ptrace_getregset = 0;
361 have_ptrace_getregset = 1;
363 /* Get XCR0 from XSAVE extended state. */
364 xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
365 / sizeof (uint64_t))];
369 /* Check the native XCR0 only if PTRACE_GETREGSET is available. If
370 PTRACE_GETREGSET is not available then set xcr0_features_bits to
371 zero so that the "no-features" descriptions are returned by the
373 if (have_ptrace_getregset)
374 xcr0_features_bits = xcr0 & X86_XSTATE_ALL_MASK;
376 xcr0_features_bits = 0;
381 switch (xcr0_features_bits)
383 case X86_XSTATE_MPX_AVX512_MASK:
384 case X86_XSTATE_AVX512_MASK:
386 return tdesc_x32_avx512_linux;
388 return tdesc_amd64_avx512_linux;
389 case X86_XSTATE_MPX_MASK:
391 return tdesc_x32_avx_linux; /* No MPX on x32 using AVX. */
393 return tdesc_amd64_mpx_linux;
394 case X86_XSTATE_AVX_MASK:
396 return tdesc_x32_avx_linux;
398 return tdesc_amd64_avx_linux;
401 return tdesc_x32_linux;
403 return tdesc_amd64_linux;
409 switch (xcr0_features_bits)
411 case X86_XSTATE_MPX_AVX512_MASK:
412 case X86_XSTATE_AVX512_MASK:
413 return tdesc_i386_avx512_linux;
414 case X86_XSTATE_MPX_MASK:
415 return tdesc_i386_mpx_linux;
416 case X86_XSTATE_AVX_MASK:
417 return tdesc_i386_avx_linux;
419 return tdesc_i386_linux;
423 gdb_assert_not_reached ("failed to return tdesc");
427 /* Enable branch tracing. */
429 static struct btrace_target_info *
430 x86_linux_enable_btrace (struct target_ops *self, ptid_t ptid,
431 const struct btrace_config *conf)
433 struct btrace_target_info *tinfo;
434 struct gdbarch *gdbarch;
437 tinfo = linux_enable_btrace (ptid, conf);
440 error (_("Could not enable branch tracing for %s: %s."),
441 target_pid_to_str (ptid), safe_strerror (errno));
443 /* Fill in the size of a pointer in bits. */
444 gdbarch = target_thread_architecture (ptid);
445 tinfo->ptr_bits = gdbarch_ptr_bit (gdbarch);
450 /* Disable branch tracing. */
453 x86_linux_disable_btrace (struct target_ops *self,
454 struct btrace_target_info *tinfo)
456 enum btrace_error errcode = linux_disable_btrace (tinfo);
458 if (errcode != BTRACE_ERR_NONE)
459 error (_("Could not disable branch tracing."));
462 /* Teardown branch tracing. */
465 x86_linux_teardown_btrace (struct target_ops *self,
466 struct btrace_target_info *tinfo)
469 linux_disable_btrace (tinfo);
472 static enum btrace_error
473 x86_linux_read_btrace (struct target_ops *self,
474 struct btrace_data *data,
475 struct btrace_target_info *btinfo,
476 enum btrace_read_type type)
478 return linux_read_btrace (data, btinfo, type);
481 /* See to_btrace_conf in target.h. */
483 static const struct btrace_config *
484 x86_linux_btrace_conf (struct target_ops *self,
485 const struct btrace_target_info *btinfo)
487 return linux_btrace_conf (btinfo);
492 /* Helper for ps_get_thread_area. Sets BASE_ADDR to a pointer to
493 the thread local storage (or its descriptor) and returns PS_OK
494 on success. Returns PS_ERR on failure. */
497 x86_linux_get_thread_area (pid_t pid, void *addr, unsigned int *base_addr)
499 /* NOTE: cagney/2003-08-26: The definition of this buffer is found
500 in the kernel header <asm-i386/ldt.h>. It, after padding, is 4 x
501 4 byte integers in size: `entry_number', `base_addr', `limit',
502 and a bunch of status bits.
504 The values returned by this ptrace call should be part of the
505 regcache buffer, and ps_get_thread_area should channel its
506 request through the regcache. That way remote targets could
507 provide the value using the remote protocol and not this direct
510 Is this function needed? I'm guessing that the `base' is the
511 address of a descriptor that libthread_db uses to find the
512 thread local address base that GDB needs. Perhaps that
513 descriptor is defined by the ABI. Anyway, given that
514 libthread_db calls this function without prompting (gdb
515 requesting tls base) I guess it needs info in there anyway. */
516 unsigned int desc[4];
518 /* This code assumes that "int" is 32 bits and that
519 GET_THREAD_AREA returns no more than 4 int values. */
520 gdb_assert (sizeof (int) == 4);
522 #ifndef PTRACE_GET_THREAD_AREA
523 #define PTRACE_GET_THREAD_AREA 25
526 if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, &desc) < 0)
529 *base_addr = desc[1];
534 /* Create an x86 GNU/Linux target. */
537 x86_linux_create_target (void)
539 /* Fill in the generic GNU/Linux methods. */
540 struct target_ops *t = linux_target ();
542 /* Initialize the debug register function vectors. */
543 x86_use_watchpoints (t);
544 x86_dr_low.set_control = x86_linux_dr_set_control;
545 x86_dr_low.set_addr = x86_linux_dr_set_addr;
546 x86_dr_low.get_addr = x86_linux_dr_get_addr;
547 x86_dr_low.get_status = x86_linux_dr_get_status;
548 x86_dr_low.get_control = x86_linux_dr_get_control;
549 x86_set_debug_register_length (sizeof (void *));
551 /* Override the GNU/Linux inferior startup hook. */
552 super_post_startup_inferior = t->to_post_startup_inferior;
553 t->to_post_startup_inferior = x86_linux_child_post_startup_inferior;
555 /* Add the description reader. */
556 t->to_read_description = x86_linux_read_description;
558 /* Add btrace methods. */
559 t->to_supports_btrace = linux_supports_btrace;
560 t->to_enable_btrace = x86_linux_enable_btrace;
561 t->to_disable_btrace = x86_linux_disable_btrace;
562 t->to_teardown_btrace = x86_linux_teardown_btrace;
563 t->to_read_btrace = x86_linux_read_btrace;
564 t->to_btrace_conf = x86_linux_btrace_conf;
569 /* Add an x86 GNU/Linux target. */
572 x86_linux_add_target (struct target_ops *t)
574 linux_nat_add_target (t);
575 linux_nat_set_new_thread (t, x86_linux_new_thread);
576 linux_nat_set_new_fork (t, x86_linux_new_fork);
577 linux_nat_set_forget_process (t, x86_forget_process);
578 linux_nat_set_prepare_to_resume (t, x86_linux_prepare_to_resume);