1 /* Native-dependent code for GNU/Linux i386.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
28 #include "linux-nat.h"
30 #include "gdb_assert.h"
31 #include "gdb_string.h"
32 #include <sys/ptrace.h>
34 #include <sys/procfs.h>
44 #ifdef HAVE_SYS_DEBUGREG_H
45 #include <sys/debugreg.h>
49 #define DR_FIRSTADDR 0
64 /* Prototypes for supply_gregset etc. */
67 #include "i387-tdep.h"
68 #include "i386-tdep.h"
69 #include "i386-linux-tdep.h"
71 /* Defines ps_err_e, struct ps_prochandle. */
72 #include "gdb_proc_service.h"
75 /* The register sets used in GNU/Linux ELF core-dumps are identical to
76 the register sets in `struct user' that is used for a.out
77 core-dumps, and is also used by `ptrace'. The corresponding types
78 are `elf_gregset_t' for the general-purpose registers (with
79 `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
80 for the floating-point registers.
82 Those types used to be available under the names `gregset_t' and
83 `fpregset_t' too, and this file used those names in the past. But
84 those names are now used for the register sets used in the
85 `mcontext_t' type, and have a different size and layout. */
87 /* Mapping between the general-purpose registers in `struct user'
88 format and GDB's register array layout. */
95 -1, -1, -1, -1, /* st0, st1, st2, st3 */
96 -1, -1, -1, -1, /* st4, st5, st6, st7 */
97 -1, -1, -1, -1, /* fctrl, fstat, ftag, fiseg */
98 -1, -1, -1, -1, /* fioff, foseg, fooff, fop */
99 -1, -1, -1, -1, /* xmm0, xmm1, xmm2, xmm3 */
100 -1, -1, -1, -1, /* xmm4, xmm5, xmm6, xmm6 */
105 /* Which ptrace request retrieves which registers?
106 These apply to the corresponding SET requests as well. */
108 #define GETREGS_SUPPLIES(regno) \
109 ((0 <= (regno) && (regno) <= 15) || (regno) == I386_LINUX_ORIG_EAX_REGNUM)
111 #define GETFPXREGS_SUPPLIES(regno) \
112 (I386_ST0_REGNUM <= (regno) && (regno) < I386_SSE_NUM_REGS)
114 /* Does the current host support the GETREGS request? */
115 int have_ptrace_getregs
=
116 #ifdef HAVE_PTRACE_GETREGS
123 /* Does the current host support the GETFPXREGS request? The header
124 file may or may not define it, and even if it is defined, the
125 kernel will return EIO if it's running on a pre-SSE processor.
127 My instinct is to attach this to some architecture- or
128 target-specific data structure, but really, a particular GDB
129 process can only run on top of one kernel at a time. So it's okay
130 for this to be a simple variable. */
131 int have_ptrace_getfpxregs
=
132 #ifdef HAVE_PTRACE_GETFPXREGS
140 /* Accessing registers through the U area, one at a time. */
142 /* Fetch one register. */
145 fetch_register (struct regcache
*regcache
, int regno
)
150 gdb_assert (!have_ptrace_getregs
);
151 if (regmap
[regno
] == -1)
153 regcache_raw_supply (regcache
, regno
, NULL
);
157 /* GNU/Linux LWP ID's are process ID's. */
158 tid
= TIDGET (inferior_ptid
);
160 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
163 val
= ptrace (PTRACE_PEEKUSER
, tid
, 4 * regmap
[regno
], 0);
165 error (_("Couldn't read register %s (#%d): %s."),
166 gdbarch_register_name (current_gdbarch
, regno
),
167 regno
, safe_strerror (errno
));
169 regcache_raw_supply (regcache
, regno
, &val
);
172 /* Store one register. */
175 store_register (const struct regcache
*regcache
, int regno
)
180 gdb_assert (!have_ptrace_getregs
);
181 if (regmap
[regno
] == -1)
184 /* GNU/Linux LWP ID's are process ID's. */
185 tid
= TIDGET (inferior_ptid
);
187 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
190 regcache_raw_collect (regcache
, regno
, &val
);
191 ptrace (PTRACE_POKEUSER
, tid
, 4 * regmap
[regno
], val
);
193 error (_("Couldn't write register %s (#%d): %s."),
194 gdbarch_register_name (current_gdbarch
, regno
),
195 regno
, safe_strerror (errno
));
199 /* Transfering the general-purpose registers between GDB, inferiors
202 /* Fill GDB's register array with the general-purpose register values
206 supply_gregset (struct regcache
*regcache
, const elf_gregset_t
*gregsetp
)
208 const elf_greg_t
*regp
= (const elf_greg_t
*) gregsetp
;
211 for (i
= 0; i
< I386_NUM_GREGS
; i
++)
212 regcache_raw_supply (regcache
, i
, regp
+ regmap
[i
]);
214 if (I386_LINUX_ORIG_EAX_REGNUM
< gdbarch_num_regs (current_gdbarch
))
215 regcache_raw_supply (regcache
, I386_LINUX_ORIG_EAX_REGNUM
,
219 /* Fill register REGNO (if it is a general-purpose register) in
220 *GREGSETPS with the value in GDB's register array. If REGNO is -1,
221 do this for all registers. */
224 fill_gregset (const struct regcache
*regcache
,
225 elf_gregset_t
*gregsetp
, int regno
)
227 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
230 for (i
= 0; i
< I386_NUM_GREGS
; i
++)
231 if (regno
== -1 || regno
== i
)
232 regcache_raw_collect (regcache
, i
, regp
+ regmap
[i
]);
234 if ((regno
== -1 || regno
== I386_LINUX_ORIG_EAX_REGNUM
)
235 && I386_LINUX_ORIG_EAX_REGNUM
< gdbarch_num_regs (current_gdbarch
))
236 regcache_raw_collect (regcache
, I386_LINUX_ORIG_EAX_REGNUM
,
240 #ifdef HAVE_PTRACE_GETREGS
242 /* Fetch all general-purpose registers from process/thread TID and
243 store their values in GDB's register array. */
246 fetch_regs (struct regcache
*regcache
, int tid
)
249 elf_gregset_t
*regs_p
= ®s
;
251 if (ptrace (PTRACE_GETREGS
, tid
, 0, (int) ®s
) < 0)
255 /* The kernel we're running on doesn't support the GETREGS
256 request. Reset `have_ptrace_getregs'. */
257 have_ptrace_getregs
= 0;
261 perror_with_name (_("Couldn't get registers"));
264 supply_gregset (regcache
, (const elf_gregset_t
*) regs_p
);
267 /* Store all valid general-purpose registers in GDB's register array
268 into the process/thread specified by TID. */
271 store_regs (const struct regcache
*regcache
, int tid
, int regno
)
275 if (ptrace (PTRACE_GETREGS
, tid
, 0, (int) ®s
) < 0)
276 perror_with_name (_("Couldn't get registers"));
278 fill_gregset (regcache
, ®s
, regno
);
280 if (ptrace (PTRACE_SETREGS
, tid
, 0, (int) ®s
) < 0)
281 perror_with_name (_("Couldn't write registers"));
286 static void fetch_regs (struct regcache
*regcache
, int tid
) {}
287 static void store_regs (const struct regcache
*regcache
, int tid
, int regno
) {}
292 /* Transfering floating-point registers between GDB, inferiors and cores. */
294 /* Fill GDB's register array with the floating-point register values in
298 supply_fpregset (struct regcache
*regcache
, const elf_fpregset_t
*fpregsetp
)
300 i387_supply_fsave (regcache
, -1, fpregsetp
);
303 /* Fill register REGNO (if it is a floating-point register) in
304 *FPREGSETP with the value in GDB's register array. If REGNO is -1,
305 do this for all registers. */
308 fill_fpregset (const struct regcache
*regcache
,
309 elf_fpregset_t
*fpregsetp
, int regno
)
311 i387_collect_fsave (regcache
, regno
, fpregsetp
);
314 #ifdef HAVE_PTRACE_GETREGS
316 /* Fetch all floating-point registers from process/thread TID and store
317 thier values in GDB's register array. */
320 fetch_fpregs (struct regcache
*regcache
, int tid
)
322 elf_fpregset_t fpregs
;
324 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (int) &fpregs
) < 0)
325 perror_with_name (_("Couldn't get floating point status"));
327 supply_fpregset (regcache
, (const elf_fpregset_t
*) &fpregs
);
330 /* Store all valid floating-point registers in GDB's register array
331 into the process/thread specified by TID. */
334 store_fpregs (const struct regcache
*regcache
, int tid
, int regno
)
336 elf_fpregset_t fpregs
;
338 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (int) &fpregs
) < 0)
339 perror_with_name (_("Couldn't get floating point status"));
341 fill_fpregset (regcache
, &fpregs
, regno
);
343 if (ptrace (PTRACE_SETFPREGS
, tid
, 0, (int) &fpregs
) < 0)
344 perror_with_name (_("Couldn't write floating point status"));
349 static void fetch_fpregs (struct regcache
*regcache
, int tid
) {}
350 static void store_fpregs (const struct regcache
*regcache
, int tid
, int regno
) {}
355 /* Transfering floating-point and SSE registers to and from GDB. */
357 #ifdef HAVE_PTRACE_GETFPXREGS
359 /* Fill GDB's register array with the floating-point and SSE register
360 values in *FPXREGSETP. */
363 supply_fpxregset (struct regcache
*regcache
,
364 const elf_fpxregset_t
*fpxregsetp
)
366 i387_supply_fxsave (regcache
, -1, fpxregsetp
);
369 /* Fill register REGNO (if it is a floating-point or SSE register) in
370 *FPXREGSETP with the value in GDB's register array. If REGNO is
371 -1, do this for all registers. */
374 fill_fpxregset (const struct regcache
*regcache
,
375 elf_fpxregset_t
*fpxregsetp
, int regno
)
377 i387_collect_fxsave (regcache
, regno
, fpxregsetp
);
380 /* Fetch all registers covered by the PTRACE_GETFPXREGS request from
381 process/thread TID and store their values in GDB's register array.
382 Return non-zero if successful, zero otherwise. */
385 fetch_fpxregs (struct regcache
*regcache
, int tid
)
387 elf_fpxregset_t fpxregs
;
389 if (! have_ptrace_getfpxregs
)
392 if (ptrace (PTRACE_GETFPXREGS
, tid
, 0, (int) &fpxregs
) < 0)
396 have_ptrace_getfpxregs
= 0;
400 perror_with_name (_("Couldn't read floating-point and SSE registers"));
403 supply_fpxregset (regcache
, (const elf_fpxregset_t
*) &fpxregs
);
407 /* Store all valid registers in GDB's register array covered by the
408 PTRACE_SETFPXREGS request into the process/thread specified by TID.
409 Return non-zero if successful, zero otherwise. */
412 store_fpxregs (const struct regcache
*regcache
, int tid
, int regno
)
414 elf_fpxregset_t fpxregs
;
416 if (! have_ptrace_getfpxregs
)
419 if (ptrace (PTRACE_GETFPXREGS
, tid
, 0, &fpxregs
) == -1)
423 have_ptrace_getfpxregs
= 0;
427 perror_with_name (_("Couldn't read floating-point and SSE registers"));
430 fill_fpxregset (regcache
, &fpxregs
, regno
);
432 if (ptrace (PTRACE_SETFPXREGS
, tid
, 0, &fpxregs
) == -1)
433 perror_with_name (_("Couldn't write floating-point and SSE registers"));
440 static int fetch_fpxregs (struct regcache
*regcache
, int tid
) { return 0; }
441 static int store_fpxregs (const struct regcache
*regcache
, int tid
, int regno
) { return 0; }
443 #endif /* HAVE_PTRACE_GETFPXREGS */
446 /* Transferring arbitrary registers between GDB and inferior. */
448 /* Fetch register REGNO from the child process. If REGNO is -1, do
449 this for all registers (including the floating point and SSE
453 i386_linux_fetch_inferior_registers (struct regcache
*regcache
, int regno
)
457 /* Use the old method of peeking around in `struct user' if the
458 GETREGS request isn't available. */
459 if (!have_ptrace_getregs
)
463 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
464 if (regno
== -1 || regno
== i
)
465 fetch_register (regcache
, i
);
470 /* GNU/Linux LWP ID's are process ID's. */
471 tid
= TIDGET (inferior_ptid
);
473 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
475 /* Use the PTRACE_GETFPXREGS request whenever possible, since it
476 transfers more registers in one system call, and we'll cache the
477 results. But remember that fetch_fpxregs can fail, and return
481 fetch_regs (regcache
, tid
);
483 /* The call above might reset `have_ptrace_getregs'. */
484 if (!have_ptrace_getregs
)
486 i386_linux_fetch_inferior_registers (regcache
, regno
);
490 if (fetch_fpxregs (regcache
, tid
))
492 fetch_fpregs (regcache
, tid
);
496 if (GETREGS_SUPPLIES (regno
))
498 fetch_regs (regcache
, tid
);
502 if (GETFPXREGS_SUPPLIES (regno
))
504 if (fetch_fpxregs (regcache
, tid
))
507 /* Either our processor or our kernel doesn't support the SSE
508 registers, so read the FP registers in the traditional way,
509 and fill the SSE registers with dummy values. It would be
510 more graceful to handle differences in the register set using
511 gdbarch. Until then, this will at least make things work
513 fetch_fpregs (regcache
, tid
);
517 internal_error (__FILE__
, __LINE__
,
518 _("Got request for bad register number %d."), regno
);
521 /* Store register REGNO back into the child process. If REGNO is -1,
522 do this for all registers (including the floating point and SSE
525 i386_linux_store_inferior_registers (struct regcache
*regcache
, int regno
)
529 /* Use the old method of poking around in `struct user' if the
530 SETREGS request isn't available. */
531 if (!have_ptrace_getregs
)
535 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
536 if (regno
== -1 || regno
== i
)
537 store_register (regcache
, i
);
542 /* GNU/Linux LWP ID's are process ID's. */
543 tid
= TIDGET (inferior_ptid
);
545 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
547 /* Use the PTRACE_SETFPXREGS requests whenever possible, since it
548 transfers more registers in one system call. But remember that
549 store_fpxregs can fail, and return zero. */
552 store_regs (regcache
, tid
, regno
);
553 if (store_fpxregs (regcache
, tid
, regno
))
555 store_fpregs (regcache
, tid
, regno
);
559 if (GETREGS_SUPPLIES (regno
))
561 store_regs (regcache
, tid
, regno
);
565 if (GETFPXREGS_SUPPLIES (regno
))
567 if (store_fpxregs (regcache
, tid
, regno
))
570 /* Either our processor or our kernel doesn't support the SSE
571 registers, so just write the FP registers in the traditional
573 store_fpregs (regcache
, tid
, regno
);
577 internal_error (__FILE__
, __LINE__
,
578 _("Got request to store bad register number %d."), regno
);
582 /* Support for debug registers. */
585 i386_linux_dr_get (int regnum
)
590 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
591 multi-threaded processes here. For now, pretend there is just
593 tid
= PIDGET (inferior_ptid
);
595 /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
596 ptrace call fails breaks debugging remote targets. The correct
597 way to fix this is to add the hardware breakpoint and watchpoint
598 stuff to the target vector. For now, just return zero if the
599 ptrace call fails. */
601 value
= ptrace (PTRACE_PEEKUSER
, tid
,
602 offsetof (struct user
, u_debugreg
[regnum
]), 0);
605 perror_with_name (_("Couldn't read debug register"));
614 i386_linux_dr_set (int regnum
, unsigned long value
)
618 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
619 multi-threaded processes here. For now, pretend there is just
621 tid
= PIDGET (inferior_ptid
);
624 ptrace (PTRACE_POKEUSER
, tid
,
625 offsetof (struct user
, u_debugreg
[regnum
]), value
);
627 perror_with_name (_("Couldn't write debug register"));
631 i386_linux_dr_set_control (unsigned long control
)
633 i386_linux_dr_set (DR_CONTROL
, control
);
637 i386_linux_dr_set_addr (int regnum
, CORE_ADDR addr
)
639 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
641 i386_linux_dr_set (DR_FIRSTADDR
+ regnum
, addr
);
645 i386_linux_dr_reset_addr (int regnum
)
647 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
649 i386_linux_dr_set (DR_FIRSTADDR
+ regnum
, 0L);
653 i386_linux_dr_get_status (void)
655 return i386_linux_dr_get (DR_STATUS
);
659 /* Called by libthread_db. Returns a pointer to the thread local
660 storage (or its descriptor). */
663 ps_get_thread_area (const struct ps_prochandle
*ph
,
664 lwpid_t lwpid
, int idx
, void **base
)
666 /* NOTE: cagney/2003-08-26: The definition of this buffer is found
667 in the kernel header <asm-i386/ldt.h>. It, after padding, is 4 x
668 4 byte integers in size: `entry_number', `base_addr', `limit',
669 and a bunch of status bits.
671 The values returned by this ptrace call should be part of the
672 regcache buffer, and ps_get_thread_area should channel its
673 request through the regcache. That way remote targets could
674 provide the value using the remote protocol and not this direct
677 Is this function needed? I'm guessing that the `base' is the
678 address of a a descriptor that libthread_db uses to find the
679 thread local address base that GDB needs. Perhaps that
680 descriptor is defined by the ABI. Anyway, given that
681 libthread_db calls this function without prompting (gdb
682 requesting tls base) I guess it needs info in there anyway. */
683 unsigned int desc
[4];
684 gdb_assert (sizeof (int) == 4);
686 #ifndef PTRACE_GET_THREAD_AREA
687 #define PTRACE_GET_THREAD_AREA 25
690 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
,
691 (void *) idx
, (unsigned long) &desc
) < 0)
694 *(int *)base
= desc
[1];
699 /* The instruction for a GNU/Linux system call is:
703 static const unsigned char linux_syscall
[] = { 0xcd, 0x80 };
705 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
707 /* The system call number is stored in the %eax register. */
708 #define LINUX_SYSCALL_REGNUM I386_EAX_REGNUM
710 /* We are specifically interested in the sigreturn and rt_sigreturn
713 #ifndef SYS_sigreturn
714 #define SYS_sigreturn 0x77
716 #ifndef SYS_rt_sigreturn
717 #define SYS_rt_sigreturn 0xad
720 /* Offset to saved processor flags, from <asm/sigcontext.h>. */
721 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
723 /* Resume execution of the inferior process.
724 If STEP is nonzero, single-step it.
725 If SIGNAL is nonzero, give it that signal. */
728 i386_linux_resume (ptid_t ptid
, int step
, enum target_signal signal
)
730 int pid
= PIDGET (ptid
);
732 int request
= PTRACE_CONT
;
735 /* Resume all threads. */
736 /* I think this only gets used in the non-threaded case, where "resume
737 all threads" and "resume inferior_ptid" are the same. */
738 pid
= PIDGET (inferior_ptid
);
742 struct regcache
*regcache
= get_thread_regcache (pid_to_ptid (pid
));
744 gdb_byte buf
[LINUX_SYSCALL_LEN
];
746 request
= PTRACE_SINGLESTEP
;
748 regcache_cooked_read_unsigned (regcache
,
749 gdbarch_pc_regnum (current_gdbarch
), &pc
);
751 /* Returning from a signal trampoline is done by calling a
752 special system call (sigreturn or rt_sigreturn, see
753 i386-linux-tdep.c for more information). This system call
754 restores the registers that were saved when the signal was
755 raised, including %eflags. That means that single-stepping
756 won't work. Instead, we'll have to modify the signal context
757 that's about to be restored, and set the trace flag there. */
759 /* First check if PC is at a system call. */
760 if (read_memory_nobpt (pc
, buf
, LINUX_SYSCALL_LEN
) == 0
761 && memcmp (buf
, linux_syscall
, LINUX_SYSCALL_LEN
) == 0)
764 regcache_cooked_read_unsigned (regcache
,
765 LINUX_SYSCALL_REGNUM
, &syscall
);
767 /* Then check the system call number. */
768 if (syscall
== SYS_sigreturn
|| syscall
== SYS_rt_sigreturn
)
771 unsigned long int eflags
;
773 regcache_cooked_read_unsigned (regcache
, I386_ESP_REGNUM
, &sp
);
774 if (syscall
== SYS_rt_sigreturn
)
775 addr
= read_memory_integer (sp
+ 8, 4) + 20;
779 /* Set the trace flag in the context that's about to be
781 addr
+= LINUX_SIGCONTEXT_EFLAGS_OFFSET
;
782 read_memory (addr
, (gdb_byte
*) &eflags
, 4);
784 write_memory (addr
, (gdb_byte
*) &eflags
, 4);
789 if (ptrace (request
, pid
, 0, target_signal_to_host (signal
)) == -1)
790 perror_with_name (("ptrace"));
793 static void (*super_post_startup_inferior
) (ptid_t ptid
);
796 i386_linux_child_post_startup_inferior (ptid_t ptid
)
798 i386_cleanup_dregs ();
799 super_post_startup_inferior (ptid
);
803 _initialize_i386_linux_nat (void)
805 struct target_ops
*t
;
807 /* Fill in the generic GNU/Linux methods. */
810 /* Override the default ptrace resume method. */
811 t
->to_resume
= i386_linux_resume
;
813 /* Override the GNU/Linux inferior startup hook. */
814 super_post_startup_inferior
= t
->to_post_startup_inferior
;
815 t
->to_post_startup_inferior
= i386_linux_child_post_startup_inferior
;
817 /* Add our register access methods. */
818 t
->to_fetch_registers
= i386_linux_fetch_inferior_registers
;
819 t
->to_store_registers
= i386_linux_store_inferior_registers
;
821 /* Register the target. */
822 linux_nat_add_target (t
);