1 /* Native-dependent code for GNU/Linux x86 (i386 and x86-64).
3 Copyright (C) 1999-2018 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 "nat/gdb_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 /* linux_nat_new_fork hook. */
49 x86_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
52 struct x86_debug_reg_state *parent_state;
53 struct x86_debug_reg_state *child_state;
55 /* NULL means no watchpoint has ever been set in the parent. In
56 that case, there's nothing to do. */
57 if (parent->arch_private == NULL)
60 /* Linux kernel before 2.6.33 commit
61 72f674d203cd230426437cdcf7dd6f681dad8b0d
62 will inherit hardware debug registers from parent
63 on fork/vfork/clone. Newer Linux kernels create such tasks with
64 zeroed debug registers.
66 GDB core assumes the child inherits the watchpoints/hw
67 breakpoints of the parent, and will remove them all from the
68 forked off process. Copy the debug registers mirrors into the
69 new process so that all breakpoints and watchpoints can be
70 removed together. The debug registers mirror will become zeroed
71 in the end before detaching the forked off process, thus making
72 this compatible with older Linux kernels too. */
74 parent_pid = ptid_get_pid (parent->ptid);
75 parent_state = x86_debug_reg_state (parent_pid);
76 child_state = x86_debug_reg_state (child_pid);
77 *child_state = *parent_state;
81 static void (*super_post_startup_inferior) (struct target_ops *self,
85 x86_linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
88 super_post_startup_inferior (self, ptid);
92 /* Value of CS segment register:
94 32bit process: 0x23 */
95 #define AMD64_LINUX_USER64_CS 0x33
97 /* Value of DS segment register:
100 #define AMD64_LINUX_X32_DS 0x2b
103 /* Get Linux/x86 target description from running target. */
105 static const struct target_desc *
106 x86_linux_read_description (struct target_ops *ops)
113 static uint64_t xcr0;
114 uint64_t xcr0_features_bits;
116 /* GNU/Linux LWP ID's are process ID's. */
117 tid = ptid_get_lwp (inferior_ptid);
119 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
126 /* Get CS register. */
128 cs = ptrace (PTRACE_PEEKUSER, tid,
129 offsetof (struct user_regs_struct, cs), 0);
131 perror_with_name (_("Couldn't get CS register"));
133 is_64bit = cs == AMD64_LINUX_USER64_CS;
135 /* Get DS register. */
137 ds = ptrace (PTRACE_PEEKUSER, tid,
138 offsetof (struct user_regs_struct, ds), 0);
140 perror_with_name (_("Couldn't get DS register"));
142 is_x32 = ds == AMD64_LINUX_X32_DS;
144 if (sizeof (void *) == 4 && is_64bit && !is_x32)
145 error (_("Can't debug 64-bit process with 32-bit GDB"));
147 #elif HAVE_PTRACE_GETFPXREGS
148 if (have_ptrace_getfpxregs == -1)
150 elf_fpxregset_t fpxregs;
152 if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
154 have_ptrace_getfpxregs = 0;
155 have_ptrace_getregset = TRIBOOL_FALSE;
156 return i386_linux_read_description (X86_XSTATE_X87_MASK);
161 if (have_ptrace_getregset == TRIBOOL_UNKNOWN)
163 uint64_t xstateregs[(X86_XSTATE_SSE_SIZE / sizeof (uint64_t))];
166 iov.iov_base = xstateregs;
167 iov.iov_len = sizeof (xstateregs);
169 /* Check if PTRACE_GETREGSET works. */
170 if (ptrace (PTRACE_GETREGSET, tid,
171 (unsigned int) NT_X86_XSTATE, &iov) < 0)
172 have_ptrace_getregset = TRIBOOL_FALSE;
175 have_ptrace_getregset = TRIBOOL_TRUE;
177 /* Get XCR0 from XSAVE extended state. */
178 xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
179 / sizeof (uint64_t))];
183 /* Check the native XCR0 only if PTRACE_GETREGSET is available. If
184 PTRACE_GETREGSET is not available then set xcr0_features_bits to
185 zero so that the "no-features" descriptions are returned by the
187 if (have_ptrace_getregset == TRIBOOL_TRUE)
188 xcr0_features_bits = xcr0 & X86_XSTATE_ALL_MASK;
190 xcr0_features_bits = 0;
195 return amd64_linux_read_description (xcr0_features_bits, is_x32);
200 const struct target_desc * tdesc
201 = i386_linux_read_description (xcr0_features_bits);
204 tdesc = i386_linux_read_description (X86_XSTATE_SSE_MASK);
209 gdb_assert_not_reached ("failed to return tdesc");
213 /* Enable branch tracing. */
215 static struct btrace_target_info *
216 x86_linux_enable_btrace (struct target_ops *self, ptid_t ptid,
217 const struct btrace_config *conf)
219 struct btrace_target_info *tinfo = nullptr;
222 tinfo = linux_enable_btrace (ptid, conf);
224 CATCH (exception, RETURN_MASK_ERROR)
226 error (_("Could not enable branch tracing for %s: %s"),
227 target_pid_to_str (ptid), exception.message);
234 /* Disable branch tracing. */
237 x86_linux_disable_btrace (struct target_ops *self,
238 struct btrace_target_info *tinfo)
240 enum btrace_error errcode = linux_disable_btrace (tinfo);
242 if (errcode != BTRACE_ERR_NONE)
243 error (_("Could not disable branch tracing."));
246 /* Teardown branch tracing. */
249 x86_linux_teardown_btrace (struct target_ops *self,
250 struct btrace_target_info *tinfo)
253 linux_disable_btrace (tinfo);
256 static enum btrace_error
257 x86_linux_read_btrace (struct target_ops *self,
258 struct btrace_data *data,
259 struct btrace_target_info *btinfo,
260 enum btrace_read_type type)
262 return linux_read_btrace (data, btinfo, type);
265 /* See to_btrace_conf in target.h. */
267 static const struct btrace_config *
268 x86_linux_btrace_conf (struct target_ops *self,
269 const struct btrace_target_info *btinfo)
271 return linux_btrace_conf (btinfo);
276 /* Helper for ps_get_thread_area. Sets BASE_ADDR to a pointer to
277 the thread local storage (or its descriptor) and returns PS_OK
278 on success. Returns PS_ERR on failure. */
281 x86_linux_get_thread_area (pid_t pid, void *addr, unsigned int *base_addr)
283 /* NOTE: cagney/2003-08-26: The definition of this buffer is found
284 in the kernel header <asm-i386/ldt.h>. It, after padding, is 4 x
285 4 byte integers in size: `entry_number', `base_addr', `limit',
286 and a bunch of status bits.
288 The values returned by this ptrace call should be part of the
289 regcache buffer, and ps_get_thread_area should channel its
290 request through the regcache. That way remote targets could
291 provide the value using the remote protocol and not this direct
294 Is this function needed? I'm guessing that the `base' is the
295 address of a descriptor that libthread_db uses to find the
296 thread local address base that GDB needs. Perhaps that
297 descriptor is defined by the ABI. Anyway, given that
298 libthread_db calls this function without prompting (gdb
299 requesting tls base) I guess it needs info in there anyway. */
300 unsigned int desc[4];
302 /* This code assumes that "int" is 32 bits and that
303 GET_THREAD_AREA returns no more than 4 int values. */
304 gdb_assert (sizeof (int) == 4);
306 #ifndef PTRACE_GET_THREAD_AREA
307 #define PTRACE_GET_THREAD_AREA 25
310 if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, &desc) < 0)
313 *base_addr = desc[1];
318 /* Create an x86 GNU/Linux target. */
321 x86_linux_create_target (void)
323 /* Fill in the generic GNU/Linux methods. */
324 struct target_ops *t = linux_target ();
326 /* Initialize the debug register function vectors. */
327 x86_use_watchpoints (t);
328 x86_dr_low.set_control = x86_linux_dr_set_control;
329 x86_dr_low.set_addr = x86_linux_dr_set_addr;
330 x86_dr_low.get_addr = x86_linux_dr_get_addr;
331 x86_dr_low.get_status = x86_linux_dr_get_status;
332 x86_dr_low.get_control = x86_linux_dr_get_control;
333 x86_set_debug_register_length (sizeof (void *));
335 /* Override the GNU/Linux inferior startup hook. */
336 super_post_startup_inferior = t->to_post_startup_inferior;
337 t->to_post_startup_inferior = x86_linux_child_post_startup_inferior;
339 /* Add the description reader. */
340 t->to_read_description = x86_linux_read_description;
342 /* Add btrace methods. */
343 t->to_supports_btrace = linux_supports_btrace;
344 t->to_enable_btrace = x86_linux_enable_btrace;
345 t->to_disable_btrace = x86_linux_disable_btrace;
346 t->to_teardown_btrace = x86_linux_teardown_btrace;
347 t->to_read_btrace = x86_linux_read_btrace;
348 t->to_btrace_conf = x86_linux_btrace_conf;
353 /* Add an x86 GNU/Linux target. */
356 x86_linux_add_target (struct target_ops *t)
358 linux_nat_add_target (t);
359 linux_nat_set_new_thread (t, x86_linux_new_thread);
360 linux_nat_set_delete_thread (t, x86_linux_delete_thread);
361 linux_nat_set_new_fork (t, x86_linux_new_fork);
362 linux_nat_set_forget_process (t, x86_forget_process);
363 linux_nat_set_prepare_to_resume (t, x86_linux_prepare_to_resume);