1 /* Native-dependent code for GNU/Linux i386.
3 Copyright (C) 1999-2013 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/>. */
27 #include "linux-nat.h"
28 #include "linux-btrace.h"
31 #include "gdb_assert.h"
33 #include "elf/common.h"
35 #include <sys/ptrace.h>
37 #include <sys/procfs.h>
47 #ifdef HAVE_SYS_DEBUGREG_H
48 #include <sys/debugreg.h>
51 /* Prototypes for supply_gregset etc. */
54 #include "i387-tdep.h"
55 #include "i386-tdep.h"
56 #include "i386-linux-tdep.h"
58 /* Defines ps_err_e, struct ps_prochandle. */
59 #include "gdb_proc_service.h"
61 #include "i386-xstate.h"
63 #ifndef PTRACE_GETREGSET
64 #define PTRACE_GETREGSET 0x4204
67 #ifndef PTRACE_SETREGSET
68 #define PTRACE_SETREGSET 0x4205
71 /* Per-thread arch-specific data we want to keep. */
75 /* Non-zero if our copy differs from what's recorded in the thread. */
76 int debug_registers_changed;
79 /* Does the current host support PTRACE_GETREGSET? */
80 static int have_ptrace_getregset = -1;
83 /* The register sets used in GNU/Linux ELF core-dumps are identical to
84 the register sets in `struct user' that is used for a.out
85 core-dumps, and is also used by `ptrace'. The corresponding types
86 are `elf_gregset_t' for the general-purpose registers (with
87 `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
88 for the floating-point registers.
90 Those types used to be available under the names `gregset_t' and
91 `fpregset_t' too, and this file used those names in the past. But
92 those names are now used for the register sets used in the
93 `mcontext_t' type, and have a different size and layout. */
95 /* Which ptrace request retrieves which registers?
96 These apply to the corresponding SET requests as well. */
98 #define GETREGS_SUPPLIES(regno) \
99 ((0 <= (regno) && (regno) <= 15) || (regno) == I386_LINUX_ORIG_EAX_REGNUM)
101 #define GETFPXREGS_SUPPLIES(regno) \
102 (I386_ST0_REGNUM <= (regno) && (regno) < I386_SSE_NUM_REGS)
104 #define GETXSTATEREGS_SUPPLIES(regno) \
105 (I386_ST0_REGNUM <= (regno) && (regno) < I386_AVX_NUM_REGS)
107 /* Does the current host support the GETREGS request? */
108 int have_ptrace_getregs =
109 #ifdef HAVE_PTRACE_GETREGS
116 /* Does the current host support the GETFPXREGS request? The header
117 file may or may not define it, and even if it is defined, the
118 kernel will return EIO if it's running on a pre-SSE processor.
120 My instinct is to attach this to some architecture- or
121 target-specific data structure, but really, a particular GDB
122 process can only run on top of one kernel at a time. So it's okay
123 for this to be a simple variable. */
124 int have_ptrace_getfpxregs =
125 #ifdef HAVE_PTRACE_GETFPXREGS
133 /* Accessing registers through the U area, one at a time. */
135 /* Fetch one register. */
138 fetch_register (struct regcache *regcache, int regno)
143 gdb_assert (!have_ptrace_getregs);
144 if (i386_linux_gregset_reg_offset[regno] == -1)
146 regcache_raw_supply (regcache, regno, NULL);
150 /* GNU/Linux LWP ID's are process ID's. */
151 tid = ptid_get_lwp (inferior_ptid);
153 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
156 val = ptrace (PTRACE_PEEKUSER, tid,
157 i386_linux_gregset_reg_offset[regno], 0);
159 error (_("Couldn't read register %s (#%d): %s."),
160 gdbarch_register_name (get_regcache_arch (regcache), regno),
161 regno, safe_strerror (errno));
163 regcache_raw_supply (regcache, regno, &val);
166 /* Store one register. */
169 store_register (const struct regcache *regcache, int regno)
174 gdb_assert (!have_ptrace_getregs);
175 if (i386_linux_gregset_reg_offset[regno] == -1)
178 /* GNU/Linux LWP ID's are process ID's. */
179 tid = ptid_get_lwp (inferior_ptid);
181 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
184 regcache_raw_collect (regcache, regno, &val);
185 ptrace (PTRACE_POKEUSER, tid,
186 i386_linux_gregset_reg_offset[regno], val);
188 error (_("Couldn't write register %s (#%d): %s."),
189 gdbarch_register_name (get_regcache_arch (regcache), regno),
190 regno, safe_strerror (errno));
194 /* Transfering the general-purpose registers between GDB, inferiors
197 /* Fill GDB's register array with the general-purpose register values
201 supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
203 const gdb_byte *regp = (const gdb_byte *) gregsetp;
206 for (i = 0; i < I386_NUM_GREGS; i++)
207 regcache_raw_supply (regcache, i,
208 regp + i386_linux_gregset_reg_offset[i]);
210 if (I386_LINUX_ORIG_EAX_REGNUM
211 < gdbarch_num_regs (get_regcache_arch (regcache)))
212 regcache_raw_supply (regcache, I386_LINUX_ORIG_EAX_REGNUM, regp
213 + i386_linux_gregset_reg_offset[I386_LINUX_ORIG_EAX_REGNUM]);
216 /* Fill register REGNO (if it is a general-purpose register) in
217 *GREGSETPS with the value in GDB's register array. If REGNO is -1,
218 do this for all registers. */
221 fill_gregset (const struct regcache *regcache,
222 elf_gregset_t *gregsetp, int regno)
224 gdb_byte *regp = (gdb_byte *) gregsetp;
227 for (i = 0; i < I386_NUM_GREGS; i++)
228 if (regno == -1 || regno == i)
229 regcache_raw_collect (regcache, i,
230 regp + i386_linux_gregset_reg_offset[i]);
232 if ((regno == -1 || regno == I386_LINUX_ORIG_EAX_REGNUM)
233 && I386_LINUX_ORIG_EAX_REGNUM
234 < gdbarch_num_regs (get_regcache_arch (regcache)))
235 regcache_raw_collect (regcache, I386_LINUX_ORIG_EAX_REGNUM, regp
236 + i386_linux_gregset_reg_offset[I386_LINUX_ORIG_EAX_REGNUM]);
239 #ifdef HAVE_PTRACE_GETREGS
241 /* Fetch all general-purpose registers from process/thread TID and
242 store their values in GDB's register array. */
245 fetch_regs (struct regcache *regcache, int tid)
248 elf_gregset_t *regs_p = ®s;
250 if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
254 /* The kernel we're running on doesn't support the GETREGS
255 request. Reset `have_ptrace_getregs'. */
256 have_ptrace_getregs = 0;
260 perror_with_name (_("Couldn't get registers"));
263 supply_gregset (regcache, (const elf_gregset_t *) regs_p);
266 /* Store all valid general-purpose registers in GDB's register array
267 into the process/thread specified by TID. */
270 store_regs (const struct regcache *regcache, int tid, int regno)
274 if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
275 perror_with_name (_("Couldn't get registers"));
277 fill_gregset (regcache, ®s, regno);
279 if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0)
280 perror_with_name (_("Couldn't write registers"));
285 static void fetch_regs (struct regcache *regcache, int tid) {}
286 static void store_regs (const struct regcache *regcache, int tid, int regno) {}
291 /* Transfering floating-point registers between GDB, inferiors and cores. */
293 /* Fill GDB's register array with the floating-point register values in
297 supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
299 i387_supply_fsave (regcache, -1, fpregsetp);
302 /* Fill register REGNO (if it is a floating-point register) in
303 *FPREGSETP with the value in GDB's register array. If REGNO is -1,
304 do this for all registers. */
307 fill_fpregset (const struct regcache *regcache,
308 elf_fpregset_t *fpregsetp, int regno)
310 i387_collect_fsave (regcache, regno, fpregsetp);
313 #ifdef HAVE_PTRACE_GETREGS
315 /* Fetch all floating-point registers from process/thread TID and store
316 thier values in GDB's register array. */
319 fetch_fpregs (struct regcache *regcache, int tid)
321 elf_fpregset_t fpregs;
323 if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
324 perror_with_name (_("Couldn't get floating point status"));
326 supply_fpregset (regcache, (const elf_fpregset_t *) &fpregs);
329 /* Store all valid floating-point registers in GDB's register array
330 into the process/thread specified by TID. */
333 store_fpregs (const struct regcache *regcache, int tid, int regno)
335 elf_fpregset_t fpregs;
337 if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
338 perror_with_name (_("Couldn't get floating point status"));
340 fill_fpregset (regcache, &fpregs, regno);
342 if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
343 perror_with_name (_("Couldn't write floating point status"));
349 fetch_fpregs (struct regcache *regcache, int tid)
354 store_fpregs (const struct regcache *regcache, int tid, int regno)
361 /* Transfering floating-point and SSE registers to and from GDB. */
363 /* Fetch all registers covered by the PTRACE_GETREGSET request from
364 process/thread TID and store their values in GDB's register array.
365 Return non-zero if successful, zero otherwise. */
368 fetch_xstateregs (struct regcache *regcache, int tid)
370 char xstateregs[I386_XSTATE_MAX_SIZE];
373 if (!have_ptrace_getregset)
376 iov.iov_base = xstateregs;
377 iov.iov_len = sizeof(xstateregs);
378 if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
380 perror_with_name (_("Couldn't read extended state status"));
382 i387_supply_xsave (regcache, -1, xstateregs);
386 /* Store all valid registers in GDB's register array covered by the
387 PTRACE_SETREGSET request into the process/thread specified by TID.
388 Return non-zero if successful, zero otherwise. */
391 store_xstateregs (const struct regcache *regcache, int tid, int regno)
393 char xstateregs[I386_XSTATE_MAX_SIZE];
396 if (!have_ptrace_getregset)
399 iov.iov_base = xstateregs;
400 iov.iov_len = sizeof(xstateregs);
401 if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
403 perror_with_name (_("Couldn't read extended state status"));
405 i387_collect_xsave (regcache, regno, xstateregs, 0);
407 if (ptrace (PTRACE_SETREGSET, tid, (unsigned int) NT_X86_XSTATE,
409 perror_with_name (_("Couldn't write extended state status"));
414 #ifdef HAVE_PTRACE_GETFPXREGS
416 /* Fetch all registers covered by the PTRACE_GETFPXREGS request from
417 process/thread TID and store their values in GDB's register array.
418 Return non-zero if successful, zero otherwise. */
421 fetch_fpxregs (struct regcache *regcache, int tid)
423 elf_fpxregset_t fpxregs;
425 if (! have_ptrace_getfpxregs)
428 if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
432 have_ptrace_getfpxregs = 0;
436 perror_with_name (_("Couldn't read floating-point and SSE registers"));
439 i387_supply_fxsave (regcache, -1, (const elf_fpxregset_t *) &fpxregs);
443 /* Store all valid registers in GDB's register array covered by the
444 PTRACE_SETFPXREGS request into the process/thread specified by TID.
445 Return non-zero if successful, zero otherwise. */
448 store_fpxregs (const struct regcache *regcache, int tid, int regno)
450 elf_fpxregset_t fpxregs;
452 if (! have_ptrace_getfpxregs)
455 if (ptrace (PTRACE_GETFPXREGS, tid, 0, &fpxregs) == -1)
459 have_ptrace_getfpxregs = 0;
463 perror_with_name (_("Couldn't read floating-point and SSE registers"));
466 i387_collect_fxsave (regcache, regno, &fpxregs);
468 if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1)
469 perror_with_name (_("Couldn't write floating-point and SSE registers"));
477 fetch_fpxregs (struct regcache *regcache, int tid)
483 store_fpxregs (const struct regcache *regcache, int tid, int regno)
488 #endif /* HAVE_PTRACE_GETFPXREGS */
491 /* Transferring arbitrary registers between GDB and inferior. */
493 /* Fetch register REGNO from the child process. If REGNO is -1, do
494 this for all registers (including the floating point and SSE
498 i386_linux_fetch_inferior_registers (struct target_ops *ops,
499 struct regcache *regcache, int regno)
503 /* Use the old method of peeking around in `struct user' if the
504 GETREGS request isn't available. */
505 if (!have_ptrace_getregs)
509 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
510 if (regno == -1 || regno == i)
511 fetch_register (regcache, i);
516 /* GNU/Linux LWP ID's are process ID's. */
517 tid = ptid_get_lwp (inferior_ptid);
519 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
521 /* Use the PTRACE_GETFPXREGS request whenever possible, since it
522 transfers more registers in one system call, and we'll cache the
523 results. But remember that fetch_fpxregs can fail, and return
527 fetch_regs (regcache, tid);
529 /* The call above might reset `have_ptrace_getregs'. */
530 if (!have_ptrace_getregs)
532 i386_linux_fetch_inferior_registers (ops, regcache, regno);
536 if (fetch_xstateregs (regcache, tid))
538 if (fetch_fpxregs (regcache, tid))
540 fetch_fpregs (regcache, tid);
544 if (GETREGS_SUPPLIES (regno))
546 fetch_regs (regcache, tid);
550 if (GETXSTATEREGS_SUPPLIES (regno))
552 if (fetch_xstateregs (regcache, tid))
556 if (GETFPXREGS_SUPPLIES (regno))
558 if (fetch_fpxregs (regcache, tid))
561 /* Either our processor or our kernel doesn't support the SSE
562 registers, so read the FP registers in the traditional way,
563 and fill the SSE registers with dummy values. It would be
564 more graceful to handle differences in the register set using
565 gdbarch. Until then, this will at least make things work
567 fetch_fpregs (regcache, tid);
571 internal_error (__FILE__, __LINE__,
572 _("Got request for bad register number %d."), regno);
575 /* Store register REGNO back into the child process. If REGNO is -1,
576 do this for all registers (including the floating point and SSE
579 i386_linux_store_inferior_registers (struct target_ops *ops,
580 struct regcache *regcache, int regno)
584 /* Use the old method of poking around in `struct user' if the
585 SETREGS request isn't available. */
586 if (!have_ptrace_getregs)
590 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
591 if (regno == -1 || regno == i)
592 store_register (regcache, i);
597 /* GNU/Linux LWP ID's are process ID's. */
598 tid = ptid_get_lwp (inferior_ptid);
600 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
602 /* Use the PTRACE_SETFPXREGS requests whenever possible, since it
603 transfers more registers in one system call. But remember that
604 store_fpxregs can fail, and return zero. */
607 store_regs (regcache, tid, regno);
608 if (store_xstateregs (regcache, tid, regno))
610 if (store_fpxregs (regcache, tid, regno))
612 store_fpregs (regcache, tid, regno);
616 if (GETREGS_SUPPLIES (regno))
618 store_regs (regcache, tid, regno);
622 if (GETXSTATEREGS_SUPPLIES (regno))
624 if (store_xstateregs (regcache, tid, regno))
628 if (GETFPXREGS_SUPPLIES (regno))
630 if (store_fpxregs (regcache, tid, regno))
633 /* Either our processor or our kernel doesn't support the SSE
634 registers, so just write the FP registers in the traditional
636 store_fpregs (regcache, tid, regno);
640 internal_error (__FILE__, __LINE__,
641 _("Got request to store bad register number %d."), regno);
645 /* Support for debug registers. */
647 /* Get debug register REGNUM value from only the one LWP of PTID. */
650 i386_linux_dr_get (ptid_t ptid, int regnum)
655 tid = ptid_get_lwp (ptid);
657 tid = ptid_get_pid (ptid);
660 value = ptrace (PTRACE_PEEKUSER, tid,
661 offsetof (struct user, u_debugreg[regnum]), 0);
663 perror_with_name (_("Couldn't read debug register"));
668 /* Set debug register REGNUM to VALUE in only the one LWP of PTID. */
671 i386_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
675 tid = ptid_get_lwp (ptid);
677 tid = ptid_get_pid (ptid);
680 ptrace (PTRACE_POKEUSER, tid,
681 offsetof (struct user, u_debugreg[regnum]), value);
683 perror_with_name (_("Couldn't write debug register"));
686 /* Return the inferior's debug register REGNUM. */
689 i386_linux_dr_get_addr (int regnum)
691 /* DR6 and DR7 are retrieved with some other way. */
692 gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
694 return i386_linux_dr_get (inferior_ptid, regnum);
697 /* Return the inferior's DR7 debug control register. */
700 i386_linux_dr_get_control (void)
702 return i386_linux_dr_get (inferior_ptid, DR_CONTROL);
705 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID. */
708 i386_linux_dr_get_status (void)
710 return i386_linux_dr_get (inferior_ptid, DR_STATUS);
713 /* Callback for iterate_over_lwps. Update the debug registers of
717 update_debug_registers_callback (struct lwp_info *lwp, void *arg)
719 if (lwp->arch_private == NULL)
720 lwp->arch_private = XCNEW (struct arch_lwp_info);
722 /* The actual update is done later just before resuming the lwp, we
723 just mark that the registers need updating. */
724 lwp->arch_private->debug_registers_changed = 1;
726 /* If the lwp isn't stopped, force it to momentarily pause, so we
727 can update its debug registers. */
729 linux_stop_lwp (lwp);
731 /* Continue the iteration. */
735 /* Set DR_CONTROL to ADDR in all LWPs of the current inferior. */
738 i386_linux_dr_set_control (unsigned long control)
740 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
742 iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
745 /* Set address REGNUM (zero based) to ADDR in all LWPs of the current
749 i386_linux_dr_set_addr (int regnum, CORE_ADDR addr)
751 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
753 gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
755 iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
758 /* Called when resuming a thread.
759 If the debug regs have changed, update the thread's copies. */
762 i386_linux_prepare_to_resume (struct lwp_info *lwp)
764 int clear_status = 0;
766 /* NULL means this is the main thread still going through the shell,
767 or, no watchpoint has been set yet. In that case, there's
769 if (lwp->arch_private == NULL)
772 if (lwp->arch_private->debug_registers_changed)
774 struct i386_debug_reg_state *state
775 = i386_debug_reg_state (ptid_get_pid (lwp->ptid));
778 /* See amd64_linux_prepare_to_resume for Linux kernel note on
779 i386_linux_dr_set calls ordering. */
781 for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++)
782 if (state->dr_ref_count[i] > 0)
784 i386_linux_dr_set (lwp->ptid, i, state->dr_mirror[i]);
786 /* If we're setting a watchpoint, any change the inferior
787 had done itself to the debug registers needs to be
788 discarded, otherwise, i386_stopped_data_address can get
793 i386_linux_dr_set (lwp->ptid, DR_CONTROL, state->dr_control_mirror);
795 lwp->arch_private->debug_registers_changed = 0;
798 if (clear_status || lwp->stopped_by_watchpoint)
799 i386_linux_dr_set (lwp->ptid, DR_STATUS, 0);
803 i386_linux_new_thread (struct lwp_info *lp)
805 struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
807 info->debug_registers_changed = 1;
809 lp->arch_private = info;
812 /* linux_nat_new_fork hook. */
815 i386_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
818 struct i386_debug_reg_state *parent_state;
819 struct i386_debug_reg_state *child_state;
821 /* NULL means no watchpoint has ever been set in the parent. In
822 that case, there's nothing to do. */
823 if (parent->arch_private == NULL)
826 /* Linux kernel before 2.6.33 commit
827 72f674d203cd230426437cdcf7dd6f681dad8b0d
828 will inherit hardware debug registers from parent
829 on fork/vfork/clone. Newer Linux kernels create such tasks with
830 zeroed debug registers.
832 GDB core assumes the child inherits the watchpoints/hw
833 breakpoints of the parent, and will remove them all from the
834 forked off process. Copy the debug registers mirrors into the
835 new process so that all breakpoints and watchpoints can be
836 removed together. The debug registers mirror will become zeroed
837 in the end before detaching the forked off process, thus making
838 this compatible with older Linux kernels too. */
840 parent_pid = ptid_get_pid (parent->ptid);
841 parent_state = i386_debug_reg_state (parent_pid);
842 child_state = i386_debug_reg_state (child_pid);
843 *child_state = *parent_state;
848 /* Called by libthread_db. Returns a pointer to the thread local
849 storage (or its descriptor). */
852 ps_get_thread_area (const struct ps_prochandle *ph,
853 lwpid_t lwpid, int idx, void **base)
855 /* NOTE: cagney/2003-08-26: The definition of this buffer is found
856 in the kernel header <asm-i386/ldt.h>. It, after padding, is 4 x
857 4 byte integers in size: `entry_number', `base_addr', `limit',
858 and a bunch of status bits.
860 The values returned by this ptrace call should be part of the
861 regcache buffer, and ps_get_thread_area should channel its
862 request through the regcache. That way remote targets could
863 provide the value using the remote protocol and not this direct
866 Is this function needed? I'm guessing that the `base' is the
867 address of a descriptor that libthread_db uses to find the
868 thread local address base that GDB needs. Perhaps that
869 descriptor is defined by the ABI. Anyway, given that
870 libthread_db calls this function without prompting (gdb
871 requesting tls base) I guess it needs info in there anyway. */
872 unsigned int desc[4];
873 gdb_assert (sizeof (int) == 4);
875 #ifndef PTRACE_GET_THREAD_AREA
876 #define PTRACE_GET_THREAD_AREA 25
879 if (ptrace (PTRACE_GET_THREAD_AREA, lwpid,
880 (void *) idx, (unsigned long) &desc) < 0)
883 *(int *)base = desc[1];
888 /* The instruction for a GNU/Linux system call is:
892 static const unsigned char linux_syscall[] = { 0xcd, 0x80 };
894 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
896 /* The system call number is stored in the %eax register. */
897 #define LINUX_SYSCALL_REGNUM I386_EAX_REGNUM
899 /* We are specifically interested in the sigreturn and rt_sigreturn
902 #ifndef SYS_sigreturn
903 #define SYS_sigreturn 0x77
905 #ifndef SYS_rt_sigreturn
906 #define SYS_rt_sigreturn 0xad
909 /* Offset to saved processor flags, from <asm/sigcontext.h>. */
910 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
912 /* Resume execution of the inferior process.
913 If STEP is nonzero, single-step it.
914 If SIGNAL is nonzero, give it that signal. */
917 i386_linux_resume (struct target_ops *ops,
918 ptid_t ptid, int step, enum gdb_signal signal)
920 int pid = ptid_get_pid (ptid);
924 if (catch_syscall_enabled () > 0)
925 request = PTRACE_SYSCALL;
927 request = PTRACE_CONT;
931 struct regcache *regcache = get_thread_regcache (pid_to_ptid (pid));
932 struct gdbarch *gdbarch = get_regcache_arch (regcache);
933 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
935 gdb_byte buf[LINUX_SYSCALL_LEN];
937 request = PTRACE_SINGLESTEP;
939 regcache_cooked_read_unsigned (regcache,
940 gdbarch_pc_regnum (gdbarch), &pc);
942 /* Returning from a signal trampoline is done by calling a
943 special system call (sigreturn or rt_sigreturn, see
944 i386-linux-tdep.c for more information). This system call
945 restores the registers that were saved when the signal was
946 raised, including %eflags. That means that single-stepping
947 won't work. Instead, we'll have to modify the signal context
948 that's about to be restored, and set the trace flag there. */
950 /* First check if PC is at a system call. */
951 if (target_read_memory (pc, buf, LINUX_SYSCALL_LEN) == 0
952 && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0)
955 regcache_cooked_read_unsigned (regcache,
956 LINUX_SYSCALL_REGNUM, &syscall);
958 /* Then check the system call number. */
959 if (syscall == SYS_sigreturn || syscall == SYS_rt_sigreturn)
962 unsigned long int eflags;
964 regcache_cooked_read_unsigned (regcache, I386_ESP_REGNUM, &sp);
965 if (syscall == SYS_rt_sigreturn)
966 addr = read_memory_unsigned_integer (sp + 8, 4, byte_order)
971 /* Set the trace flag in the context that's about to be
973 addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET;
974 read_memory (addr, (gdb_byte *) &eflags, 4);
976 write_memory (addr, (gdb_byte *) &eflags, 4);
981 if (ptrace (request, pid, 0, gdb_signal_to_host (signal)) == -1)
982 perror_with_name (("ptrace"));
985 static void (*super_post_startup_inferior) (ptid_t ptid);
988 i386_linux_child_post_startup_inferior (ptid_t ptid)
990 i386_cleanup_dregs ();
991 super_post_startup_inferior (ptid);
994 /* Get Linux/x86 target description from running target. */
996 static const struct target_desc *
997 i386_linux_read_description (struct target_ops *ops)
1000 static uint64_t xcr0;
1002 /* GNU/Linux LWP ID's are process ID's. */
1003 tid = ptid_get_lwp (inferior_ptid);
1005 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
1007 #ifdef HAVE_PTRACE_GETFPXREGS
1008 if (have_ptrace_getfpxregs == -1)
1010 elf_fpxregset_t fpxregs;
1012 if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
1014 have_ptrace_getfpxregs = 0;
1015 have_ptrace_getregset = 0;
1016 return tdesc_i386_mmx_linux;
1021 if (have_ptrace_getregset == -1)
1023 uint64_t xstateregs[(I386_XSTATE_SSE_SIZE / sizeof (uint64_t))];
1026 iov.iov_base = xstateregs;
1027 iov.iov_len = sizeof (xstateregs);
1029 /* Check if PTRACE_GETREGSET works. */
1030 if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
1032 have_ptrace_getregset = 0;
1035 have_ptrace_getregset = 1;
1037 /* Get XCR0 from XSAVE extended state. */
1038 xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
1039 / sizeof (long long))];
1043 /* Check the native XCR0 only if PTRACE_GETREGSET is available. */
1044 if (have_ptrace_getregset
1045 && (xcr0 & I386_XSTATE_AVX_MASK) == I386_XSTATE_AVX_MASK)
1046 return tdesc_i386_avx_linux;
1048 return tdesc_i386_linux;
1051 /* Enable branch tracing. */
1053 static struct btrace_target_info *
1054 i386_linux_enable_btrace (ptid_t ptid)
1056 struct btrace_target_info *tinfo;
1057 struct gdbarch *gdbarch;
1060 tinfo = linux_enable_btrace (ptid);
1063 error (_("Could not enable branch tracing for %s: %s."),
1064 target_pid_to_str (ptid), safe_strerror (errno));
1066 /* Fill in the size of a pointer in bits. */
1067 gdbarch = target_thread_architecture (ptid);
1068 tinfo->ptr_bits = gdbarch_ptr_bit (gdbarch);
1073 /* Disable branch tracing. */
1076 i386_linux_disable_btrace (struct btrace_target_info *tinfo)
1078 int errcode = linux_disable_btrace (tinfo);
1081 error (_("Could not disable branch tracing: %s."), safe_strerror (errcode));
1084 /* Teardown branch tracing. */
1087 i386_linux_teardown_btrace (struct btrace_target_info *tinfo)
1089 /* Ignore errors. */
1090 linux_disable_btrace (tinfo);
1093 /* -Wmissing-prototypes */
1094 extern initialize_file_ftype _initialize_i386_linux_nat;
1097 _initialize_i386_linux_nat (void)
1099 struct target_ops *t;
1101 /* Fill in the generic GNU/Linux methods. */
1102 t = linux_target ();
1104 i386_use_watchpoints (t);
1106 i386_dr_low.set_control = i386_linux_dr_set_control;
1107 i386_dr_low.set_addr = i386_linux_dr_set_addr;
1108 i386_dr_low.get_addr = i386_linux_dr_get_addr;
1109 i386_dr_low.get_status = i386_linux_dr_get_status;
1110 i386_dr_low.get_control = i386_linux_dr_get_control;
1111 i386_set_debug_register_length (4);
1113 /* Override the default ptrace resume method. */
1114 t->to_resume = i386_linux_resume;
1116 /* Override the GNU/Linux inferior startup hook. */
1117 super_post_startup_inferior = t->to_post_startup_inferior;
1118 t->to_post_startup_inferior = i386_linux_child_post_startup_inferior;
1120 /* Add our register access methods. */
1121 t->to_fetch_registers = i386_linux_fetch_inferior_registers;
1122 t->to_store_registers = i386_linux_store_inferior_registers;
1124 t->to_read_description = i386_linux_read_description;
1126 /* Add btrace methods. */
1127 t->to_supports_btrace = linux_supports_btrace;
1128 t->to_enable_btrace = i386_linux_enable_btrace;
1129 t->to_disable_btrace = i386_linux_disable_btrace;
1130 t->to_teardown_btrace = i386_linux_teardown_btrace;
1131 t->to_read_btrace = linux_read_btrace;
1133 /* Register the target. */
1134 linux_nat_add_target (t);
1135 linux_nat_set_new_thread (t, i386_linux_new_thread);
1136 linux_nat_set_new_fork (t, i386_linux_new_fork);
1137 linux_nat_set_forget_process (t, i386_forget_process);
1138 linux_nat_set_prepare_to_resume (t, i386_linux_prepare_to_resume);