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 3 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, see <http://www.gnu.org/licenses/>. */
26 #include "linux-nat.h"
28 #include "gdb_assert.h"
29 #include "gdb_string.h"
30 #include <sys/ptrace.h>
32 #include <sys/procfs.h>
42 #ifdef HAVE_SYS_DEBUGREG_H
43 #include <sys/debugreg.h>
47 #define DR_FIRSTADDR 0
62 /* Prototypes for supply_gregset etc. */
65 #include "i387-tdep.h"
66 #include "i386-tdep.h"
67 #include "i386-linux-tdep.h"
69 /* Defines ps_err_e, struct ps_prochandle. */
70 #include "gdb_proc_service.h"
73 /* The register sets used in GNU/Linux ELF core-dumps are identical to
74 the register sets in `struct user' that is used for a.out
75 core-dumps, and is also used by `ptrace'. The corresponding types
76 are `elf_gregset_t' for the general-purpose registers (with
77 `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
78 for the floating-point registers.
80 Those types used to be available under the names `gregset_t' and
81 `fpregset_t' too, and this file used those names in the past. But
82 those names are now used for the register sets used in the
83 `mcontext_t' type, and have a different size and layout. */
85 /* Mapping between the general-purpose registers in `struct user'
86 format and GDB's register array layout. */
93 -1, -1, -1, -1, /* st0, st1, st2, st3 */
94 -1, -1, -1, -1, /* st4, st5, st6, st7 */
95 -1, -1, -1, -1, /* fctrl, fstat, ftag, fiseg */
96 -1, -1, -1, -1, /* fioff, foseg, fooff, fop */
97 -1, -1, -1, -1, /* xmm0, xmm1, xmm2, xmm3 */
98 -1, -1, -1, -1, /* xmm4, xmm5, xmm6, xmm6 */
103 /* Which ptrace request retrieves which registers?
104 These apply to the corresponding SET requests as well. */
106 #define GETREGS_SUPPLIES(regno) \
107 ((0 <= (regno) && (regno) <= 15) || (regno) == I386_LINUX_ORIG_EAX_REGNUM)
109 #define GETFPXREGS_SUPPLIES(regno) \
110 (I386_ST0_REGNUM <= (regno) && (regno) < I386_SSE_NUM_REGS)
112 /* Does the current host support the GETREGS request? */
113 int have_ptrace_getregs
=
114 #ifdef HAVE_PTRACE_GETREGS
121 /* Does the current host support the GETFPXREGS request? The header
122 file may or may not define it, and even if it is defined, the
123 kernel will return EIO if it's running on a pre-SSE processor.
125 My instinct is to attach this to some architecture- or
126 target-specific data structure, but really, a particular GDB
127 process can only run on top of one kernel at a time. So it's okay
128 for this to be a simple variable. */
129 int have_ptrace_getfpxregs
=
130 #ifdef HAVE_PTRACE_GETFPXREGS
138 /* Accessing registers through the U area, one at a time. */
140 /* Fetch one register. */
143 fetch_register (struct regcache
*regcache
, int regno
)
148 gdb_assert (!have_ptrace_getregs
);
149 if (regmap
[regno
] == -1)
151 regcache_raw_supply (regcache
, regno
, NULL
);
155 /* GNU/Linux LWP ID's are process ID's. */
156 tid
= TIDGET (inferior_ptid
);
158 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
161 val
= ptrace (PTRACE_PEEKUSER
, tid
, 4 * regmap
[regno
], 0);
163 error (_("Couldn't read register %s (#%d): %s."),
164 gdbarch_register_name (current_gdbarch
, regno
),
165 regno
, safe_strerror (errno
));
167 regcache_raw_supply (regcache
, regno
, &val
);
170 /* Store one register. */
173 store_register (const struct regcache
*regcache
, int regno
)
178 gdb_assert (!have_ptrace_getregs
);
179 if (regmap
[regno
] == -1)
182 /* GNU/Linux LWP ID's are process ID's. */
183 tid
= TIDGET (inferior_ptid
);
185 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
188 regcache_raw_collect (regcache
, regno
, &val
);
189 ptrace (PTRACE_POKEUSER
, tid
, 4 * regmap
[regno
], val
);
191 error (_("Couldn't write register %s (#%d): %s."),
192 gdbarch_register_name (current_gdbarch
, regno
),
193 regno
, safe_strerror (errno
));
197 /* Transfering the general-purpose registers between GDB, inferiors
200 /* Fill GDB's register array with the general-purpose register values
204 supply_gregset (struct regcache
*regcache
, const elf_gregset_t
*gregsetp
)
206 const elf_greg_t
*regp
= (const elf_greg_t
*) gregsetp
;
209 for (i
= 0; i
< I386_NUM_GREGS
; i
++)
210 regcache_raw_supply (regcache
, i
, regp
+ regmap
[i
]);
212 if (I386_LINUX_ORIG_EAX_REGNUM
< gdbarch_num_regs (current_gdbarch
))
213 regcache_raw_supply (regcache
, I386_LINUX_ORIG_EAX_REGNUM
,
217 /* Fill register REGNO (if it is a general-purpose register) in
218 *GREGSETPS with the value in GDB's register array. If REGNO is -1,
219 do this for all registers. */
222 fill_gregset (const struct regcache
*regcache
,
223 elf_gregset_t
*gregsetp
, int regno
)
225 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
228 for (i
= 0; i
< I386_NUM_GREGS
; i
++)
229 if (regno
== -1 || regno
== i
)
230 regcache_raw_collect (regcache
, i
, regp
+ regmap
[i
]);
232 if ((regno
== -1 || regno
== I386_LINUX_ORIG_EAX_REGNUM
)
233 && I386_LINUX_ORIG_EAX_REGNUM
< gdbarch_num_regs (current_gdbarch
))
234 regcache_raw_collect (regcache
, I386_LINUX_ORIG_EAX_REGNUM
,
238 #ifdef HAVE_PTRACE_GETREGS
240 /* Fetch all general-purpose registers from process/thread TID and
241 store their values in GDB's register array. */
244 fetch_regs (struct regcache
*regcache
, int tid
)
247 elf_gregset_t
*regs_p
= ®s
;
249 if (ptrace (PTRACE_GETREGS
, tid
, 0, (int) ®s
) < 0)
253 /* The kernel we're running on doesn't support the GETREGS
254 request. Reset `have_ptrace_getregs'. */
255 have_ptrace_getregs
= 0;
259 perror_with_name (_("Couldn't get registers"));
262 supply_gregset (regcache
, (const elf_gregset_t
*) regs_p
);
265 /* Store all valid general-purpose registers in GDB's register array
266 into the process/thread specified by TID. */
269 store_regs (const struct regcache
*regcache
, int tid
, int regno
)
273 if (ptrace (PTRACE_GETREGS
, tid
, 0, (int) ®s
) < 0)
274 perror_with_name (_("Couldn't get registers"));
276 fill_gregset (regcache
, ®s
, regno
);
278 if (ptrace (PTRACE_SETREGS
, tid
, 0, (int) ®s
) < 0)
279 perror_with_name (_("Couldn't write registers"));
284 static void fetch_regs (struct regcache
*regcache
, int tid
) {}
285 static void store_regs (const struct regcache
*regcache
, int tid
, int regno
) {}
290 /* Transfering floating-point registers between GDB, inferiors and cores. */
292 /* Fill GDB's register array with the floating-point register values in
296 supply_fpregset (struct regcache
*regcache
, const elf_fpregset_t
*fpregsetp
)
298 i387_supply_fsave (regcache
, -1, fpregsetp
);
301 /* Fill register REGNO (if it is a floating-point register) in
302 *FPREGSETP with the value in GDB's register array. If REGNO is -1,
303 do this for all registers. */
306 fill_fpregset (const struct regcache
*regcache
,
307 elf_fpregset_t
*fpregsetp
, int regno
)
309 i387_collect_fsave (regcache
, regno
, fpregsetp
);
312 #ifdef HAVE_PTRACE_GETREGS
314 /* Fetch all floating-point registers from process/thread TID and store
315 thier values in GDB's register array. */
318 fetch_fpregs (struct regcache
*regcache
, int tid
)
320 elf_fpregset_t fpregs
;
322 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (int) &fpregs
) < 0)
323 perror_with_name (_("Couldn't get floating point status"));
325 supply_fpregset (regcache
, (const elf_fpregset_t
*) &fpregs
);
328 /* Store all valid floating-point registers in GDB's register array
329 into the process/thread specified by TID. */
332 store_fpregs (const struct regcache
*regcache
, int tid
, int regno
)
334 elf_fpregset_t fpregs
;
336 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (int) &fpregs
) < 0)
337 perror_with_name (_("Couldn't get floating point status"));
339 fill_fpregset (regcache
, &fpregs
, regno
);
341 if (ptrace (PTRACE_SETFPREGS
, tid
, 0, (int) &fpregs
) < 0)
342 perror_with_name (_("Couldn't write floating point status"));
347 static void fetch_fpregs (struct regcache
*regcache
, int tid
) {}
348 static void store_fpregs (const struct regcache
*regcache
, int tid
, int regno
) {}
353 /* Transfering floating-point and SSE registers to and from GDB. */
355 #ifdef HAVE_PTRACE_GETFPXREGS
357 /* Fill GDB's register array with the floating-point and SSE register
358 values in *FPXREGSETP. */
361 supply_fpxregset (struct regcache
*regcache
,
362 const elf_fpxregset_t
*fpxregsetp
)
364 i387_supply_fxsave (regcache
, -1, fpxregsetp
);
367 /* Fill register REGNO (if it is a floating-point or SSE register) in
368 *FPXREGSETP with the value in GDB's register array. If REGNO is
369 -1, do this for all registers. */
372 fill_fpxregset (const struct regcache
*regcache
,
373 elf_fpxregset_t
*fpxregsetp
, int regno
)
375 i387_collect_fxsave (regcache
, regno
, fpxregsetp
);
378 /* Fetch all registers covered by the PTRACE_GETFPXREGS request from
379 process/thread TID and store their values in GDB's register array.
380 Return non-zero if successful, zero otherwise. */
383 fetch_fpxregs (struct regcache
*regcache
, int tid
)
385 elf_fpxregset_t fpxregs
;
387 if (! have_ptrace_getfpxregs
)
390 if (ptrace (PTRACE_GETFPXREGS
, tid
, 0, (int) &fpxregs
) < 0)
394 have_ptrace_getfpxregs
= 0;
398 perror_with_name (_("Couldn't read floating-point and SSE registers"));
401 supply_fpxregset (regcache
, (const elf_fpxregset_t
*) &fpxregs
);
405 /* Store all valid registers in GDB's register array covered by the
406 PTRACE_SETFPXREGS request into the process/thread specified by TID.
407 Return non-zero if successful, zero otherwise. */
410 store_fpxregs (const struct regcache
*regcache
, int tid
, int regno
)
412 elf_fpxregset_t fpxregs
;
414 if (! have_ptrace_getfpxregs
)
417 if (ptrace (PTRACE_GETFPXREGS
, tid
, 0, &fpxregs
) == -1)
421 have_ptrace_getfpxregs
= 0;
425 perror_with_name (_("Couldn't read floating-point and SSE registers"));
428 fill_fpxregset (regcache
, &fpxregs
, regno
);
430 if (ptrace (PTRACE_SETFPXREGS
, tid
, 0, &fpxregs
) == -1)
431 perror_with_name (_("Couldn't write floating-point and SSE registers"));
438 static int fetch_fpxregs (struct regcache
*regcache
, int tid
) { return 0; }
439 static int store_fpxregs (const struct regcache
*regcache
, int tid
, int regno
) { return 0; }
441 #endif /* HAVE_PTRACE_GETFPXREGS */
444 /* Transferring arbitrary registers between GDB and inferior. */
446 /* Fetch register REGNO from the child process. If REGNO is -1, do
447 this for all registers (including the floating point and SSE
451 i386_linux_fetch_inferior_registers (struct regcache
*regcache
, int regno
)
455 /* Use the old method of peeking around in `struct user' if the
456 GETREGS request isn't available. */
457 if (!have_ptrace_getregs
)
461 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
462 if (regno
== -1 || regno
== i
)
463 fetch_register (regcache
, i
);
468 /* GNU/Linux LWP ID's are process ID's. */
469 tid
= TIDGET (inferior_ptid
);
471 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
473 /* Use the PTRACE_GETFPXREGS request whenever possible, since it
474 transfers more registers in one system call, and we'll cache the
475 results. But remember that fetch_fpxregs can fail, and return
479 fetch_regs (regcache
, tid
);
481 /* The call above might reset `have_ptrace_getregs'. */
482 if (!have_ptrace_getregs
)
484 i386_linux_fetch_inferior_registers (regcache
, regno
);
488 if (fetch_fpxregs (regcache
, tid
))
490 fetch_fpregs (regcache
, tid
);
494 if (GETREGS_SUPPLIES (regno
))
496 fetch_regs (regcache
, tid
);
500 if (GETFPXREGS_SUPPLIES (regno
))
502 if (fetch_fpxregs (regcache
, tid
))
505 /* Either our processor or our kernel doesn't support the SSE
506 registers, so read the FP registers in the traditional way,
507 and fill the SSE registers with dummy values. It would be
508 more graceful to handle differences in the register set using
509 gdbarch. Until then, this will at least make things work
511 fetch_fpregs (regcache
, tid
);
515 internal_error (__FILE__
, __LINE__
,
516 _("Got request for bad register number %d."), regno
);
519 /* Store register REGNO back into the child process. If REGNO is -1,
520 do this for all registers (including the floating point and SSE
523 i386_linux_store_inferior_registers (struct regcache
*regcache
, int regno
)
527 /* Use the old method of poking around in `struct user' if the
528 SETREGS request isn't available. */
529 if (!have_ptrace_getregs
)
533 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
534 if (regno
== -1 || regno
== i
)
535 store_register (regcache
, i
);
540 /* GNU/Linux LWP ID's are process ID's. */
541 tid
= TIDGET (inferior_ptid
);
543 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
545 /* Use the PTRACE_SETFPXREGS requests whenever possible, since it
546 transfers more registers in one system call. But remember that
547 store_fpxregs can fail, and return zero. */
550 store_regs (regcache
, tid
, regno
);
551 if (store_fpxregs (regcache
, tid
, regno
))
553 store_fpregs (regcache
, tid
, regno
);
557 if (GETREGS_SUPPLIES (regno
))
559 store_regs (regcache
, tid
, regno
);
563 if (GETFPXREGS_SUPPLIES (regno
))
565 if (store_fpxregs (regcache
, tid
, regno
))
568 /* Either our processor or our kernel doesn't support the SSE
569 registers, so just write the FP registers in the traditional
571 store_fpregs (regcache
, tid
, regno
);
575 internal_error (__FILE__
, __LINE__
,
576 _("Got request to store bad register number %d."), regno
);
580 /* Support for debug registers. */
583 i386_linux_dr_get (int regnum
)
588 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
589 multi-threaded processes here. For now, pretend there is just
591 tid
= PIDGET (inferior_ptid
);
593 /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
594 ptrace call fails breaks debugging remote targets. The correct
595 way to fix this is to add the hardware breakpoint and watchpoint
596 stuff to the target vector. For now, just return zero if the
597 ptrace call fails. */
599 value
= ptrace (PTRACE_PEEKUSER
, tid
,
600 offsetof (struct user
, u_debugreg
[regnum
]), 0);
603 perror_with_name (_("Couldn't read debug register"));
612 i386_linux_dr_set (int regnum
, unsigned long value
)
616 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
617 multi-threaded processes here. For now, pretend there is just
619 tid
= PIDGET (inferior_ptid
);
622 ptrace (PTRACE_POKEUSER
, tid
,
623 offsetof (struct user
, u_debugreg
[regnum
]), value
);
625 perror_with_name (_("Couldn't write debug register"));
629 i386_linux_dr_set_control (unsigned long control
)
631 i386_linux_dr_set (DR_CONTROL
, control
);
635 i386_linux_dr_set_addr (int regnum
, CORE_ADDR addr
)
637 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
639 i386_linux_dr_set (DR_FIRSTADDR
+ regnum
, addr
);
643 i386_linux_dr_reset_addr (int regnum
)
645 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
647 i386_linux_dr_set (DR_FIRSTADDR
+ regnum
, 0L);
651 i386_linux_dr_get_status (void)
653 return i386_linux_dr_get (DR_STATUS
);
657 /* Called by libthread_db. Returns a pointer to the thread local
658 storage (or its descriptor). */
661 ps_get_thread_area (const struct ps_prochandle
*ph
,
662 lwpid_t lwpid
, int idx
, void **base
)
664 /* NOTE: cagney/2003-08-26: The definition of this buffer is found
665 in the kernel header <asm-i386/ldt.h>. It, after padding, is 4 x
666 4 byte integers in size: `entry_number', `base_addr', `limit',
667 and a bunch of status bits.
669 The values returned by this ptrace call should be part of the
670 regcache buffer, and ps_get_thread_area should channel its
671 request through the regcache. That way remote targets could
672 provide the value using the remote protocol and not this direct
675 Is this function needed? I'm guessing that the `base' is the
676 address of a a descriptor that libthread_db uses to find the
677 thread local address base that GDB needs. Perhaps that
678 descriptor is defined by the ABI. Anyway, given that
679 libthread_db calls this function without prompting (gdb
680 requesting tls base) I guess it needs info in there anyway. */
681 unsigned int desc
[4];
682 gdb_assert (sizeof (int) == 4);
684 #ifndef PTRACE_GET_THREAD_AREA
685 #define PTRACE_GET_THREAD_AREA 25
688 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
,
689 (void *) idx
, (unsigned long) &desc
) < 0)
692 *(int *)base
= desc
[1];
697 /* The instruction for a GNU/Linux system call is:
701 static const unsigned char linux_syscall
[] = { 0xcd, 0x80 };
703 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
705 /* The system call number is stored in the %eax register. */
706 #define LINUX_SYSCALL_REGNUM I386_EAX_REGNUM
708 /* We are specifically interested in the sigreturn and rt_sigreturn
711 #ifndef SYS_sigreturn
712 #define SYS_sigreturn 0x77
714 #ifndef SYS_rt_sigreturn
715 #define SYS_rt_sigreturn 0xad
718 /* Offset to saved processor flags, from <asm/sigcontext.h>. */
719 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
721 /* Resume execution of the inferior process.
722 If STEP is nonzero, single-step it.
723 If SIGNAL is nonzero, give it that signal. */
726 i386_linux_resume (ptid_t ptid
, int step
, enum target_signal signal
)
728 int pid
= PIDGET (ptid
);
730 int request
= PTRACE_CONT
;
733 /* Resume all threads. */
734 /* I think this only gets used in the non-threaded case, where "resume
735 all threads" and "resume inferior_ptid" are the same. */
736 pid
= PIDGET (inferior_ptid
);
740 struct regcache
*regcache
= get_thread_regcache (pid_to_ptid (pid
));
742 gdb_byte buf
[LINUX_SYSCALL_LEN
];
744 request
= PTRACE_SINGLESTEP
;
746 regcache_cooked_read_unsigned (regcache
,
747 gdbarch_pc_regnum (current_gdbarch
), &pc
);
749 /* Returning from a signal trampoline is done by calling a
750 special system call (sigreturn or rt_sigreturn, see
751 i386-linux-tdep.c for more information). This system call
752 restores the registers that were saved when the signal was
753 raised, including %eflags. That means that single-stepping
754 won't work. Instead, we'll have to modify the signal context
755 that's about to be restored, and set the trace flag there. */
757 /* First check if PC is at a system call. */
758 if (read_memory_nobpt (pc
, buf
, LINUX_SYSCALL_LEN
) == 0
759 && memcmp (buf
, linux_syscall
, LINUX_SYSCALL_LEN
) == 0)
762 regcache_cooked_read_unsigned (regcache
,
763 LINUX_SYSCALL_REGNUM
, &syscall
);
765 /* Then check the system call number. */
766 if (syscall
== SYS_sigreturn
|| syscall
== SYS_rt_sigreturn
)
769 unsigned long int eflags
;
771 regcache_cooked_read_unsigned (regcache
, I386_ESP_REGNUM
, &sp
);
772 if (syscall
== SYS_rt_sigreturn
)
773 addr
= read_memory_integer (sp
+ 8, 4) + 20;
777 /* Set the trace flag in the context that's about to be
779 addr
+= LINUX_SIGCONTEXT_EFLAGS_OFFSET
;
780 read_memory (addr
, (gdb_byte
*) &eflags
, 4);
782 write_memory (addr
, (gdb_byte
*) &eflags
, 4);
787 if (ptrace (request
, pid
, 0, target_signal_to_host (signal
)) == -1)
788 perror_with_name (("ptrace"));
791 static void (*super_post_startup_inferior
) (ptid_t ptid
);
794 i386_linux_child_post_startup_inferior (ptid_t ptid
)
796 i386_cleanup_dregs ();
797 super_post_startup_inferior (ptid
);
801 _initialize_i386_linux_nat (void)
803 struct target_ops
*t
;
805 /* Fill in the generic GNU/Linux methods. */
808 /* Override the default ptrace resume method. */
809 t
->to_resume
= i386_linux_resume
;
811 /* Override the GNU/Linux inferior startup hook. */
812 super_post_startup_inferior
= t
->to_post_startup_inferior
;
813 t
->to_post_startup_inferior
= i386_linux_child_post_startup_inferior
;
815 /* Add our register access methods. */
816 t
->to_fetch_registers
= i386_linux_fetch_inferior_registers
;
817 t
->to_store_registers
= i386_linux_store_inferior_registers
;
819 /* Register the target. */
820 linux_nat_add_target (t
);