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 <sys/ptrace.h>
30 #include <sys/procfs.h>
36 #ifdef HAVE_SYS_DEBUGREG_H
37 #include <sys/debugreg.h>
41 #define DR_FIRSTADDR 0
56 /* Prototypes for supply_gregset etc. */
59 /* Prototypes for i387_supply_fsave etc. */
60 #include "i387-tdep.h"
62 /* Defines for XMM0_REGNUM etc. */
63 #include "i386-tdep.h"
65 /* Prototypes for local functions. */
66 static void dummy_sse_values (void);
70 /* The register sets used in GNU/Linux ELF core-dumps are identical to
71 the register sets in `struct user' that is used for a.out
72 core-dumps, and is also used by `ptrace'. The corresponding types
73 are `elf_gregset_t' for the general-purpose registers (with
74 `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
75 for the floating-point registers.
77 Those types used to be available under the names `gregset_t' and
78 `fpregset_t' too, and this file used those names in the past. But
79 those names are now used for the register sets used in the
80 `mcontext_t' type, and have a different size and layout. */
82 /* Mapping between the general-purpose registers in `struct user'
83 format and GDB's register array layout. */
92 /* Which ptrace request retrieves which registers?
93 These apply to the corresponding SET requests as well. */
94 #define GETREGS_SUPPLIES(regno) \
95 ((0 <= (regno) && (regno) <= 15) || (regno) == I386_LINUX_ORIG_EAX_REGNUM)
96 #define GETFPREGS_SUPPLIES(regno) \
97 (FP0_REGNUM <= (regno) && (regno) <= LAST_FPU_CTRL_REGNUM)
98 #define GETFPXREGS_SUPPLIES(regno) \
99 (FP0_REGNUM <= (regno) && (regno) <= MXCSR_REGNUM)
101 /* Does the current host support the GETREGS request? */
102 int have_ptrace_getregs
=
103 #ifdef HAVE_PTRACE_GETREGS
110 /* Does the current host support the GETFPXREGS request? The header
111 file may or may not define it, and even if it is defined, the
112 kernel will return EIO if it's running on a pre-SSE processor.
114 My instinct is to attach this to some architecture- or
115 target-specific data structure, but really, a particular GDB
116 process can only run on top of one kernel at a time. So it's okay
117 for this to be a simple variable. */
118 int have_ptrace_getfpxregs
=
119 #ifdef HAVE_PTRACE_GETFPXREGS
127 /* Support for the user struct. */
129 /* Return the address of register REGNUM. BLOCKEND is the value of
130 u.u_ar0, which should point to the registers. */
133 register_u_addr (CORE_ADDR blockend
, int regnum
)
135 return (blockend
+ 4 * regmap
[regnum
]);
138 /* Return the size of the user struct. */
143 return (sizeof (struct user
));
147 /* Fetching registers directly from the U area, one at a time. */
149 /* FIXME: kettenis/2000-03-05: This duplicates code from `inptrace.c'.
150 The problem is that we define FETCH_INFERIOR_REGISTERS since we
151 want to use our own versions of {fetch,store}_inferior_registers
152 that use the GETREGS request. This means that the code in
153 `infptrace.c' is #ifdef'd out. But we need to fall back on that
154 code when GDB is running on top of a kernel that doesn't support
155 the GETREGS request. I want to avoid changing `infptrace.c' right
159 #define PT_READ_U PTRACE_PEEKUSR
162 #define PT_WRITE_U PTRACE_POKEUSR
165 /* Default the type of the ptrace transfer to int. */
166 #ifndef PTRACE_XFER_TYPE
167 #define PTRACE_XFER_TYPE int
170 /* Registers we shouldn't try to fetch. */
171 #define OLD_CANNOT_FETCH_REGISTER(regno) ((regno) >= NUM_GREGS)
173 /* Fetch one register. */
176 fetch_register (int regno
)
178 /* This isn't really an address. But ptrace thinks of it as one. */
180 char mess
[128]; /* For messages */
182 unsigned int offset
; /* Offset of registers within the u area. */
183 char buf
[MAX_REGISTER_RAW_SIZE
];
186 if (OLD_CANNOT_FETCH_REGISTER (regno
))
188 memset (buf
, '\0', REGISTER_RAW_SIZE (regno
)); /* Supply zeroes */
189 supply_register (regno
, buf
);
193 /* Overload thread id onto process id */
194 if ((tid
= TIDGET (inferior_ptid
)) == 0)
195 tid
= PIDGET (inferior_ptid
); /* no thread id, just use process id */
197 offset
= U_REGS_OFFSET
;
199 regaddr
= register_addr (regno
, offset
);
200 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
203 *(PTRACE_XFER_TYPE
*) & buf
[i
] = ptrace (PT_READ_U
, tid
,
204 (PTRACE_ARG3_TYPE
) regaddr
, 0);
205 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
208 sprintf (mess
, "reading register %s (#%d)",
209 REGISTER_NAME (regno
), regno
);
210 perror_with_name (mess
);
213 supply_register (regno
, buf
);
216 /* Fetch register values from the inferior.
217 If REGNO is negative, do this for all registers.
218 Otherwise, REGNO specifies which register (so we can save time). */
221 old_fetch_inferior_registers (int regno
)
225 fetch_register (regno
);
229 for (regno
= 0; regno
< NUM_REGS
; regno
++)
231 fetch_register (regno
);
236 /* Registers we shouldn't try to store. */
237 #define OLD_CANNOT_STORE_REGISTER(regno) ((regno) >= NUM_GREGS)
239 /* Store one register. */
242 store_register (int regno
)
244 /* This isn't really an address. But ptrace thinks of it as one. */
246 char mess
[128]; /* For messages */
248 unsigned int offset
; /* Offset of registers within the u area. */
251 if (OLD_CANNOT_STORE_REGISTER (regno
))
256 /* Overload thread id onto process id */
257 if ((tid
= TIDGET (inferior_ptid
)) == 0)
258 tid
= PIDGET (inferior_ptid
); /* no thread id, just use process id */
260 offset
= U_REGS_OFFSET
;
262 regaddr
= register_addr (regno
, offset
);
263 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (PTRACE_XFER_TYPE
))
266 ptrace (PT_WRITE_U
, tid
, (PTRACE_ARG3_TYPE
) regaddr
,
267 *(PTRACE_XFER_TYPE
*) & registers
[REGISTER_BYTE (regno
) + i
]);
268 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
271 sprintf (mess
, "writing register %s (#%d)",
272 REGISTER_NAME (regno
), regno
);
273 perror_with_name (mess
);
278 /* Store our register values back into the inferior.
279 If REGNO is negative, do this for all registers.
280 Otherwise, REGNO specifies which register (so we can save time). */
283 old_store_inferior_registers (int regno
)
287 store_register (regno
);
291 for (regno
= 0; regno
< NUM_REGS
; regno
++)
293 store_register (regno
);
299 /* Transfering the general-purpose registers between GDB, inferiors
302 /* Fill GDB's register array with the general-purpose register values
306 supply_gregset (elf_gregset_t
*gregsetp
)
308 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
311 for (i
= 0; i
< NUM_GREGS
; i
++)
312 supply_register (i
, (char *) (regp
+ regmap
[i
]));
314 supply_register (I386_LINUX_ORIG_EAX_REGNUM
, (char *) (regp
+ ORIG_EAX
));
317 /* Fill register REGNO (if it is a general-purpose register) in
318 *GREGSETPS with the value in GDB's register array. If REGNO is -1,
319 do this for all registers. */
322 fill_gregset (elf_gregset_t
*gregsetp
, int regno
)
324 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
327 for (i
= 0; i
< NUM_GREGS
; i
++)
328 if ((regno
== -1 || regno
== i
))
329 regcache_collect (i
, regp
+ regmap
[i
]);
331 if (regno
== -1 || regno
== I386_LINUX_ORIG_EAX_REGNUM
)
332 regcache_collect (I386_LINUX_ORIG_EAX_REGNUM
, regp
+ ORIG_EAX
);
335 #ifdef HAVE_PTRACE_GETREGS
337 /* Fetch all general-purpose registers from process/thread TID and
338 store their values in GDB's register array. */
345 if (ptrace (PTRACE_GETREGS
, tid
, 0, (int) ®s
) < 0)
349 /* The kernel we're running on doesn't support the GETREGS
350 request. Reset `have_ptrace_getregs'. */
351 have_ptrace_getregs
= 0;
355 perror_with_name ("Couldn't get registers");
358 supply_gregset (®s
);
361 /* Store all valid general-purpose registers in GDB's register array
362 into the process/thread specified by TID. */
365 store_regs (int tid
, int regno
)
369 if (ptrace (PTRACE_GETREGS
, tid
, 0, (int) ®s
) < 0)
370 perror_with_name ("Couldn't get registers");
372 fill_gregset (®s
, regno
);
374 if (ptrace (PTRACE_SETREGS
, tid
, 0, (int) ®s
) < 0)
375 perror_with_name ("Couldn't write registers");
380 static void fetch_regs (int tid
) {}
381 static void store_regs (int tid
, int regno
) {}
386 /* Transfering floating-point registers between GDB, inferiors and cores. */
388 /* Fill GDB's register array with the floating-point register values in
392 supply_fpregset (elf_fpregset_t
*fpregsetp
)
394 i387_supply_fsave ((char *) fpregsetp
);
398 /* Fill register REGNO (if it is a floating-point register) in
399 *FPREGSETP with the value in GDB's register array. If REGNO is -1,
400 do this for all registers. */
403 fill_fpregset (elf_fpregset_t
*fpregsetp
, int regno
)
405 i387_fill_fsave ((char *) fpregsetp
, regno
);
408 #ifdef HAVE_PTRACE_GETREGS
410 /* Fetch all floating-point registers from process/thread TID and store
411 thier values in GDB's register array. */
414 fetch_fpregs (int tid
)
416 elf_fpregset_t fpregs
;
418 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (int) &fpregs
) < 0)
419 perror_with_name ("Couldn't get floating point status");
421 supply_fpregset (&fpregs
);
424 /* Store all valid floating-point registers in GDB's register array
425 into the process/thread specified by TID. */
428 store_fpregs (int tid
, int regno
)
430 elf_fpregset_t fpregs
;
432 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (int) &fpregs
) < 0)
433 perror_with_name ("Couldn't get floating point status");
435 fill_fpregset (&fpregs
, regno
);
437 if (ptrace (PTRACE_SETFPREGS
, tid
, 0, (int) &fpregs
) < 0)
438 perror_with_name ("Couldn't write floating point status");
443 static void fetch_fpregs (int tid
) {}
444 static void store_fpregs (int tid
, int regno
) {}
449 /* Transfering floating-point and SSE registers to and from GDB. */
451 #ifdef HAVE_PTRACE_GETFPXREGS
453 /* Fill GDB's register array with the floating-point and SSE register
454 values in *FPXREGSETP. */
457 supply_fpxregset (elf_fpxregset_t
*fpxregsetp
)
459 i387_supply_fxsave ((char *) fpxregsetp
);
462 /* Fill register REGNO (if it is a floating-point or SSE register) in
463 *FPXREGSETP with the value in GDB's register array. If REGNO is
464 -1, do this for all registers. */
467 fill_fpxregset (elf_fpxregset_t
*fpxregsetp
, int regno
)
469 i387_fill_fxsave ((char *) fpxregsetp
, regno
);
472 /* Fetch all registers covered by the PTRACE_GETFPXREGS request from
473 process/thread TID and store their values in GDB's register array.
474 Return non-zero if successful, zero otherwise. */
477 fetch_fpxregs (int tid
)
479 elf_fpxregset_t fpxregs
;
481 if (! have_ptrace_getfpxregs
)
484 if (ptrace (PTRACE_GETFPXREGS
, tid
, 0, (int) &fpxregs
) < 0)
488 have_ptrace_getfpxregs
= 0;
492 perror_with_name ("Couldn't read floating-point and SSE registers");
495 supply_fpxregset (&fpxregs
);
499 /* Store all valid registers in GDB's register array covered by the
500 PTRACE_SETFPXREGS request into the process/thread specified by TID.
501 Return non-zero if successful, zero otherwise. */
504 store_fpxregs (int tid
, int regno
)
506 elf_fpxregset_t fpxregs
;
508 if (! have_ptrace_getfpxregs
)
511 if (ptrace (PTRACE_GETFPXREGS
, tid
, 0, &fpxregs
) == -1)
515 have_ptrace_getfpxregs
= 0;
519 perror_with_name ("Couldn't read floating-point and SSE registers");
522 fill_fpxregset (&fpxregs
, regno
);
524 if (ptrace (PTRACE_SETFPXREGS
, tid
, 0, &fpxregs
) == -1)
525 perror_with_name ("Couldn't write floating-point and SSE registers");
530 /* Fill the XMM registers in the register array with dummy values. For
531 cases where we don't have access to the XMM registers. I think
532 this is cleaner than printing a warning. For a cleaner solution,
533 we should gdbarchify the i386 family. */
536 dummy_sse_values (void)
538 /* C doesn't have a syntax for NaN's, so write it out as an array of
540 static long dummy
[4] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff };
541 static long mxcsr
= 0x1f80;
544 for (reg
= 0; reg
< 8; reg
++)
545 supply_register (XMM0_REGNUM
+ reg
, (char *) dummy
);
546 supply_register (MXCSR_REGNUM
, (char *) &mxcsr
);
551 static int fetch_fpxregs (int tid
) { return 0; }
552 static int store_fpxregs (int tid
, int regno
) { return 0; }
553 static void dummy_sse_values (void) {}
555 #endif /* HAVE_PTRACE_GETFPXREGS */
558 /* Transferring arbitrary registers between GDB and inferior. */
560 /* Check if register REGNO in the child process is accessible.
561 If we are accessing registers directly via the U area, only the
562 general-purpose registers are available.
563 All registers should be accessible if we have GETREGS support. */
566 cannot_fetch_register (int regno
)
568 if (! have_ptrace_getregs
)
569 return OLD_CANNOT_FETCH_REGISTER (regno
);
573 cannot_store_register (int regno
)
575 if (! have_ptrace_getregs
)
576 return OLD_CANNOT_STORE_REGISTER (regno
);
580 /* Fetch register REGNO from the child process. If REGNO is -1, do
581 this for all registers (including the floating point and SSE
585 fetch_inferior_registers (int regno
)
589 /* Use the old method of peeking around in `struct user' if the
590 GETREGS request isn't available. */
591 if (! have_ptrace_getregs
)
593 old_fetch_inferior_registers (regno
);
597 /* GNU/Linux LWP ID's are process ID's. */
598 if ((tid
= TIDGET (inferior_ptid
)) == 0)
599 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
601 /* Use the PTRACE_GETFPXREGS request whenever possible, since it
602 transfers more registers in one system call, and we'll cache the
603 results. But remember that fetch_fpxregs can fail, and return
609 /* The call above might reset `have_ptrace_getregs'. */
610 if (! have_ptrace_getregs
)
612 old_fetch_inferior_registers (-1);
616 if (fetch_fpxregs (tid
))
622 if (GETREGS_SUPPLIES (regno
))
628 if (GETFPXREGS_SUPPLIES (regno
))
630 if (fetch_fpxregs (tid
))
633 /* Either our processor or our kernel doesn't support the SSE
634 registers, so read the FP registers in the traditional way,
635 and fill the SSE registers with dummy values. It would be
636 more graceful to handle differences in the register set using
637 gdbarch. Until then, this will at least make things work
643 internal_error (__FILE__
, __LINE__
,
644 "Got request for bad register number %d.", regno
);
647 /* Store register REGNO back into the child process. If REGNO is -1,
648 do this for all registers (including the floating point and SSE
651 store_inferior_registers (int regno
)
655 /* Use the old method of poking around in `struct user' if the
656 SETREGS request isn't available. */
657 if (! have_ptrace_getregs
)
659 old_store_inferior_registers (regno
);
663 /* GNU/Linux LWP ID's are process ID's. */
664 if ((tid
= TIDGET (inferior_ptid
)) == 0)
665 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
667 /* Use the PTRACE_SETFPXREGS requests whenever possible, since it
668 transfers more registers in one system call. But remember that
669 store_fpxregs can fail, and return zero. */
672 store_regs (tid
, regno
);
673 if (store_fpxregs (tid
, regno
))
675 store_fpregs (tid
, regno
);
679 if (GETREGS_SUPPLIES (regno
))
681 store_regs (tid
, regno
);
685 if (GETFPXREGS_SUPPLIES (regno
))
687 if (store_fpxregs (tid
, regno
))
690 /* Either our processor or our kernel doesn't support the SSE
691 registers, so just write the FP registers in the traditional
693 store_fpregs (tid
, regno
);
697 internal_error (__FILE__
, __LINE__
,
698 "Got request to store bad register number %d.", regno
);
703 i386_linux_dr_get (int regnum
)
708 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
709 multi-threaded processes here. For now, pretend there is just
711 tid
= PIDGET (inferior_ptid
);
713 /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
714 ptrace call fails breaks debugging remote targets. The correct
715 way to fix this is to add the hardware breakpoint and watchpoint
716 stuff to the target vectore. For now, just return zero if the
717 ptrace call fails. */
719 value
= ptrace (PT_READ_U
, tid
,
720 offsetof (struct user
, u_debugreg
[regnum
]), 0);
723 perror_with_name ("Couldn't read debug register");
732 i386_linux_dr_set (int regnum
, unsigned long value
)
736 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
737 multi-threaded processes here. For now, pretend there is just
739 tid
= PIDGET (inferior_ptid
);
742 ptrace (PT_WRITE_U
, tid
,
743 offsetof (struct user
, u_debugreg
[regnum
]), value
);
745 perror_with_name ("Couldn't write debug register");
749 i386_linux_dr_set_control (unsigned long control
)
751 i386_linux_dr_set (DR_CONTROL
, control
);
755 i386_linux_dr_set_addr (int regnum
, CORE_ADDR addr
)
757 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
759 i386_linux_dr_set (DR_FIRSTADDR
+ regnum
, addr
);
763 i386_linux_dr_reset_addr (int regnum
)
765 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
767 i386_linux_dr_set (DR_FIRSTADDR
+ regnum
, 0L);
771 i386_linux_dr_get_status (void)
773 return i386_linux_dr_get (DR_STATUS
);
777 /* Interpreting register set info found in core files. */
779 /* Provide registers to GDB from a core file.
781 (We can't use the generic version of this function in
782 core-regset.c, because GNU/Linux has *three* different kinds of
783 register set notes. core-regset.c would have to call
784 supply_fpxregset, which most platforms don't have.)
786 CORE_REG_SECT points to an array of bytes, which are the contents
787 of a `note' from a core file which BFD thinks might contain
788 register contents. CORE_REG_SIZE is its size.
790 WHICH says which register set corelow suspects this is:
791 0 --- the general-purpose register set, in elf_gregset_t format
792 2 --- the floating-point register set, in elf_fpregset_t format
793 3 --- the extended floating-point register set, in elf_fpxregset_t format
795 REG_ADDR isn't used on GNU/Linux. */
798 fetch_core_registers (char *core_reg_sect
, unsigned core_reg_size
,
799 int which
, CORE_ADDR reg_addr
)
801 elf_gregset_t gregset
;
802 elf_fpregset_t fpregset
;
807 if (core_reg_size
!= sizeof (gregset
))
808 warning ("Wrong size gregset in core file.");
811 memcpy (&gregset
, core_reg_sect
, sizeof (gregset
));
812 supply_gregset (&gregset
);
817 if (core_reg_size
!= sizeof (fpregset
))
818 warning ("Wrong size fpregset in core file.");
821 memcpy (&fpregset
, core_reg_sect
, sizeof (fpregset
));
822 supply_fpregset (&fpregset
);
826 #ifdef HAVE_PTRACE_GETFPXREGS
828 elf_fpxregset_t fpxregset
;
831 if (core_reg_size
!= sizeof (fpxregset
))
832 warning ("Wrong size fpxregset in core file.");
835 memcpy (&fpxregset
, core_reg_sect
, sizeof (fpxregset
));
836 supply_fpxregset (&fpxregset
);
843 /* We've covered all the kinds of registers we know about here,
844 so this must be something we wouldn't know what to do with
845 anyway. Just ignore it. */
851 /* The instruction for a GNU/Linux system call is:
855 static const unsigned char linux_syscall
[] = { 0xcd, 0x80 };
857 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
859 /* The system call number is stored in the %eax register. */
860 #define LINUX_SYSCALL_REGNUM 0 /* %eax */
862 /* We are specifically interested in the sigreturn and rt_sigreturn
865 #ifndef SYS_sigreturn
866 #define SYS_sigreturn 0x77
868 #ifndef SYS_rt_sigreturn
869 #define SYS_rt_sigreturn 0xad
872 /* Offset to saved processor flags, from <asm/sigcontext.h>. */
873 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
875 /* Resume execution of the inferior process.
876 If STEP is nonzero, single-step it.
877 If SIGNAL is nonzero, give it that signal. */
880 child_resume (ptid_t ptid
, int step
, enum target_signal signal
)
882 int pid
= PIDGET (ptid
);
884 int request
= PTRACE_CONT
;
887 /* Resume all threads. */
888 /* I think this only gets used in the non-threaded case, where "resume
889 all threads" and "resume inferior_ptid" are the same. */
890 pid
= PIDGET (inferior_ptid
);
894 CORE_ADDR pc
= read_pc_pid (pid_to_ptid (pid
));
895 unsigned char buf
[LINUX_SYSCALL_LEN
];
897 request
= PTRACE_SINGLESTEP
;
899 /* Returning from a signal trampoline is done by calling a
900 special system call (sigreturn or rt_sigreturn, see
901 i386-linux-tdep.c for more information). This system call
902 restores the registers that were saved when the signal was
903 raised, including %eflags. That means that single-stepping
904 won't work. Instead, we'll have to modify the signal context
905 that's about to be restored, and set the trace flag there. */
907 /* First check if PC is at a system call. */
908 if (read_memory_nobpt (pc
, (char *) buf
, LINUX_SYSCALL_LEN
) == 0
909 && memcmp (buf
, linux_syscall
, LINUX_SYSCALL_LEN
) == 0)
911 int syscall
= read_register_pid (LINUX_SYSCALL_REGNUM
,
914 /* Then check the system call number. */
915 if (syscall
== SYS_sigreturn
|| syscall
== SYS_rt_sigreturn
)
917 CORE_ADDR sp
= read_register (SP_REGNUM
);
919 unsigned long int eflags
;
921 if (syscall
== SYS_rt_sigreturn
)
922 addr
= read_memory_integer (sp
+ 8, 4) + 20;
924 /* Set the trace flag in the context that's about to be
926 addr
+= LINUX_SIGCONTEXT_EFLAGS_OFFSET
;
927 read_memory (addr
, (char *) &eflags
, 4);
929 write_memory (addr
, (char *) &eflags
, 4);
934 if (ptrace (request
, pid
, 0, target_signal_to_host (signal
)) == -1)
935 perror_with_name ("ptrace");
939 /* Register that we are able to handle GNU/Linux ELF core file
942 static struct core_fns linux_elf_core_fns
=
944 bfd_target_elf_flavour
, /* core_flavour */
945 default_check_format
, /* check_format */
946 default_core_sniffer
, /* core_sniffer */
947 fetch_core_registers
, /* core_read_registers */
952 _initialize_i386_linux_nat (void)
954 add_core_fns (&linux_elf_core_fns
);