1 /* Native-dependent code for GNU/Linux x86.
3 Copyright 1999, 2000, 2001, 2002 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 2 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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
27 #include "gdb_assert.h"
28 #include "gdb_string.h"
29 #include <sys/ptrace.h>
31 #include <sys/procfs.h>
37 #ifdef HAVE_SYS_DEBUGREG_H
38 #include <sys/debugreg.h>
42 #define DR_FIRSTADDR 0
57 /* Prototypes for supply_gregset etc. */
60 /* Prototypes for i387_supply_fsave etc. */
61 #include "i387-tdep.h"
63 /* Defines for XMM0_REGNUM etc. */
64 #include "i386-tdep.h"
66 /* Defines I386_LINUX_ORIG_EAX_REGNUM. */
67 #include "i386-linux-tdep.h"
69 /* Prototypes for local functions. */
70 static void dummy_sse_values (void);
74 /* The register sets used in GNU/Linux ELF core-dumps are identical to
75 the register sets in `struct user' that is used for a.out
76 core-dumps, and is also used by `ptrace'. The corresponding types
77 are `elf_gregset_t' for the general-purpose registers (with
78 `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
79 for the floating-point registers.
81 Those types used to be available under the names `gregset_t' and
82 `fpregset_t' too, and this file used those names in the past. But
83 those names are now used for the register sets used in the
84 `mcontext_t' type, and have a different size and layout. */
86 /* Mapping between the general-purpose registers in `struct user'
87 format and GDB's register array layout. */
96 /* Which ptrace request retrieves which registers?
97 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)
100 #define GETFPREGS_SUPPLIES(regno) \
101 (FP0_REGNUM <= (regno) && (regno) <= LAST_FPU_CTRL_REGNUM)
102 #define GETFPXREGS_SUPPLIES(regno) \
103 (FP0_REGNUM <= (regno) && (regno) <= MXCSR_REGNUM)
105 /* Does the current host support the GETREGS request? */
106 int have_ptrace_getregs
=
107 #ifdef HAVE_PTRACE_GETREGS
114 /* Does the current host support the GETFPXREGS request? The header
115 file may or may not define it, and even if it is defined, the
116 kernel will return EIO if it's running on a pre-SSE processor.
118 My instinct is to attach this to some architecture- or
119 target-specific data structure, but really, a particular GDB
120 process can only run on top of one kernel at a time. So it's okay
121 for this to be a simple variable. */
122 int have_ptrace_getfpxregs
=
123 #ifdef HAVE_PTRACE_GETFPXREGS
131 /* Support for the user struct. */
133 /* Return the address of register REGNUM. BLOCKEND is the value of
134 u.u_ar0, which should point to the registers. */
137 register_u_addr (CORE_ADDR blockend
, int regnum
)
139 return (blockend
+ 4 * regmap
[regnum
]);
142 /* Return the size of the user struct. */
147 return (sizeof (struct user
));
151 /* Fetching registers directly from the U area, one at a time. */
153 /* FIXME: kettenis/2000-03-05: This duplicates code from `inptrace.c'.
154 The problem is that we define FETCH_INFERIOR_REGISTERS since we
155 want to use our own versions of {fetch,store}_inferior_registers
156 that use the GETREGS request. This means that the code in
157 `infptrace.c' is #ifdef'd out. But we need to fall back on that
158 code when GDB is running on top of a kernel that doesn't support
159 the GETREGS request. I want to avoid changing `infptrace.c' right
163 #define PT_READ_U PTRACE_PEEKUSR
166 #define PT_WRITE_U PTRACE_POKEUSR
169 /* Default the type of the ptrace transfer to int. */
170 #ifndef PTRACE_XFER_TYPE
171 #define PTRACE_XFER_TYPE int
174 /* Registers we shouldn't try to fetch. */
175 #define OLD_CANNOT_FETCH_REGISTER(regno) ((regno) >= I386_NUM_GREGS)
177 /* Fetch one register. */
180 fetch_register (int regno
)
182 /* This isn't really an address. But ptrace thinks of it as one. */
184 char mess
[128]; /* For messages */
186 unsigned int offset
; /* Offset of registers within the u area. */
187 char buf
[MAX_REGISTER_RAW_SIZE
];
190 if (OLD_CANNOT_FETCH_REGISTER (regno
))
192 memset (buf
, '\0', REGISTER_RAW_SIZE (regno
)); /* Supply zeroes */
193 supply_register (regno
, buf
);
197 /* Overload thread id onto process id */
198 if ((tid
= TIDGET (inferior_ptid
)) == 0)
199 tid
= PIDGET (inferior_ptid
); /* no thread id, just use process id */
201 offset
= U_REGS_OFFSET
;
203 regaddr
= register_addr (regno
, offset
);
204 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
207 *(PTRACE_XFER_TYPE
*) & buf
[i
] = ptrace (PT_READ_U
, tid
,
208 (PTRACE_ARG3_TYPE
) regaddr
, 0);
209 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
212 sprintf (mess
, "reading register %s (#%d)",
213 REGISTER_NAME (regno
), regno
);
214 perror_with_name (mess
);
217 supply_register (regno
, buf
);
220 /* Fetch register values from the inferior.
221 If REGNO is negative, do this for all registers.
222 Otherwise, REGNO specifies which register (so we can save time). */
225 old_fetch_inferior_registers (int regno
)
229 fetch_register (regno
);
233 for (regno
= 0; regno
< NUM_REGS
; regno
++)
235 fetch_register (regno
);
240 /* Registers we shouldn't try to store. */
241 #define OLD_CANNOT_STORE_REGISTER(regno) ((regno) >= I386_NUM_GREGS)
243 /* Store one register. */
246 store_register (int regno
)
248 /* This isn't really an address. But ptrace thinks of it as one. */
250 char mess
[128]; /* For messages */
252 unsigned int offset
; /* Offset of registers within the u area. */
255 if (OLD_CANNOT_STORE_REGISTER (regno
))
260 /* Overload thread id onto process id */
261 if ((tid
= TIDGET (inferior_ptid
)) == 0)
262 tid
= PIDGET (inferior_ptid
); /* no thread id, just use process id */
264 offset
= U_REGS_OFFSET
;
266 regaddr
= register_addr (regno
, offset
);
267 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
270 ptrace (PT_WRITE_U
, tid
, (PTRACE_ARG3_TYPE
) regaddr
,
271 *(PTRACE_XFER_TYPE
*) & registers
[REGISTER_BYTE (regno
) + i
]);
272 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
275 sprintf (mess
, "writing register %s (#%d)",
276 REGISTER_NAME (regno
), regno
);
277 perror_with_name (mess
);
282 /* Store our register values back into the inferior.
283 If REGNO is negative, do this for all registers.
284 Otherwise, REGNO specifies which register (so we can save time). */
287 old_store_inferior_registers (int regno
)
291 store_register (regno
);
295 for (regno
= 0; regno
< NUM_REGS
; regno
++)
297 store_register (regno
);
303 /* Transfering the general-purpose registers between GDB, inferiors
306 /* Fill GDB's register array with the general-purpose register values
310 supply_gregset (elf_gregset_t
*gregsetp
)
312 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
315 for (i
= 0; i
< I386_NUM_GREGS
; i
++)
316 supply_register (i
, (char *) (regp
+ regmap
[i
]));
318 if (I386_LINUX_ORIG_EAX_REGNUM
< NUM_REGS
)
319 supply_register (I386_LINUX_ORIG_EAX_REGNUM
, (char *) (regp
+ ORIG_EAX
));
322 /* Fill register REGNO (if it is a general-purpose register) in
323 *GREGSETPS with the value in GDB's register array. If REGNO is -1,
324 do this for all registers. */
327 fill_gregset (elf_gregset_t
*gregsetp
, int regno
)
329 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
332 for (i
= 0; i
< I386_NUM_GREGS
; i
++)
333 if (regno
== -1 || regno
== i
)
334 regcache_collect (i
, regp
+ regmap
[i
]);
336 if ((regno
== -1 || regno
== I386_LINUX_ORIG_EAX_REGNUM
)
337 && I386_LINUX_ORIG_EAX_REGNUM
< NUM_REGS
)
338 regcache_collect (I386_LINUX_ORIG_EAX_REGNUM
, regp
+ ORIG_EAX
);
341 #ifdef HAVE_PTRACE_GETREGS
343 /* Fetch all general-purpose registers from process/thread TID and
344 store their values in GDB's register array. */
351 if (ptrace (PTRACE_GETREGS
, tid
, 0, (int) ®s
) < 0)
355 /* The kernel we're running on doesn't support the GETREGS
356 request. Reset `have_ptrace_getregs'. */
357 have_ptrace_getregs
= 0;
361 perror_with_name ("Couldn't get registers");
364 supply_gregset (®s
);
367 /* Store all valid general-purpose registers in GDB's register array
368 into the process/thread specified by TID. */
371 store_regs (int tid
, int regno
)
375 if (ptrace (PTRACE_GETREGS
, tid
, 0, (int) ®s
) < 0)
376 perror_with_name ("Couldn't get registers");
378 fill_gregset (®s
, regno
);
380 if (ptrace (PTRACE_SETREGS
, tid
, 0, (int) ®s
) < 0)
381 perror_with_name ("Couldn't write registers");
386 static void fetch_regs (int tid
) {}
387 static void store_regs (int tid
, int regno
) {}
392 /* Transfering floating-point registers between GDB, inferiors and cores. */
394 /* Fill GDB's register array with the floating-point register values in
398 supply_fpregset (elf_fpregset_t
*fpregsetp
)
400 i387_supply_fsave ((char *) fpregsetp
);
404 /* Fill register REGNO (if it is a floating-point register) in
405 *FPREGSETP with the value in GDB's register array. If REGNO is -1,
406 do this for all registers. */
409 fill_fpregset (elf_fpregset_t
*fpregsetp
, int regno
)
411 i387_fill_fsave ((char *) fpregsetp
, regno
);
414 #ifdef HAVE_PTRACE_GETREGS
416 /* Fetch all floating-point registers from process/thread TID and store
417 thier values in GDB's register array. */
420 fetch_fpregs (int tid
)
422 elf_fpregset_t fpregs
;
424 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (int) &fpregs
) < 0)
425 perror_with_name ("Couldn't get floating point status");
427 supply_fpregset (&fpregs
);
430 /* Store all valid floating-point registers in GDB's register array
431 into the process/thread specified by TID. */
434 store_fpregs (int tid
, int regno
)
436 elf_fpregset_t fpregs
;
438 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (int) &fpregs
) < 0)
439 perror_with_name ("Couldn't get floating point status");
441 fill_fpregset (&fpregs
, regno
);
443 if (ptrace (PTRACE_SETFPREGS
, tid
, 0, (int) &fpregs
) < 0)
444 perror_with_name ("Couldn't write floating point status");
449 static void fetch_fpregs (int tid
) {}
450 static void store_fpregs (int tid
, int regno
) {}
455 /* Transfering floating-point and SSE registers to and from GDB. */
457 #ifdef HAVE_PTRACE_GETFPXREGS
459 /* Fill GDB's register array with the floating-point and SSE register
460 values in *FPXREGSETP. */
463 supply_fpxregset (elf_fpxregset_t
*fpxregsetp
)
465 i387_supply_fxsave ((char *) fpxregsetp
);
468 /* Fill register REGNO (if it is a floating-point or SSE register) in
469 *FPXREGSETP with the value in GDB's register array. If REGNO is
470 -1, do this for all registers. */
473 fill_fpxregset (elf_fpxregset_t
*fpxregsetp
, int regno
)
475 i387_fill_fxsave ((char *) fpxregsetp
, regno
);
478 /* Fetch all registers covered by the PTRACE_GETFPXREGS request from
479 process/thread TID and store their values in GDB's register array.
480 Return non-zero if successful, zero otherwise. */
483 fetch_fpxregs (int tid
)
485 elf_fpxregset_t fpxregs
;
487 if (! have_ptrace_getfpxregs
)
490 if (ptrace (PTRACE_GETFPXREGS
, tid
, 0, (int) &fpxregs
) < 0)
494 have_ptrace_getfpxregs
= 0;
498 perror_with_name ("Couldn't read floating-point and SSE registers");
501 supply_fpxregset (&fpxregs
);
505 /* Store all valid registers in GDB's register array covered by the
506 PTRACE_SETFPXREGS request into the process/thread specified by TID.
507 Return non-zero if successful, zero otherwise. */
510 store_fpxregs (int tid
, int regno
)
512 elf_fpxregset_t fpxregs
;
514 if (! have_ptrace_getfpxregs
)
517 if (ptrace (PTRACE_GETFPXREGS
, tid
, 0, &fpxregs
) == -1)
521 have_ptrace_getfpxregs
= 0;
525 perror_with_name ("Couldn't read floating-point and SSE registers");
528 fill_fpxregset (&fpxregs
, regno
);
530 if (ptrace (PTRACE_SETFPXREGS
, tid
, 0, &fpxregs
) == -1)
531 perror_with_name ("Couldn't write floating-point and SSE registers");
536 /* Fill the XMM registers in the register array with dummy values. For
537 cases where we don't have access to the XMM registers. I think
538 this is cleaner than printing a warning. For a cleaner solution,
539 we should gdbarchify the i386 family. */
542 dummy_sse_values (void)
544 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
545 /* C doesn't have a syntax for NaN's, so write it out as an array of
547 static long dummy
[4] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff };
548 static long mxcsr
= 0x1f80;
551 for (reg
= 0; reg
< tdep
->num_xmm_regs
; reg
++)
552 supply_register (XMM0_REGNUM
+ reg
, (char *) dummy
);
553 if (tdep
->num_xmm_regs
> 0)
554 supply_register (MXCSR_REGNUM
, (char *) &mxcsr
);
559 static int fetch_fpxregs (int tid
) { return 0; }
560 static int store_fpxregs (int tid
, int regno
) { return 0; }
561 static void dummy_sse_values (void) {}
563 #endif /* HAVE_PTRACE_GETFPXREGS */
566 /* Transferring arbitrary registers between GDB and inferior. */
568 /* Check if register REGNO in the child process is accessible.
569 If we are accessing registers directly via the U area, only the
570 general-purpose registers are available.
571 All registers should be accessible if we have GETREGS support. */
574 cannot_fetch_register (int regno
)
576 if (! have_ptrace_getregs
)
577 return OLD_CANNOT_FETCH_REGISTER (regno
);
581 cannot_store_register (int regno
)
583 if (! have_ptrace_getregs
)
584 return OLD_CANNOT_STORE_REGISTER (regno
);
588 /* Fetch register REGNO from the child process. If REGNO is -1, do
589 this for all registers (including the floating point and SSE
593 fetch_inferior_registers (int regno
)
597 /* Use the old method of peeking around in `struct user' if the
598 GETREGS request isn't available. */
599 if (! have_ptrace_getregs
)
601 old_fetch_inferior_registers (regno
);
605 /* GNU/Linux LWP ID's are process ID's. */
606 if ((tid
= TIDGET (inferior_ptid
)) == 0)
607 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
609 /* Use the PTRACE_GETFPXREGS request whenever possible, since it
610 transfers more registers in one system call, and we'll cache the
611 results. But remember that fetch_fpxregs can fail, and return
617 /* The call above might reset `have_ptrace_getregs'. */
618 if (! have_ptrace_getregs
)
620 old_fetch_inferior_registers (-1);
624 if (fetch_fpxregs (tid
))
630 if (GETREGS_SUPPLIES (regno
))
636 if (GETFPXREGS_SUPPLIES (regno
))
638 if (fetch_fpxregs (tid
))
641 /* Either our processor or our kernel doesn't support the SSE
642 registers, so read the FP registers in the traditional way,
643 and fill the SSE registers with dummy values. It would be
644 more graceful to handle differences in the register set using
645 gdbarch. Until then, this will at least make things work
651 internal_error (__FILE__
, __LINE__
,
652 "Got request for bad register number %d.", regno
);
655 /* Store register REGNO back into the child process. If REGNO is -1,
656 do this for all registers (including the floating point and SSE
659 store_inferior_registers (int regno
)
663 /* Use the old method of poking around in `struct user' if the
664 SETREGS request isn't available. */
665 if (! have_ptrace_getregs
)
667 old_store_inferior_registers (regno
);
671 /* GNU/Linux LWP ID's are process ID's. */
672 if ((tid
= TIDGET (inferior_ptid
)) == 0)
673 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
675 /* Use the PTRACE_SETFPXREGS requests whenever possible, since it
676 transfers more registers in one system call. But remember that
677 store_fpxregs can fail, and return zero. */
680 store_regs (tid
, regno
);
681 if (store_fpxregs (tid
, regno
))
683 store_fpregs (tid
, regno
);
687 if (GETREGS_SUPPLIES (regno
))
689 store_regs (tid
, regno
);
693 if (GETFPXREGS_SUPPLIES (regno
))
695 if (store_fpxregs (tid
, regno
))
698 /* Either our processor or our kernel doesn't support the SSE
699 registers, so just write the FP registers in the traditional
701 store_fpregs (tid
, regno
);
705 internal_error (__FILE__
, __LINE__
,
706 "Got request to store bad register number %d.", regno
);
711 i386_linux_dr_get (int regnum
)
716 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
717 multi-threaded processes here. For now, pretend there is just
719 tid
= PIDGET (inferior_ptid
);
721 /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
722 ptrace call fails breaks debugging remote targets. The correct
723 way to fix this is to add the hardware breakpoint and watchpoint
724 stuff to the target vectore. For now, just return zero if the
725 ptrace call fails. */
727 value
= ptrace (PT_READ_U
, tid
,
728 offsetof (struct user
, u_debugreg
[regnum
]), 0);
731 perror_with_name ("Couldn't read debug register");
740 i386_linux_dr_set (int regnum
, unsigned long value
)
744 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
745 multi-threaded processes here. For now, pretend there is just
747 tid
= PIDGET (inferior_ptid
);
750 ptrace (PT_WRITE_U
, tid
,
751 offsetof (struct user
, u_debugreg
[regnum
]), value
);
753 perror_with_name ("Couldn't write debug register");
757 i386_linux_dr_set_control (unsigned long control
)
759 i386_linux_dr_set (DR_CONTROL
, control
);
763 i386_linux_dr_set_addr (int regnum
, CORE_ADDR addr
)
765 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
767 i386_linux_dr_set (DR_FIRSTADDR
+ regnum
, addr
);
771 i386_linux_dr_reset_addr (int regnum
)
773 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
775 i386_linux_dr_set (DR_FIRSTADDR
+ regnum
, 0L);
779 i386_linux_dr_get_status (void)
781 return i386_linux_dr_get (DR_STATUS
);
785 /* Interpreting register set info found in core files. */
787 /* Provide registers to GDB from a core file.
789 (We can't use the generic version of this function in
790 core-regset.c, because GNU/Linux has *three* different kinds of
791 register set notes. core-regset.c would have to call
792 supply_fpxregset, which most platforms don't have.)
794 CORE_REG_SECT points to an array of bytes, which are the contents
795 of a `note' from a core file which BFD thinks might contain
796 register contents. CORE_REG_SIZE is its size.
798 WHICH says which register set corelow suspects this is:
799 0 --- the general-purpose register set, in elf_gregset_t format
800 2 --- the floating-point register set, in elf_fpregset_t format
801 3 --- the extended floating-point register set, in elf_fpxregset_t format
803 REG_ADDR isn't used on GNU/Linux. */
806 fetch_core_registers (char *core_reg_sect
, unsigned core_reg_size
,
807 int which
, CORE_ADDR reg_addr
)
809 elf_gregset_t gregset
;
810 elf_fpregset_t fpregset
;
815 if (core_reg_size
!= sizeof (gregset
))
816 warning ("Wrong size gregset in core file.");
819 memcpy (&gregset
, core_reg_sect
, sizeof (gregset
));
820 supply_gregset (&gregset
);
825 if (core_reg_size
!= sizeof (fpregset
))
826 warning ("Wrong size fpregset in core file.");
829 memcpy (&fpregset
, core_reg_sect
, sizeof (fpregset
));
830 supply_fpregset (&fpregset
);
834 #ifdef HAVE_PTRACE_GETFPXREGS
836 elf_fpxregset_t fpxregset
;
839 if (core_reg_size
!= sizeof (fpxregset
))
840 warning ("Wrong size fpxregset in core file.");
843 memcpy (&fpxregset
, core_reg_sect
, sizeof (fpxregset
));
844 supply_fpxregset (&fpxregset
);
851 /* We've covered all the kinds of registers we know about here,
852 so this must be something we wouldn't know what to do with
853 anyway. Just ignore it. */
859 /* The instruction for a GNU/Linux system call is:
863 static const unsigned char linux_syscall
[] = { 0xcd, 0x80 };
865 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
867 /* The system call number is stored in the %eax register. */
868 #define LINUX_SYSCALL_REGNUM 0 /* %eax */
870 /* We are specifically interested in the sigreturn and rt_sigreturn
873 #ifndef SYS_sigreturn
874 #define SYS_sigreturn 0x77
876 #ifndef SYS_rt_sigreturn
877 #define SYS_rt_sigreturn 0xad
880 /* Offset to saved processor flags, from <asm/sigcontext.h>. */
881 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
883 /* Resume execution of the inferior process.
884 If STEP is nonzero, single-step it.
885 If SIGNAL is nonzero, give it that signal. */
888 child_resume (ptid_t ptid
, int step
, enum target_signal signal
)
890 int pid
= PIDGET (ptid
);
892 int request
= PTRACE_CONT
;
895 /* Resume all threads. */
896 /* I think this only gets used in the non-threaded case, where "resume
897 all threads" and "resume inferior_ptid" are the same. */
898 pid
= PIDGET (inferior_ptid
);
902 CORE_ADDR pc
= read_pc_pid (pid_to_ptid (pid
));
903 unsigned char buf
[LINUX_SYSCALL_LEN
];
905 request
= PTRACE_SINGLESTEP
;
907 /* Returning from a signal trampoline is done by calling a
908 special system call (sigreturn or rt_sigreturn, see
909 i386-linux-tdep.c for more information). This system call
910 restores the registers that were saved when the signal was
911 raised, including %eflags. That means that single-stepping
912 won't work. Instead, we'll have to modify the signal context
913 that's about to be restored, and set the trace flag there. */
915 /* First check if PC is at a system call. */
916 if (read_memory_nobpt (pc
, (char *) buf
, LINUX_SYSCALL_LEN
) == 0
917 && memcmp (buf
, linux_syscall
, LINUX_SYSCALL_LEN
) == 0)
919 int syscall
= read_register_pid (LINUX_SYSCALL_REGNUM
,
922 /* Then check the system call number. */
923 if (syscall
== SYS_sigreturn
|| syscall
== SYS_rt_sigreturn
)
925 CORE_ADDR sp
= read_register (SP_REGNUM
);
927 unsigned long int eflags
;
929 if (syscall
== SYS_rt_sigreturn
)
930 addr
= read_memory_integer (sp
+ 8, 4) + 20;
932 /* Set the trace flag in the context that's about to be
934 addr
+= LINUX_SIGCONTEXT_EFLAGS_OFFSET
;
935 read_memory (addr
, (char *) &eflags
, 4);
937 write_memory (addr
, (char *) &eflags
, 4);
942 if (ptrace (request
, pid
, 0, target_signal_to_host (signal
)) == -1)
943 perror_with_name ("ptrace");
947 /* Register that we are able to handle GNU/Linux ELF core file
950 static struct core_fns linux_elf_core_fns
=
952 bfd_target_elf_flavour
, /* core_flavour */
953 default_check_format
, /* check_format */
954 default_core_sniffer
, /* core_sniffer */
955 fetch_core_registers
, /* core_read_registers */
960 _initialize_i386_linux_nat (void)
962 add_core_fns (&linux_elf_core_fns
);