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"
43 #include "nat/x86-linux-dregs.h"
44 #include "nat/linux-ptrace.h"
46 /* Per-thread arch-specific data we want to keep. */
50 /* Non-zero if our copy differs from what's recorded in the thread. */
51 int debug_registers_changed;
54 /* Does the current host support PTRACE_GETREGSET? */
55 int have_ptrace_getregset = -1;
58 /* linux_nat_new_fork hook. */
61 x86_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
64 struct x86_debug_reg_state *parent_state;
65 struct x86_debug_reg_state *child_state;
67 /* NULL means no watchpoint has ever been set in the parent. In
68 that case, there's nothing to do. */
69 if (parent->arch_private == NULL)
72 /* Linux kernel before 2.6.33 commit
73 72f674d203cd230426437cdcf7dd6f681dad8b0d
74 will inherit hardware debug registers from parent
75 on fork/vfork/clone. Newer Linux kernels create such tasks with
76 zeroed debug registers.
78 GDB core assumes the child inherits the watchpoints/hw
79 breakpoints of the parent, and will remove them all from the
80 forked off process. Copy the debug registers mirrors into the
81 new process so that all breakpoints and watchpoints can be
82 removed together. The debug registers mirror will become zeroed
83 in the end before detaching the forked off process, thus making
84 this compatible with older Linux kernels too. */
86 parent_pid = ptid_get_pid (parent->ptid);
87 parent_state = x86_debug_reg_state (parent_pid);
88 child_state = x86_debug_reg_state (child_pid);
89 *child_state = *parent_state;
93 static void (*super_post_startup_inferior) (struct target_ops *self,
97 x86_linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
100 super_post_startup_inferior (self, ptid);
104 /* Value of CS segment register:
106 32bit process: 0x23 */
107 #define AMD64_LINUX_USER64_CS 0x33
109 /* Value of DS segment register:
112 #define AMD64_LINUX_X32_DS 0x2b
115 /* Get Linux/x86 target description from running target. */
117 static const struct target_desc *
118 x86_linux_read_description (struct target_ops *ops)
125 static uint64_t xcr0;
126 uint64_t xcr0_features_bits;
128 /* GNU/Linux LWP ID's are process ID's. */
129 tid = ptid_get_lwp (inferior_ptid);
131 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
138 /* Get CS register. */
140 cs = ptrace (PTRACE_PEEKUSER, tid,
141 offsetof (struct user_regs_struct, cs), 0);
143 perror_with_name (_("Couldn't get CS register"));
145 is_64bit = cs == AMD64_LINUX_USER64_CS;
147 /* Get DS register. */
149 ds = ptrace (PTRACE_PEEKUSER, tid,
150 offsetof (struct user_regs_struct, ds), 0);
152 perror_with_name (_("Couldn't get DS register"));
154 is_x32 = ds == AMD64_LINUX_X32_DS;
156 if (sizeof (void *) == 4 && is_64bit && !is_x32)
157 error (_("Can't debug 64-bit process with 32-bit GDB"));
159 #elif HAVE_PTRACE_GETFPXREGS
160 if (have_ptrace_getfpxregs == -1)
162 elf_fpxregset_t fpxregs;
164 if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
166 have_ptrace_getfpxregs = 0;
167 have_ptrace_getregset = 0;
168 return tdesc_i386_mmx_linux;
173 if (have_ptrace_getregset == -1)
175 uint64_t xstateregs[(X86_XSTATE_SSE_SIZE / sizeof (uint64_t))];
178 iov.iov_base = xstateregs;
179 iov.iov_len = sizeof (xstateregs);
181 /* Check if PTRACE_GETREGSET works. */
182 if (ptrace (PTRACE_GETREGSET, tid,
183 (unsigned int) NT_X86_XSTATE, &iov) < 0)
184 have_ptrace_getregset = 0;
187 have_ptrace_getregset = 1;
189 /* Get XCR0 from XSAVE extended state. */
190 xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
191 / sizeof (uint64_t))];
195 /* Check the native XCR0 only if PTRACE_GETREGSET is available. If
196 PTRACE_GETREGSET is not available then set xcr0_features_bits to
197 zero so that the "no-features" descriptions are returned by the
199 if (have_ptrace_getregset)
200 xcr0_features_bits = xcr0 & X86_XSTATE_ALL_MASK;
202 xcr0_features_bits = 0;
207 switch (xcr0_features_bits)
209 case X86_XSTATE_MPX_AVX512_MASK:
210 case X86_XSTATE_AVX512_MASK:
212 return tdesc_x32_avx512_linux;
214 return tdesc_amd64_avx512_linux;
215 case X86_XSTATE_MPX_MASK:
217 return tdesc_x32_avx_linux; /* No MPX on x32 using AVX. */
219 return tdesc_amd64_mpx_linux;
220 case X86_XSTATE_AVX_MASK:
222 return tdesc_x32_avx_linux;
224 return tdesc_amd64_avx_linux;
227 return tdesc_x32_linux;
229 return tdesc_amd64_linux;
235 switch (xcr0_features_bits)
237 case X86_XSTATE_MPX_AVX512_MASK:
238 case X86_XSTATE_AVX512_MASK:
239 return tdesc_i386_avx512_linux;
240 case X86_XSTATE_MPX_MASK:
241 return tdesc_i386_mpx_linux;
242 case X86_XSTATE_AVX_MASK:
243 return tdesc_i386_avx_linux;
245 return tdesc_i386_linux;
249 gdb_assert_not_reached ("failed to return tdesc");
253 /* Enable branch tracing. */
255 static struct btrace_target_info *
256 x86_linux_enable_btrace (struct target_ops *self, ptid_t ptid,
257 const struct btrace_config *conf)
259 struct btrace_target_info *tinfo;
260 struct gdbarch *gdbarch;
263 tinfo = linux_enable_btrace (ptid, conf);
266 error (_("Could not enable branch tracing for %s: %s."),
267 target_pid_to_str (ptid), safe_strerror (errno));
269 /* Fill in the size of a pointer in bits. */
270 if (tinfo->ptr_bits == 0)
272 gdbarch = target_thread_architecture (ptid);
273 tinfo->ptr_bits = gdbarch_ptr_bit (gdbarch);
278 /* Disable branch tracing. */
281 x86_linux_disable_btrace (struct target_ops *self,
282 struct btrace_target_info *tinfo)
284 enum btrace_error errcode = linux_disable_btrace (tinfo);
286 if (errcode != BTRACE_ERR_NONE)
287 error (_("Could not disable branch tracing."));
290 /* Teardown branch tracing. */
293 x86_linux_teardown_btrace (struct target_ops *self,
294 struct btrace_target_info *tinfo)
297 linux_disable_btrace (tinfo);
300 static enum btrace_error
301 x86_linux_read_btrace (struct target_ops *self,
302 struct btrace_data *data,
303 struct btrace_target_info *btinfo,
304 enum btrace_read_type type)
306 return linux_read_btrace (data, btinfo, type);
309 /* See to_btrace_conf in target.h. */
311 static const struct btrace_config *
312 x86_linux_btrace_conf (struct target_ops *self,
313 const struct btrace_target_info *btinfo)
315 return linux_btrace_conf (btinfo);
320 /* Helper for ps_get_thread_area. Sets BASE_ADDR to a pointer to
321 the thread local storage (or its descriptor) and returns PS_OK
322 on success. Returns PS_ERR on failure. */
325 x86_linux_get_thread_area (pid_t pid, void *addr, unsigned int *base_addr)
327 /* NOTE: cagney/2003-08-26: The definition of this buffer is found
328 in the kernel header <asm-i386/ldt.h>. It, after padding, is 4 x
329 4 byte integers in size: `entry_number', `base_addr', `limit',
330 and a bunch of status bits.
332 The values returned by this ptrace call should be part of the
333 regcache buffer, and ps_get_thread_area should channel its
334 request through the regcache. That way remote targets could
335 provide the value using the remote protocol and not this direct
338 Is this function needed? I'm guessing that the `base' is the
339 address of a descriptor that libthread_db uses to find the
340 thread local address base that GDB needs. Perhaps that
341 descriptor is defined by the ABI. Anyway, given that
342 libthread_db calls this function without prompting (gdb
343 requesting tls base) I guess it needs info in there anyway. */
344 unsigned int desc[4];
346 /* This code assumes that "int" is 32 bits and that
347 GET_THREAD_AREA returns no more than 4 int values. */
348 gdb_assert (sizeof (int) == 4);
350 #ifndef PTRACE_GET_THREAD_AREA
351 #define PTRACE_GET_THREAD_AREA 25
354 if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, &desc) < 0)
357 *base_addr = desc[1];
362 /* Create an x86 GNU/Linux target. */
365 x86_linux_create_target (void)
367 /* Fill in the generic GNU/Linux methods. */
368 struct target_ops *t = linux_target ();
370 /* Initialize the debug register function vectors. */
371 x86_use_watchpoints (t);
372 x86_dr_low.set_control = x86_linux_dr_set_control;
373 x86_dr_low.set_addr = x86_linux_dr_set_addr;
374 x86_dr_low.get_addr = x86_linux_dr_get_addr;
375 x86_dr_low.get_status = x86_linux_dr_get_status;
376 x86_dr_low.get_control = x86_linux_dr_get_control;
377 x86_set_debug_register_length (sizeof (void *));
379 /* Override the GNU/Linux inferior startup hook. */
380 super_post_startup_inferior = t->to_post_startup_inferior;
381 t->to_post_startup_inferior = x86_linux_child_post_startup_inferior;
383 /* Add the description reader. */
384 t->to_read_description = x86_linux_read_description;
386 /* Add btrace methods. */
387 t->to_supports_btrace = linux_supports_btrace;
388 t->to_enable_btrace = x86_linux_enable_btrace;
389 t->to_disable_btrace = x86_linux_disable_btrace;
390 t->to_teardown_btrace = x86_linux_teardown_btrace;
391 t->to_read_btrace = x86_linux_read_btrace;
392 t->to_btrace_conf = x86_linux_btrace_conf;
397 /* Add an x86 GNU/Linux target. */
400 x86_linux_add_target (struct target_ops *t)
402 linux_nat_add_target (t);
403 linux_nat_set_new_thread (t, x86_linux_new_thread);
404 linux_nat_set_new_fork (t, x86_linux_new_fork);
405 linux_nat_set_forget_process (t, x86_forget_process);
406 linux_nat_set_prepare_to_resume (t, x86_linux_prepare_to_resume);