diff options
| -rw-r--r-- | gdb/ChangeLog | 91 | ||||
| -rw-r--r-- | gdb/Makefile.in | 13 | ||||
| -rw-r--r-- | gdb/config/i386/i386sol2.mt | 2 | ||||
| -rw-r--r-- | gdb/i386-cygwin-tdep.c | 63 | ||||
| -rw-r--r-- | gdb/i386-linux-tdep.c | 100 | ||||
| -rw-r--r-- | gdb/i386-nto-tdep.c | 16 | ||||
| -rw-r--r-- | gdb/i386-sol2-tdep.c | 6 | ||||
| -rw-r--r-- | gdb/i386-tdep.c | 1180 | ||||
| -rw-r--r-- | gdb/i386-tdep.h | 13 | ||||
| -rw-r--r-- | gdb/i386bsd-tdep.c | 25 |
10 files changed, 854 insertions, 655 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 02a4b2d..b31281d 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,94 @@ +2003-05-30 Mark Kettenis <kettenis@gnu.org> + + * i386-tdep.h (i386bsd_sigcontext_addr): Remove prototype. + (I386_SIZEOF_GREGS, I386_SIZEOF_FREGS, I386_SIZEOF_XREGS): Remove + defenitions. + (IS_FP_REGNUM, IS_SSE_REGNUM): Remove definitions. + * i386-tdep.c: Mark functions that are 64-bit safe as such. + (I386_EAX_REGNUM, I386_EDX_REGNUM, I386_ESP_REGNUM, + I386_EBP_REGNUM, I386_EIP_REGNUM, I386_EFLAGS_REGNUM, + I386_ST0_REGNUM): New defines. + (CODESTREAM_BUFSIZ, codestream_tell, codestream_peek, + codestream_get): Remove define. + (codestream_next_addr, condestream_addr, condestream_buf, + codestream_off, codestream_cnt): Remove variables. + (codestream_fill, codestream_seek, codestream_read): Remove + functions. + (i386_follow_jump): Rewrite to avoid usage of removed codestream + functionality. + (i386_get_frame_setup, i386_frameless_signal_p, i386_frame_chain, + i386_sigtramp_saved_pc, i386_sigtramp_saved_sp, + i386_frame_saved_pc, i386_saved_pc_after_call, + i386_frame_num_args, i386_frame_init_saved_regs, + i386_push_return_address, i386_do_pop_frame, i386_pop_frame, + i386_push_arguments): Remove functions. + (i386_skip_prologue): Rewrite to avoid usage of removed codestream + functionality. Use i386_analyze_prologue instead of + i386_get_frame_setup. + (I386_NUM_SAVED_REGS): New define. + (struct i386_frame_cache): New structure. + (i386_alloc_frame_cache, i386_analyze_struct_return, + i386_skip_probe, i386_analyze_frame_setup, + i386_analyze_register_saves, i386_analyze_prologue, + i386_unwind_pc, i386_frame_cache, i386_frame_this_id, + i386_frame_prev_register, i386_sigtramp_frame_cache, + i386_sigtramp_frame_this_id, i386_sigtramp_frame_prev_register, + i386_frame_p, i386_sigtramp_frame_p, i386_frame_base_address, + i386_unwind_dummy_id, i386_save_dummy_tos, i386_push_dummy_call): + New functions. + (i386_frame_unwind, i386_sigtramp_frame_unwind, i386_frame_base): + New variables. + (LOW_RETURN_REGNUM, HIGH_RETURN_REGNUM): Define in terms of + I386_EAX_REGNUM and I386_EDX_REGNUM. + (i386_extract_return_value, i386_store_return_value): Use + I386_ST0_REGNUM where appropriate. + (i386_extract_struct_value_address): Rewrite to use extract_address. + (i386_svr4_pc_in_sigtramp): Add comment. + (i386_svr4_sigcontext_addr): Rewrite. + (i386_svr4_init_abi): Adjust TDEP->sc_pc_offset and + TDEP->sc_sp_offset. + (i386_gdbarch_init): Don't set deprecated_init_frame_pc. Set + sp_regnum, fp_regnum, pc_regnum, ps_regnum and fp0_regnum in terms + of new defines. Set push_dummy_call, don't set + deprecated_push_arguments, deprecated_push_return_address, + deprecated_pop_frame. Don't set parm_boundary. Don't set + deprecated_frame_chain, deprecated_frame_saved_pc, + deprecated_saved_pc_after_call. Set unwind_dummy_id, + save_dummy_frame_tos, unwind_pc. Call + frame_unwind_append_predicate and frame_base_set_default. Don't + set deprecated_dummy_write_pc. Don't set deprecated_fp_regnum. + Don't set frameless_function_invocation. Don't set + deprecated_register_bytes, deprecated_register_size, + deprecated_call_dummy_words and deprecated_sizeof_call_dummy. + * i386-linux-tdep.c: Fix formatting in some comments. + (LINUX_SIGTRAMP_INSN0, LINUX_SIGTRAMP_OFFSET0, + LINUX_SIGTRAMP_INSN1, LINUX_SIGTRAMP_OFFSET1, + LINUX_SIGTRAMP_INSN2, LINUX_SIGTRAMP_OFFSET2, + LINUX_RT_SIGTRAMP_INSN0, LINUX_RT_SIGTRAMP_OFFSET0, + LINUX_RT_SIGTRAMP_INSN1, LINUX_RT_SIGTRAMP_OFFSET1): Drop + redundant parentheses. + (I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET): New define. + (i386_linux_sigcontext_addr): Use it. Rewrite. + (find_minsym_and_objfile): Change name of second argument. + (skip_gnu_resolver): Renamed from skip_hurd_resolver. All callers + changed. Use frame_pc_unwind instead of + DEPRECATED_SAVED_PC_AFTER_CALL. + (i386_linux_init_abi): Don't set deprecated_register_bytes. + * i386bsd-tdep.c (i386bsd_sigcontext_addr): Rewrite. + * i386-nto-tdep.c (i386nto_sigcontext_addr): Adapt for new frame + unwinder. + * i386-cygwin-tdep.c: Don't include "gdbcore.h", "frame.h" and + "dummy-frame.h". + (i386_cygwin_frame_chain_valid, i386_cygwin_frame_chain): Removed. + (_initialize_i386_cygwin_tdep): New prototype. + (i386_cygwin_init_abi): Don't set deprecated_frame_chain and + deprecated_frame_chain_valid. + * i386-sol2-tdep.c (i386_sol2_init_abi): Don't set + TDEP->sigcontext_addr, TDEP->sc_pc_offset and TDEP->sc_sp_offset. + Rely on the SVR4 defaults. + * config/i386/i386sol2.mt (TDEPFILES): Remove i386bsd-tdep.o. + * Makefile.in (i386-tdep.o, i386-cygwin-tdep.o): Update dependencies. + 2003-05-30 Andrew Cagney <cagney@redhat.com> * infcall.c (call_function_by_hand): Always call diff --git a/gdb/Makefile.in b/gdb/Makefile.in index c52eadc..35125d9 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -1792,11 +1792,12 @@ i386-nat.o: i386-nat.c $(defs_h) $(breakpoint_h) $(command_h) $(gdbcmd_h) i386-sol2-tdep.o: i386-sol2-tdep.c $(defs_h) $(value_h) $(i386_tdep_h) \ $(osabi_h) i386-stub.o: i386-stub.c -i386-tdep.o: i386-tdep.c $(defs_h) $(gdb_string_h) $(frame_h) $(inferior_h) \ - $(gdbcore_h) $(objfiles_h) $(target_h) $(floatformat_h) $(symfile_h) \ - $(symtab_h) $(gdbcmd_h) $(command_h) $(arch_utils_h) $(regcache_h) \ - $(doublest_h) $(value_h) $(gdb_assert_h) $(i386_tdep_h) \ - $(i387_tdep_h) $(osabi_h) +i386-tdep.o: i386-tdep.c $(defs_h) $(arch_utils_h) $(command_h) \ + $(dummy_frame_h) $(doublest_h) $(floatformat_h) $(frame_h) \ + $(frame_base_h) $(frame_unwind_h) $(inferior_h) $(gdbcmd_h) \ + $(gdbcore_h) $(objfiles_h) $(osabi_h) $(regcache_h) $(reggroups_h) \ + $(symfile_h) $(symtab_h) $(target_h) $(value_h) $(gdb_assert_h) \ + $(gdb_string_h) $(i386_tdep_h) $(i387_tdep_h) i386b-nat.o: i386b-nat.c $(defs_h) i386bsd-nat.o: i386bsd-nat.c $(defs_h) $(inferior_h) $(regcache_h) \ $(gdb_assert_h) $(gregset_h) $(i386_tdep_h) $(i387_tdep_h) \ @@ -1811,7 +1812,7 @@ i386gnu-tdep.o: i386gnu-tdep.c $(defs_h) $(i386_tdep_h) $(osabi_h) i386ly-tdep.o: i386ly-tdep.c $(defs_h) $(gdbcore_h) $(inferior_h) \ $(regcache_h) $(target_h) $(i386_tdep_h) $(osabi_h) i386-cygwin-tdep.o: i386-cygwin-tdep.c $(defs_h) $(gdb_string_h) \ - $(i386_tdep_h) $(osabi_h) $(gdbcore_h) $(frame_h) $(dummy_frame_h) + $(i386_tdep_h) $(osabi_h) i386nbsd-tdep.o: i386nbsd-tdep.c $(defs_h) $(gdbtypes_h) $(gdbcore_h) \ $(regcache_h) $(arch_utils_h) $(i386_tdep_h) $(i387_tdep_h) \ $(nbsd_tdep_h) $(solib_svr4_h) $(osabi_h) diff --git a/gdb/config/i386/i386sol2.mt b/gdb/config/i386/i386sol2.mt index f8fabd4..93c2d78 100644 --- a/gdb/config/i386/i386sol2.mt +++ b/gdb/config/i386/i386sol2.mt @@ -1,3 +1,3 @@ # Target: Intel 386 running Solaris 2 (SVR4) -TDEPFILES= i386-tdep.o i387-tdep.o i386-sol2-tdep.o i386bsd-tdep.o +TDEPFILES= i386-tdep.o i387-tdep.o i386-sol2-tdep.o TM_FILE= tm-i386sol2.h diff --git a/gdb/i386-cygwin-tdep.c b/gdb/i386-cygwin-tdep.c index 5911ec9..443f8f7 100644 --- a/gdb/i386-cygwin-tdep.c +++ b/gdb/i386-cygwin-tdep.c @@ -1,56 +1,30 @@ /* Target-dependent code for Cygwin running on i386's, for GDB. + Copyright 2003 Free Software Foundation, Inc. -This file is part of GDB. + This file is part of GDB. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ #include "defs.h" - -#include "gdb_string.h" -#include "gdbcore.h" -#include "i386-tdep.h" #include "osabi.h" -#include "frame.h" -#include "dummy-frame.h" - -static int -i386_cygwin_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe) -{ - /* In the context where this is used, we get the saved PC before we've - successfully unwound far enough to be sure what we've got (it may - be a signal handler caller). If we're dealing with a signal - handler caller, this will return valid, which is fine. If not, - it'll make the correct test. */ - return ((get_frame_type (thisframe) == SIGTRAMP_FRAME) || chain != 0); -} -/* Return the chain-pointer for FRAME. In the case of the i386, the - frame's nominal address is the address of a 4-byte word containing - the calling frame's address. */ -static CORE_ADDR -i386_cygwin_frame_chain (struct frame_info *frame) -{ - if (pc_in_dummy_frame (get_frame_pc (frame))) - return get_frame_base (frame); - if (get_frame_type (frame) == SIGTRAMP_FRAME - || i386_frameless_signal_p (frame)) - return get_frame_base (frame); +#include "gdb_string.h" - return read_memory_unsigned_integer (get_frame_base (frame), 4); -} +#include "i386-tdep.h" static void i386_cygwin_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) @@ -58,8 +32,6 @@ i386_cygwin_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); tdep->struct_return = reg_struct_return; - set_gdbarch_deprecated_frame_chain (gdbarch, i386_cygwin_frame_chain); - set_gdbarch_deprecated_frame_chain_valid (gdbarch, i386_cygwin_frame_chain_valid); } static enum gdb_osabi @@ -75,6 +47,9 @@ i386_cygwin_osabi_sniffer (bfd * abfd) return GDB_OSABI_UNKNOWN; } +/* Provide a prototype to silence -Wmissing-prototypes. */ +void _initialize_i386_cygwin_tdep (void); + void _initialize_i386_cygwin_tdep (void) { diff --git a/gdb/i386-linux-tdep.c b/gdb/i386-linux-tdep.c index afff548..e666610 100644 --- a/gdb/i386-linux-tdep.c +++ b/gdb/i386-linux-tdep.c @@ -81,7 +81,7 @@ i386_linux_register_reggroup_p (struct gdbarch *gdbarch, int regnum, The instruction sequence for normal signals is pop %eax - mov $0x77,%eax + mov $0x77, %eax int $0x80 or 0x58 0xb8 0x77 0x00 0x00 0x00 0xcd 0x80. @@ -103,17 +103,17 @@ i386_linux_register_reggroup_p (struct gdbarch *gdbarch, int regnum, to the ones used by the kernel. Therefore, these trampolines are supported too. */ -#define LINUX_SIGTRAMP_INSN0 (0x58) /* pop %eax */ -#define LINUX_SIGTRAMP_OFFSET0 (0) -#define LINUX_SIGTRAMP_INSN1 (0xb8) /* mov $NNNN,%eax */ -#define LINUX_SIGTRAMP_OFFSET1 (1) -#define LINUX_SIGTRAMP_INSN2 (0xcd) /* int */ -#define LINUX_SIGTRAMP_OFFSET2 (6) +#define LINUX_SIGTRAMP_INSN0 0x58 /* pop %eax */ +#define LINUX_SIGTRAMP_OFFSET0 0 +#define LINUX_SIGTRAMP_INSN1 0xb8 /* mov $NNNN, %eax */ +#define LINUX_SIGTRAMP_OFFSET1 1 +#define LINUX_SIGTRAMP_INSN2 0xcd /* int */ +#define LINUX_SIGTRAMP_OFFSET2 6 static const unsigned char linux_sigtramp_code[] = { LINUX_SIGTRAMP_INSN0, /* pop %eax */ - LINUX_SIGTRAMP_INSN1, 0x77, 0x00, 0x00, 0x00, /* mov $0x77,%eax */ + LINUX_SIGTRAMP_INSN1, 0x77, 0x00, 0x00, 0x00, /* mov $0x77, %eax */ LINUX_SIGTRAMP_INSN2, 0x80 /* int $0x80 */ }; @@ -167,20 +167,20 @@ i386_linux_sigtramp_start (CORE_ADDR pc) /* This function does the same for RT signals. Here the instruction sequence is - mov $0xad,%eax + mov $0xad, %eax int $0x80 or 0xb8 0xad 0x00 0x00 0x00 0xcd 0x80. The effect is to call the system call rt_sigreturn. */ -#define LINUX_RT_SIGTRAMP_INSN0 (0xb8) /* mov $NNNN,%eax */ -#define LINUX_RT_SIGTRAMP_OFFSET0 (0) -#define LINUX_RT_SIGTRAMP_INSN1 (0xcd) /* int */ -#define LINUX_RT_SIGTRAMP_OFFSET1 (5) +#define LINUX_RT_SIGTRAMP_INSN0 0xb8 /* mov $NNNN, %eax */ +#define LINUX_RT_SIGTRAMP_OFFSET0 0 +#define LINUX_RT_SIGTRAMP_INSN1 0xcd /* int */ +#define LINUX_RT_SIGTRAMP_OFFSET1 5 static const unsigned char linux_rt_sigtramp_code[] = { - LINUX_RT_SIGTRAMP_INSN0, 0xad, 0x00, 0x00, 0x00, /* mov $0xad,%eax */ + LINUX_RT_SIGTRAMP_INSN0, 0xad, 0x00, 0x00, 0x00, /* mov $0xad, %eax */ LINUX_RT_SIGTRAMP_INSN1, 0x80 /* int $0x80 */ }; @@ -239,50 +239,47 @@ i386_linux_pc_in_sigtramp (CORE_ADDR pc, char *name) || strcmp ("__restore_rt", name) == 0); } -/* Assuming FRAME is for a GNU/Linux sigtramp routine, return the - address of the associated sigcontext structure. */ +/* Offset to struct sigcontext in ucontext, from <asm/ucontext.h>. */ +#define I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET 20 + +/* Assuming NEXT_FRAME is a frame following a GNU/Linux sigtramp + routine, return the address of the associated sigcontext structure. */ static CORE_ADDR -i386_linux_sigcontext_addr (struct frame_info *frame) +i386_linux_sigcontext_addr (struct frame_info *next_frame) { CORE_ADDR pc; + CORE_ADDR sp; + char buf[4]; + + frame_unwind_register (next_frame, SP_REGNUM, buf); + sp = extract_unsigned_integer (buf, 4); - pc = i386_linux_sigtramp_start (get_frame_pc (frame)); + pc = i386_linux_sigtramp_start (frame_pc_unwind (next_frame)); if (pc) { - CORE_ADDR sp; - - if (get_next_frame (frame)) - /* If this isn't the top frame, the next frame must be for the - signal handler itself. The sigcontext structure lives on - the stack, right after the signum argument. */ - return get_frame_base (get_next_frame (frame)) + 12; - - /* This is the top frame. We'll have to find the address of the - sigcontext structure by looking at the stack pointer. Keep - in mind that the first instruction of the sigtramp code is - "pop %eax". If the PC is at this instruction, adjust the - returned value accordingly. */ - sp = read_register (SP_REGNUM); - if (pc == get_frame_pc (frame)) + /* The sigcontext structure lives on the stack, right after + the signum argument. We determine the address of the + sigcontext structure by looking at the frame's stack + pointer. Keep in mind that the first instruction of the + sigtramp code is "pop %eax". If the PC is after this + instruction, adjust the returned value accordingly. */ + if (pc == frame_pc_unwind (next_frame)) return sp + 4; return sp; } - pc = i386_linux_rt_sigtramp_start (get_frame_pc (frame)); + pc = i386_linux_rt_sigtramp_start (frame_pc_unwind (next_frame)); if (pc) { - if (get_next_frame (frame)) - /* If this isn't the top frame, the next frame must be for the - signal handler itself. The sigcontext structure is part of - the user context. A pointer to the user context is passed - as the third argument to the signal handler. */ - return read_memory_integer (get_frame_base (get_next_frame (frame)) - + 16, 4) + 20; - - /* This is the top frame. Again, use the stack pointer to find - the address of the sigcontext structure. */ - return read_memory_integer (read_register (SP_REGNUM) + 8, 4) + 20; + CORE_ADDR ucontext_addr; + + /* The sigcontext structure is part of the user context. A + pointer to the user context is passed as the third argument + to the signal handler. */ + read_memory (sp + 8, buf, 4); + ucontext_addr = extract_unsigned_integer (buf, 4) + 20; + return ucontext_addr + I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET; } error ("Couldn't recognize signal trampoline."); @@ -322,7 +319,7 @@ i386_linux_write_pc (CORE_ADDR pc, ptid_t ptid) be considered too special-purpose for general consumption. */ static struct minimal_symbol * -find_minsym_and_objfile (char *name, struct objfile **objfile_p) +find_minsym_and_objfile (char *name, struct objfile **objfilep) { struct objfile *objfile; @@ -335,7 +332,7 @@ find_minsym_and_objfile (char *name, struct objfile **objfile_p) if (SYMBOL_LINKAGE_NAME (msym) && strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0) { - *objfile_p = objfile; + *objfilep = objfile; return msym; } } @@ -345,9 +342,9 @@ find_minsym_and_objfile (char *name, struct objfile **objfile_p) } static CORE_ADDR -skip_hurd_resolver (CORE_ADDR pc) +skip_gnu_resolver (CORE_ADDR pc) { - /* The HURD dynamic linker is part of the GNU C library, so many + /* The GNU dynamic linker is part of the GNU C library, so many GNU/Linux distributions use it. (All ELF versions, as far as I know.) An unresolved PLT entry points to "_dl_runtime_resolve", which calls "fixup" to patch the PLT, and then passes control to @@ -374,7 +371,7 @@ skip_hurd_resolver (CORE_ADDR pc) = lookup_minimal_symbol ("fixup", NULL, objfile); if (fixup && SYMBOL_VALUE_ADDRESS (fixup) == pc) - return (DEPRECATED_SAVED_PC_AFTER_CALL (get_current_frame ())); + return frame_pc_unwind (get_current_frame ()); } return 0; @@ -393,7 +390,7 @@ i386_linux_skip_solib_resolver (CORE_ADDR pc) CORE_ADDR result; /* Plug in functions for other kinds of resolvers here. */ - result = skip_hurd_resolver (pc); + result = skip_gnu_resolver (pc); if (result) return result; @@ -461,7 +458,6 @@ i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) set_gdbarch_num_regs (gdbarch, I386_SSE_NUM_REGS + 1); set_gdbarch_register_name (gdbarch, i386_linux_register_name); set_gdbarch_register_reggroup_p (gdbarch, i386_linux_register_reggroup_p); - set_gdbarch_deprecated_register_bytes (gdbarch, I386_SSE_SIZEOF_REGS + 4); tdep->jb_pc_offset = 20; /* From <bits/setjmp.h>. */ diff --git a/gdb/i386-nto-tdep.c b/gdb/i386-nto-tdep.c index b35dd2a..381119f 100644 --- a/gdb/i386-nto-tdep.c +++ b/gdb/i386-nto-tdep.c @@ -231,14 +231,20 @@ i386nto_pc_in_sigtramp (CORE_ADDR pc, char *name) return name && strcmp ("__signalstub", name) == 0; } -#define SIGCONTEXT_OFFSET 136 +#define I386_NTO_SIGCONTEXT_OFFSET 136 + +/* Assuming NEXT_FRAME is a frame following a QNX Neutrino sigtramp + routine, return the address of the associated sigcontext structure. */ + static CORE_ADDR -i386nto_sigcontext_addr (struct frame_info *frame) +i386nto_sigcontext_addr (struct frame_info *next_frame) { - if (get_next_frame (frame)) - return get_frame_base (get_next_frame (frame)) + SIGCONTEXT_OFFSET; + char buf[4]; + + frame_unwind_register (next_frame, SP_REGNUM, buf); + sp = extract_unsigned_integer (buf, 4); - return read_register (SP_REGNUM) + SIGCONTEXT_OFFSET; + return sp + I386_NTO_SIGCONTEXT_OFFSET; } static void diff --git a/gdb/i386-sol2-tdep.c b/gdb/i386-sol2-tdep.c index a52b188..78487af 100644 --- a/gdb/i386-sol2-tdep.c +++ b/gdb/i386-sol2-tdep.c @@ -42,12 +42,8 @@ i386_sol2_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) /* Solaris is SVR4-based. */ i386_svr4_init_abi (info, gdbarch); - /* Signal trampolines are different from SVR4, in fact they're - rather similar to BSD. */ + /* Signal trampolines are slightly different from SVR4. */ set_gdbarch_pc_in_sigtramp (gdbarch, i386_sol2_pc_in_sigtramp); - tdep->sigcontext_addr = i386bsd_sigcontext_addr; - tdep->sc_pc_offset = 36 + 14 * 4; - tdep->sc_sp_offset = 36 + 17 * 4; } diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c index 0428c13..6641516 100644 --- a/gdb/i386-tdep.c +++ b/gdb/i386-tdep.c @@ -21,29 +21,42 @@ Boston, MA 02111-1307, USA. */ #include "defs.h" -#include "gdb_string.h" +#include "arch-utils.h" +#include "command.h" +#include "dummy-frame.h" +#include "doublest.h" +#include "floatformat.h" #include "frame.h" +#include "frame-base.h" +#include "frame-unwind.h" #include "inferior.h" +#include "gdbcmd.h" #include "gdbcore.h" #include "objfiles.h" -#include "target.h" -#include "floatformat.h" +#include "osabi.h" +#include "regcache.h" +#include "reggroups.h" #include "symfile.h" #include "symtab.h" -#include "gdbcmd.h" -#include "command.h" -#include "arch-utils.h" -#include "regcache.h" -#include "doublest.h" +#include "target.h" #include "value.h" + #include "gdb_assert.h" -#include "reggroups.h" -#include "dummy-frame.h" -#include "osabi.h" +#include "gdb_string.h" #include "i386-tdep.h" #include "i387-tdep.h" +/* Register numbers of various important registers. */ + +#define I386_EAX_REGNUM 0 /* %eax */ +#define I386_EDX_REGNUM 2 /* %edx */ +#define I386_ESP_REGNUM 4 /* %esp */ +#define I386_EBP_REGNUM 5 /* %ebp */ +#define I386_EIP_REGNUM 8 /* %eip */ +#define I386_EFLAGS_REGNUM 9 /* %eflags */ +#define I386_ST0_REGNUM 16 /* %st(0) */ + /* Names of the registers. The first 10 registers match the register numbering scheme used by GCC for stabs and DWARF. */ @@ -140,7 +153,7 @@ i386_stab_reg_to_regnum (int reg) /* This implements what GCC calls the "default" register map. */ if (reg >= 0 && reg <= 7) { - /* General registers. */ + /* General-purpose registers. */ return reg; } else if (reg >= 12 && reg <= 19) @@ -173,7 +186,7 @@ i386_dwarf_reg_to_regnum (int reg) numbers the floating point registers differently. */ if (reg >= 0 && reg <= 9) { - /* General registers. */ + /* General-purpose registers. */ return reg; } else if (reg >= 11 && reg <= 18) @@ -203,412 +216,359 @@ static const char *valid_flavors[] = NULL }; static const char *disassembly_flavor = att_flavor; + -/* Stdio style buffering was used to minimize calls to ptrace, but - this buffering did not take into account that the code section - being accessed may not be an even number of buffers long (even if - the buffer is only sizeof(int) long). In cases where the code - section size happened to be a non-integral number of buffers long, - attempting to read the last buffer would fail. Simply using - target_read_memory and ignoring errors, rather than read_memory, is - not the correct solution, since legitimate access errors would then - be totally ignored. To properly handle this situation and continue - to use buffering would require that this code be able to determine - the minimum code section size granularity (not the alignment of the - section itself, since the actual failing case that pointed out this - problem had a section alignment of 4 but was not a multiple of 4 - bytes long), on a target by target basis, and then adjust it's - buffer size accordingly. This is messy, but potentially feasible. - It probably needs the bfd library's help and support. For now, the - buffer size is set to 1. (FIXME -fnf) */ - -#define CODESTREAM_BUFSIZ 1 /* Was sizeof(int), see note above. */ -static CORE_ADDR codestream_next_addr; -static CORE_ADDR codestream_addr; -static unsigned char codestream_buf[CODESTREAM_BUFSIZ]; -static int codestream_off; -static int codestream_cnt; - -#define codestream_tell() (codestream_addr + codestream_off) -#define codestream_peek() \ - (codestream_cnt == 0 ? \ - codestream_fill(1) : codestream_buf[codestream_off]) -#define codestream_get() \ - (codestream_cnt-- == 0 ? \ - codestream_fill(0) : codestream_buf[codestream_off++]) - -static unsigned char -codestream_fill (int peek_flag) -{ - codestream_addr = codestream_next_addr; - codestream_next_addr += CODESTREAM_BUFSIZ; - codestream_off = 0; - codestream_cnt = CODESTREAM_BUFSIZ; - read_memory (codestream_addr, (char *) codestream_buf, CODESTREAM_BUFSIZ); - - if (peek_flag) - return (codestream_peek ()); - else - return (codestream_get ()); -} +/* Use the program counter to determine the contents and size of a + breakpoint instruction. Return a pointer to a string of bytes that + encode a breakpoint instruction, store the length of the string in + *LEN and optionally adjust *PC to point to the correct memory + location for inserting the breakpoint. -static void -codestream_seek (CORE_ADDR place) -{ - codestream_next_addr = place / CODESTREAM_BUFSIZ; - codestream_next_addr *= CODESTREAM_BUFSIZ; - codestream_cnt = 0; - codestream_fill (1); - while (codestream_tell () != place) - codestream_get (); -} + On the i386 we have a single breakpoint that fits in a single byte + and can be inserted anywhere. -static void -codestream_read (unsigned char *buf, int count) + This function is 64-bit safe. */ + +static const unsigned char * +i386_breakpoint_from_pc (CORE_ADDR *pc, int *len) { - unsigned char *p; - int i; - p = buf; - for (i = 0; i < count; i++) - *p++ = codestream_get (); + static unsigned char break_insn[] = { 0xcc }; /* int 3 */ + + *len = sizeof (break_insn); + return break_insn; } +#ifdef I386_REGNO_TO_SYMMETRY +#error "The Sequent Symmetry is no longer supported." +#endif -/* If the next instruction is a jump, move to its target. */ +/* According to the System V ABI, the registers %ebp, %ebx, %edi, %esi + and %esp "belong" to the calling function. Therefore these + registers should be saved if they're going to be modified. */ -static void -i386_follow_jump (void) +/* The maximum number of saved registers. This should include all + registers mentioned above, and %eip. */ +#define I386_NUM_SAVED_REGS 9 + +struct i386_frame_cache { - unsigned char buf[4]; - long delta; + /* Base address. */ + CORE_ADDR base; + CORE_ADDR sp_offset; + CORE_ADDR pc; + + /* Saved registers. */ + CORE_ADDR saved_regs[I386_NUM_SAVED_REGS]; + CORE_ADDR saved_sp; + int pc_in_eax; + + /* Stack space reserved for local variables. */ + long locals; +}; + +/* Allocate and initialize a frame cache. */ + +static struct i386_frame_cache * +i386_alloc_frame_cache (void) +{ + struct i386_frame_cache *cache; + int i; + + cache = FRAME_OBSTACK_ZALLOC (struct i386_frame_cache); + + /* Base address. */ + cache->base = 0; + cache->sp_offset = -4; + cache->pc = 0; + + /* Saved registers. We initialize these to -1 since zero is a valid + offset (that's where %ebp is supposed to be stored). */ + for (i = 0; i < I386_NUM_SAVED_REGS; i++) + cache->saved_regs[i] = -1; + cache->saved_sp = 0; + cache->pc_in_eax = 0; + + /* Frameless until proven otherwise. */ + cache->locals = -1; + + return cache; +} - int data16; - CORE_ADDR pos; +/* If the instruction at PC is a jump, return the address of its + target. Otherwise, return PC. */ - pos = codestream_tell (); +static CORE_ADDR +i386_follow_jump (CORE_ADDR pc) +{ + unsigned char op; + long delta = 0; + int data16 = 0; - data16 = 0; - if (codestream_peek () == 0x66) + op = read_memory_unsigned_integer (pc, 1); + if (op == 0x66) { - codestream_get (); data16 = 1; + op = read_memory_unsigned_integer (pc + 1, 1); } - switch (codestream_get ()) + switch (op) { case 0xe9: /* Relative jump: if data16 == 0, disp32, else disp16. */ if (data16) { - codestream_read (buf, 2); - delta = extract_signed_integer (buf, 2); + delta = read_memory_integer (pc + 2, 2); /* Include the size of the jmp instruction (including the 0x66 prefix). */ - pos += delta + 4; + delta += 4; } else { - codestream_read (buf, 4); - delta = extract_signed_integer (buf, 4); + delta = read_memory_integer (pc + 1, 4); - pos += delta + 5; + /* Include the size of the jmp instruction. */ + delta += 5; } break; case 0xeb: /* Relative jump, disp8 (ignore data16). */ - codestream_read (buf, 1); - /* Sign-extend it. */ - delta = extract_signed_integer (buf, 1); + delta = read_memory_integer (pc + data16 + 1, 1); - pos += delta + 2; + delta += data16 + 2; break; } - codestream_seek (pos); -} -/* Find & return the amount a local space allocated, and advance the - codestream to the first register push (if any). + return pc + delta; +} - If the entry sequence doesn't make sense, return -1, and leave - codestream pointer at a random spot. */ +/* Check whether PC points at a prologue for a function returning a + structure or union. If so, it updates CACHE and returns the + address of the first instruction after the code sequence that + removes the "hidden" argument from the stack or CURRENT_PC, + whichever is smaller. Otherwise, return PC. */ -static long -i386_get_frame_setup (CORE_ADDR pc) +static CORE_ADDR +i386_analyze_struct_return (CORE_ADDR pc, CORE_ADDR current_pc, + struct i386_frame_cache *cache) { + /* Functions that return a structure or union start with: + + popl %eax 0x58 + xchgl %eax, (%esp) 0x87 0x04 0x24 + or xchgl %eax, 0(%esp) 0x87 0x44 0x24 0x00 + + (the System V compiler puts out the second `xchg' instruction, + and the assembler doesn't try to optimize it, so the 'sib' form + gets generated). This sequence is used to get the address of the + return buffer for a function that returns a structure. */ + static unsigned char proto1[3] = { 0x87, 0x04, 0x24 }; + static unsigned char proto2[4] = { 0x87, 0x44, 0x24, 0x00 }; + unsigned char buf[4]; unsigned char op; - codestream_seek (pc); + if (current_pc <= pc) + return pc; + + op = read_memory_unsigned_integer (pc, 1); - i386_follow_jump (); + if (op != 0x58) /* popl %eax */ + return pc; - op = codestream_get (); + read_memory (pc + 1, buf, 4); + if (memcmp (buf, proto1, 3) != 0 && memcmp (buf, proto2, 4) != 0) + return pc; - if (op == 0x58) /* popl %eax */ + if (current_pc == pc) { - /* This function must start with - - popl %eax 0x58 - xchgl %eax, (%esp) 0x87 0x04 0x24 - or xchgl %eax, 0(%esp) 0x87 0x44 0x24 0x00 - - (the System V compiler puts out the second `xchg' - instruction, and the assembler doesn't try to optimize it, so - the 'sib' form gets generated). This sequence is used to get - the address of the return buffer for a function that returns - a structure. */ - int pos; - unsigned char buf[4]; - static unsigned char proto1[3] = { 0x87, 0x04, 0x24 }; - static unsigned char proto2[4] = { 0x87, 0x44, 0x24, 0x00 }; - - pos = codestream_tell (); - codestream_read (buf, 4); - if (memcmp (buf, proto1, 3) == 0) - pos += 3; - else if (memcmp (buf, proto2, 4) == 0) - pos += 4; - - codestream_seek (pos); - op = codestream_get (); /* Update next opcode. */ + cache->sp_offset += 4; + return current_pc; } - if (op == 0x68 || op == 0x6a) + if (current_pc == pc + 1) { - /* This function may start with + cache->pc_in_eax = 1; + return current_pc; + } + + if (buf[1] == proto1[1]) + return pc + 4; + else + return pc + 5; +} + +static CORE_ADDR +i386_skip_probe (CORE_ADDR pc) +{ + /* A function may start with - pushl constant - call _probe - addl $4, %esp + pushl constant + call _probe + addl $4, %esp - followed by + followed by + + pushl %ebp - pushl %ebp + etc. */ + unsigned char buf[8]; + unsigned char op; - etc. */ - int pos; - unsigned char buf[8]; + op = read_memory_unsigned_integer (pc, 1); + + if (op == 0x68 || op == 0x6a) + { + int delta; - /* Skip past the `pushl' instruction; it has either a one-byte - or a four-byte operand, depending on the opcode. */ - pos = codestream_tell (); + /* Skip past the `pushl' instruction; it has either a one-byte or a + four-byte operand, depending on the opcode. */ if (op == 0x68) - pos += 4; + delta = 5; else - pos += 1; - codestream_seek (pos); + delta = 2; - /* Read the following 8 bytes, which should be "call _probe" (6 - bytes) followed by "addl $4,%esp" (2 bytes). */ - codestream_read (buf, sizeof (buf)); + /* Read the following 8 bytes, which should be `call _probe' (6 + bytes) followed by `addl $4,%esp' (2 bytes). */ + read_memory (pc + delta, buf, sizeof (buf)); if (buf[0] == 0xe8 && buf[6] == 0xc4 && buf[7] == 0x4) - pos += sizeof (buf); - codestream_seek (pos); - op = codestream_get (); /* Update next opcode. */ + pc += delta + sizeof (buf); } + return pc; +} + +/* Check whether PC points at a code that sets up a new stack frame. + If so, it updates CACHE and returns the address of the first + instruction after the sequence that sets removes the "hidden" + argument from the stack or CURRENT_PC, whichever is smaller. + Otherwise, return PC. */ + +static CORE_ADDR +i386_analyze_frame_setup (CORE_ADDR pc, CORE_ADDR current_pc, + struct i386_frame_cache *cache) +{ + unsigned char op; + + if (current_pc <= pc) + return current_pc; + + op = read_memory_unsigned_integer (pc, 1); + if (op == 0x55) /* pushl %ebp */ { - /* Check for "movl %esp, %ebp" -- can be written in two ways. */ - switch (codestream_get ()) + /* Take into account that we've executed the `pushl %ebp' that + starts this instruction sequence. */ + cache->saved_regs[I386_EBP_REGNUM] = 0; + cache->sp_offset += 4; + + /* If that's all, return now. */ + if (current_pc <= pc + 1) + return current_pc; + + /* Check for `movl %esp, %ebp' -- can be written in two ways. */ + op = read_memory_unsigned_integer (pc + 1, 1); + switch (op) { case 0x8b: - if (codestream_get () != 0xec) - return -1; + if (read_memory_unsigned_integer (pc + 2, 1) != 0xec) + return pc + 1; break; case 0x89: - if (codestream_get () != 0xe5) - return -1; + if (read_memory_unsigned_integer (pc + 2, 1) != 0xe5) + return pc + 1; break; default: - return -1; + return pc + 1; } + + /* OK, we actually have a frame. We just don't know how large it is + yet. Set its size to zero. We'll adjust it if necessary. */ + cache->locals = 0; + + /* If that's all, return now. */ + if (current_pc <= pc + 3) + return current_pc; + /* Check for stack adjustment - subl $XXX, %esp + subl $XXX, %esp NOTE: You can't subtract a 16 bit immediate from a 32 bit reg, so we don't have to worry about a data16 prefix. */ - op = codestream_peek (); + op = read_memory_unsigned_integer (pc + 3, 1); if (op == 0x83) { /* `subl' with 8 bit immediate. */ - codestream_get (); - if (codestream_get () != 0xec) + if (read_memory_unsigned_integer (pc + 4, 1) != 0xec) /* Some instruction starting with 0x83 other than `subl'. */ - { - codestream_seek (codestream_tell () - 2); - return 0; - } - /* `subl' with signed byte immediate (though it wouldn't - make sense to be negative). */ - return (codestream_get ()); + return pc + 3; + + /* `subl' with signed byte immediate (though it wouldn't make + sense to be negative). */ + cache->locals = read_memory_integer (pc + 5, 1); + return pc + 6; } else if (op == 0x81) { - char buf[4]; /* Maybe it is `subl' with a 32 bit immedediate. */ - codestream_get (); - if (codestream_get () != 0xec) + if (read_memory_unsigned_integer (pc + 4, 1) != 0xec) /* Some instruction starting with 0x81 other than `subl'. */ - { - codestream_seek (codestream_tell () - 2); - return 0; - } + return pc + 3; + /* It is `subl' with a 32 bit immediate. */ - codestream_read ((unsigned char *) buf, 4); - return extract_signed_integer (buf, 4); + cache->locals = read_memory_integer (pc + 5, 4); + return pc + 9; } else { - return 0; + /* Some instruction other than `subl'. */ + return pc + 3; } } - else if (op == 0xc8) + else if (op == 0xc8) /* enter $XXX */ { - char buf[2]; - /* `enter' with 16 bit unsigned immediate. */ - codestream_read ((unsigned char *) buf, 2); - codestream_get (); /* Flush final byte of enter instruction. */ - return extract_unsigned_integer (buf, 2); + cache->locals = read_memory_unsigned_integer (pc + 1, 2); + return pc + 4; } - return (-1); -} - -/* Signal trampolines don't have a meaningful frame. The frame - pointer value we use is actually the frame pointer of the calling - frame -- that is, the frame which was in progress when the signal - trampoline was entered. GDB mostly treats this frame pointer value - as a magic cookie. We detect the case of a signal trampoline by - testing for get_frame_type() == SIGTRAMP_FRAME, which is set based - on PC_IN_SIGTRAMP. - - When a signal trampoline is invoked from a frameless function, we - essentially have two frameless functions in a row. In this case, - we use the same magic cookie for three frames in a row. We detect - this case by seeing whether the next frame is a SIGTRAMP_FRAME, - and, if it does, checking whether the current frame is actually - frameless. In this case, we need to get the PC by looking at the - SP register value stored in the signal context. - - This should work in most cases except in horrible situations where - a signal occurs just as we enter a function but before the frame - has been set up. Incidentally, that's just what happens when we - call a function from GDB with a signal pending (there's a test in - the testsuite that makes this happen). Therefore we pretend that - we have a frameless function if we're stopped at the start of a - function. */ - -/* Return non-zero if we're dealing with a frameless signal, that is, - a signal trampoline invoked from a frameless function. */ - -int -i386_frameless_signal_p (struct frame_info *frame) -{ - return (get_next_frame (frame) - && get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME - && (frameless_look_for_prologue (frame) - || get_frame_pc (frame) == get_frame_func (frame))); -} - -/* Return the chain-pointer for FRAME. In the case of the i386, the - frame's nominal address is the address of a 4-byte word containing - the calling frame's address. */ - -static CORE_ADDR -i386_frame_chain (struct frame_info *frame) -{ - if (pc_in_dummy_frame (get_frame_pc (frame))) - return get_frame_base (frame); - - if (get_frame_type (frame) == SIGTRAMP_FRAME - || i386_frameless_signal_p (frame)) - return get_frame_base (frame); - - if (! inside_entry_file (get_frame_pc (frame))) - return read_memory_unsigned_integer (get_frame_base (frame), 4); - - return 0; -} - -/* Determine whether the function invocation represented by FRAME does - not have a from on the stack associated with it. If it does not, - return non-zero, otherwise return zero. */ - -static int -i386_frameless_function_invocation (struct frame_info *frame) -{ - if (get_frame_type (frame) == SIGTRAMP_FRAME) - return 0; - - return frameless_look_for_prologue (frame); -} - -/* Assuming FRAME is for a sigtramp routine, return the saved program - counter. */ - -static CORE_ADDR -i386_sigtramp_saved_pc (struct frame_info *frame) -{ - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - CORE_ADDR addr; - addr = tdep->sigcontext_addr (frame); - return read_memory_unsigned_integer (addr + tdep->sc_pc_offset, 4); + return pc; } -/* Assuming FRAME is for a sigtramp routine, return the saved stack - pointer. */ +/* Check whether PC points at code that saves registers on the stack. + If so, it updates CACHE and returns the address of the first + instruction after the register saves or CURRENT_PC, whichever is + smaller. Otherwise, return PC. */ static CORE_ADDR -i386_sigtramp_saved_sp (struct frame_info *frame) +i386_analyze_register_saves (CORE_ADDR pc, CORE_ADDR current_pc, + struct i386_frame_cache *cache) { - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - CORE_ADDR addr; - - addr = tdep->sigcontext_addr (frame); - return read_memory_unsigned_integer (addr + tdep->sc_sp_offset, 4); -} - -/* Return the saved program counter for FRAME. */ - -static CORE_ADDR -i386_frame_saved_pc (struct frame_info *frame) -{ - if (pc_in_dummy_frame (get_frame_pc (frame))) + if (cache->locals >= 0) { - ULONGEST pc; - - frame_unwind_unsigned_register (frame, PC_REGNUM, &pc); - return pc; - } + CORE_ADDR offset; + unsigned char op; + int i; - if (get_frame_type (frame) == SIGTRAMP_FRAME) - return i386_sigtramp_saved_pc (frame); + offset = - 4 - cache->locals; + for (i = 0; i < 8 && pc < current_pc; i++) + { + op = read_memory_unsigned_integer (pc, 1); + if (op < 0x50 || op > 0x57) + break; - if (i386_frameless_signal_p (frame)) - { - CORE_ADDR sp = i386_sigtramp_saved_sp (get_next_frame (frame)); - return read_memory_unsigned_integer (sp, 4); + cache->saved_regs[op - 0x50] = offset; + offset -= 4; + pc++; + } } - return read_memory_unsigned_integer (get_frame_base (frame) + 4, 4); + return pc; } -/* Immediately after a function call, return the saved pc. */ - -static CORE_ADDR -i386_saved_pc_after_call (struct frame_info *frame) -{ - if (get_frame_type (frame) == SIGTRAMP_FRAME) - return i386_sigtramp_saved_pc (frame); - - return read_memory_unsigned_integer (read_register (SP_REGNUM), 4); -} +/* Do a full analysis of the prologue at PC and update CACHE + accordingly. Bail out early if CURRENT_PC is reached. Return the + address where the analysis stopped. -/* Parse the first few instructions the function to see what registers - were stored. - We handle these cases: The startup sequence can be at the start of the function, or the @@ -632,79 +592,43 @@ i386_saved_pc_after_call (struct frame_info *frame) If the setup sequence is at the end of the function, then the next instruction will be a branch back to the start. */ -static void -i386_frame_init_saved_regs (struct frame_info *fip) +static CORE_ADDR +i386_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc, + struct i386_frame_cache *cache) { - long locals = -1; - unsigned char op; - CORE_ADDR addr; - CORE_ADDR pc; - int i; - - if (get_frame_saved_regs (fip)) - return; - - frame_saved_regs_zalloc (fip); - - pc = get_frame_func (fip); - if (pc != 0) - locals = i386_get_frame_setup (pc); - - if (locals >= 0) - { - addr = get_frame_base (fip) - 4 - locals; - for (i = 0; i < 8; i++) - { - op = codestream_get (); - if (op < 0x50 || op > 0x57) - break; -#ifdef I386_REGNO_TO_SYMMETRY - /* Dynix uses different internal numbering. Ick. */ - get_frame_saved_regs (fip)[I386_REGNO_TO_SYMMETRY (op - 0x50)] = addr; -#else - get_frame_saved_regs (fip)[op - 0x50] = addr; -#endif - addr -= 4; - } - } - - get_frame_saved_regs (fip)[PC_REGNUM] = get_frame_base (fip) + 4; - get_frame_saved_regs (fip)[DEPRECATED_FP_REGNUM] = get_frame_base (fip); + pc = i386_follow_jump (pc); + pc = i386_analyze_struct_return (pc, current_pc, cache); + pc = i386_skip_probe (pc); + pc = i386_analyze_frame_setup (pc, current_pc, cache); + return i386_analyze_register_saves (pc, current_pc, cache); } /* Return PC of first real instruction. */ static CORE_ADDR -i386_skip_prologue (CORE_ADDR pc) +i386_skip_prologue (CORE_ADDR start_pc) { - unsigned char op; - int i; static unsigned char pic_pat[6] = - { 0xe8, 0, 0, 0, 0, /* call 0x0 */ - 0x5b, /* popl %ebx */ + { + 0xe8, 0, 0, 0, 0, /* call 0x0 */ + 0x5b, /* popl %ebx */ }; - CORE_ADDR pos; - - if (i386_get_frame_setup (pc) < 0) - return (pc); + struct i386_frame_cache cache; + CORE_ADDR pc; + unsigned char op; + int i; - /* Found valid frame setup -- codestream now points to start of push - instructions for saving registers. */ + cache.locals = -1; + pc = i386_analyze_prologue (start_pc, 0xffffffff, &cache); + if (cache.locals < 0) + return start_pc; - /* Skip over register saves. */ - for (i = 0; i < 8; i++) - { - op = codestream_peek (); - /* Break if not `pushl' instrunction. */ - if (op < 0x50 || op > 0x57) - break; - codestream_get (); - } + /* Found valid frame setup. */ /* The native cc on SVR4 in -K PIC mode inserts the following code to get the address of the global offset table (GOT) into register - %ebx - + %ebx: + call 0x0 popl %ebx movl %ebx,x(%ebp) (optional) @@ -714,110 +638,335 @@ i386_skip_prologue (CORE_ADDR pc) function), so we have to skip it to get to the first real instruction at the start of the function. */ - pos = codestream_tell (); for (i = 0; i < 6; i++) { - op = codestream_get (); + op = read_memory_unsigned_integer (pc + i, 1); if (pic_pat[i] != op) break; } if (i == 6) { - unsigned char buf[4]; - long delta = 6; + int delta = 6; + + op = read_memory_unsigned_integer (pc + delta, 1); - op = codestream_get (); if (op == 0x89) /* movl %ebx, x(%ebp) */ { - op = codestream_get (); + op = read_memory_unsigned_integer (pc + delta + 1, 1); + if (op == 0x5d) /* One byte offset from %ebp. */ - { - delta += 3; - codestream_read (buf, 1); - } + delta += 3; else if (op == 0x9d) /* Four byte offset from %ebp. */ - { - delta += 6; - codestream_read (buf, 4); - } + delta += 6; else /* Unexpected instruction. */ - delta = -1; - op = codestream_get (); + delta = 0; + + op = read_memory_unsigned_integer (pc + delta, 1); } + /* addl y,%ebx */ - if (delta > 0 && op == 0x81 && codestream_get () == 0xc3) + if (delta > 0 && op == 0x81 + && read_memory_unsigned_integer (pc + delta + 1, 1) == 0xc3); { - pos += delta + 6; + pc += delta + 6; } } - codestream_seek (pos); - - i386_follow_jump (); - return (codestream_tell ()); + return i386_follow_jump (pc); } -/* Use the program counter to determine the contents and size of a - breakpoint instruction. Return a pointer to a string of bytes that - encode a breakpoint instruction, store the length of the string in - *LEN and optionally adjust *PC to point to the correct memory - location for inserting the breakpoint. +/* This function is 64-bit safe. */ - On the i386 we have a single breakpoint that fits in a single byte - and can be inserted anywhere. */ - -static const unsigned char * -i386_breakpoint_from_pc (CORE_ADDR *pc, int *len) +static CORE_ADDR +i386_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) { - static unsigned char break_insn[] = { 0xcc }; /* int 3 */ - - *len = sizeof (break_insn); - return break_insn; + char buf[8]; + + frame_unwind_register (next_frame, PC_REGNUM, buf); + return extract_typed_address (buf, builtin_type_void_func_ptr); } + -/* Push the return address (pointing to the call dummy) onto the stack - and return the new value for the stack pointer. */ +/* Normal frames. */ -static CORE_ADDR -i386_push_return_address (CORE_ADDR pc, CORE_ADDR sp) +static struct i386_frame_cache * +i386_frame_cache (struct frame_info *next_frame, void **this_cache) { + struct i386_frame_cache *cache; char buf[4]; + int i; + + if (*this_cache) + return *this_cache; + + cache = i386_alloc_frame_cache (); + *this_cache = cache; + + /* In principle, for normal frames, %ebp holds the frame pointer, + which holds the base address for the current stack frame. + However, for functions that don't need it, the frame pointer is + optional. For these "frameless" functions the frame pointer is + actually the frame pointer of the calling frame. Signal + trampolines are just a special case of a "frameless" function. + They (usually) share their frame pointer with the frame that was + in progress when the signal occurred. */ + + frame_unwind_register (next_frame, I386_EBP_REGNUM, buf); + cache->base = extract_unsigned_integer (buf, 4); + if (cache->base == 0) + return cache; + + /* For normal frames, %eip is stored at 4(%ebp). */ + cache->saved_regs[I386_EIP_REGNUM] = 4; + + cache->pc = frame_func_unwind (next_frame); + if (cache->pc != 0) + i386_analyze_prologue (cache->pc, frame_pc_unwind (next_frame), cache); + + if (cache->locals < 0) + { + /* We didn't find a valid frame, which means that CACHE->base + currently holds the frame pointer for our calling frame. If + we're at the start of a function, or somewhere half-way its + prologue, the function's frame probably hasn't been fully + setup yet. Try to reconstruct the base address for the stack + frame by looking at the stack pointer. For truly "frameless" + functions this might work too. */ + + frame_unwind_register (next_frame, I386_ESP_REGNUM, buf); + cache->base = extract_unsigned_integer (buf, 4) + cache->sp_offset; + } + + /* Now that we have the base address for the stack frame we can + calculate the value of %esp in the calling frame. */ + cache->saved_sp = cache->base + 8; - store_unsigned_integer (buf, 4, CALL_DUMMY_ADDRESS ()); - write_memory (sp - 4, buf, 4); - return sp - 4; + /* Adjust all the saved registers such that they contain addresses + instead of offsets. */ + for (i = 0; i < I386_NUM_SAVED_REGS; i++) + if (cache->saved_regs[i] != -1) + cache->saved_regs[i] += cache->base; + + return cache; } static void -i386_do_pop_frame (struct frame_info *frame) +i386_frame_this_id (struct frame_info *next_frame, void **this_cache, + struct frame_id *this_id) { - CORE_ADDR fp; - int regnum; - char regbuf[I386_MAX_REGISTER_SIZE]; + struct i386_frame_cache *cache = i386_frame_cache (next_frame, this_cache); + + /* This marks the outermost frame. */ + if (cache->base == 0) + return; + + (*this_id) = frame_id_build (cache->base + 8, cache->pc); +} + +static void +i386_frame_prev_register (struct frame_info *next_frame, void **this_cache, + int regnum, int *optimizedp, + enum lval_type *lvalp, CORE_ADDR *addrp, + int *realnump, void *valuep) +{ + struct i386_frame_cache *cache = i386_frame_cache (next_frame, this_cache); + + gdb_assert (regnum >= 0); + + /* The System V ABI says that: + + "The flags register contains the system flags, such as the + direction flag and the carry flag. The direction flag must be + set to the forward (that is, zero) direction before entry and + upon exit from a function. Other user flags have no specified + role in the standard calling sequence and are not preserved." + + To guarantee the "upon exit" part of that statement we fake a + saved flags register that has its direction flag cleared. + + Note that GCC doesn't seem to rely on the fact that the direction + flag is cleared after a function return; it always explicitly + clears the flag before operations where it matters. + + FIXME: kettenis/20030316: I'm not quite sure whether this is the + right thing to do. The way we fake the flags register here makes + it impossible to change it. */ + + if (regnum == I386_EFLAGS_REGNUM) + { + *optimizedp = 0; + *lvalp = not_lval; + *addrp = 0; + *realnump = -1; + if (valuep) + { + ULONGEST val; - fp = get_frame_base (frame); - i386_frame_init_saved_regs (frame); + /* Clear the direction flag. */ + frame_unwind_unsigned_register (next_frame, PS_REGNUM, &val); + val &= ~(1 << 10); + store_unsigned_integer (valuep, 4, val); + } + + return; + } - for (regnum = 0; regnum < NUM_REGS; regnum++) + if (regnum == I386_EIP_REGNUM && cache->pc_in_eax) { - CORE_ADDR addr; - addr = get_frame_saved_regs (frame)[regnum]; - if (addr) + frame_register_unwind (next_frame, I386_EAX_REGNUM, + optimizedp, lvalp, addrp, realnump, valuep); + return; + } + + if (regnum == I386_ESP_REGNUM && cache->saved_sp) + { + *optimizedp = 0; + *lvalp = not_lval; + *addrp = 0; + *realnump = -1; + if (valuep) { - read_memory (addr, regbuf, REGISTER_RAW_SIZE (regnum)); - deprecated_write_register_gen (regnum, regbuf); + /* Store the value. */ + store_unsigned_integer (valuep, 4, cache->saved_sp); } + return; } - write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, 4)); - write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); - write_register (SP_REGNUM, fp + 8); - flush_cached_frames (); + + if (regnum < I386_NUM_SAVED_REGS && cache->saved_regs[regnum] != -1) + { + *optimizedp = 0; + *lvalp = lval_memory; + *addrp = cache->saved_regs[regnum]; + *realnump = -1; + if (valuep) + { + /* Read the value in from memory. */ + read_memory (*addrp, valuep, + register_size (current_gdbarch, regnum)); + } + return; + } + + frame_register_unwind (next_frame, regnum, + optimizedp, lvalp, addrp, realnump, valuep); +} + +static const struct frame_unwind i386_frame_unwind = +{ + NORMAL_FRAME, + i386_frame_this_id, + i386_frame_prev_register +}; + +static const struct frame_unwind * +i386_frame_p (CORE_ADDR pc) +{ + return &i386_frame_unwind; +} + + +/* Signal trampolines. */ + +static struct i386_frame_cache * +i386_sigtramp_frame_cache (struct frame_info *next_frame, void **this_cache) +{ + struct i386_frame_cache *cache; + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + CORE_ADDR addr; + char buf[4]; + + if (*this_cache) + return *this_cache; + + cache = i386_alloc_frame_cache (); + + frame_unwind_register (next_frame, I386_ESP_REGNUM, buf); + cache->base = extract_unsigned_integer (buf, 4) - 4; + + addr = tdep->sigcontext_addr (next_frame); + cache->saved_regs[I386_EIP_REGNUM] = addr + tdep->sc_pc_offset; + cache->saved_regs[I386_ESP_REGNUM] = addr + tdep->sc_sp_offset; + + *this_cache = cache; + return cache; +} + +static void +i386_sigtramp_frame_this_id (struct frame_info *next_frame, void **this_cache, + struct frame_id *this_id) +{ + struct i386_frame_cache *cache = + i386_sigtramp_frame_cache (next_frame, this_cache); + + (*this_id) = frame_id_build (cache->base + 8, frame_pc_unwind (next_frame)); +} + +static void +i386_sigtramp_frame_prev_register (struct frame_info *next_frame, + void **this_cache, + int regnum, int *optimizedp, + enum lval_type *lvalp, CORE_ADDR *addrp, + int *realnump, void *valuep) +{ + /* Make sure we've initialized the cache. */ + i386_sigtramp_frame_cache (next_frame, this_cache); + + i386_frame_prev_register (next_frame, this_cache, regnum, + optimizedp, lvalp, addrp, realnump, valuep); } +static const struct frame_unwind i386_sigtramp_frame_unwind = +{ + SIGTRAMP_FRAME, + i386_sigtramp_frame_this_id, + i386_sigtramp_frame_prev_register +}; + +static const struct frame_unwind * +i386_sigtramp_frame_p (CORE_ADDR pc) +{ + char *name; + + find_pc_partial_function (pc, &name, NULL, NULL); + if (PC_IN_SIGTRAMP (pc, name)) + return &i386_sigtramp_frame_unwind; + + return NULL; +} + + +static CORE_ADDR +i386_frame_base_address (struct frame_info *next_frame, void **this_cache) +{ + struct i386_frame_cache *cache = i386_frame_cache (next_frame, this_cache); + + return cache->base; +} + +static const struct frame_base i386_frame_base = +{ + &i386_frame_unwind, + i386_frame_base_address, + i386_frame_base_address, + i386_frame_base_address +}; + static void -i386_pop_frame (void) +i386_save_dummy_frame_tos (CORE_ADDR sp) { - generic_pop_current_frame (i386_do_pop_frame); + generic_save_dummy_frame_tos (sp + 8); +} + +static struct frame_id +i386_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) +{ + char buf[4]; + CORE_ADDR fp; + + frame_unwind_register (next_frame, I386_EBP_REGNUM, buf); + fp = extract_unsigned_integer (buf, 4); + + return frame_id_build (fp + 8, frame_pc_unwind (next_frame)); } @@ -825,7 +974,9 @@ i386_pop_frame (void) stack. We expect the first arg to be a pointer to the jmp_buf structure from which we extract the address that we will land at. This address is copied into PC. This routine returns non-zero on - success. */ + success. + + This function is 64-bit safe. */ static int i386_get_longjmp_target (CORE_ADDR *pc) @@ -854,28 +1005,57 @@ i386_get_longjmp_target (CORE_ADDR *pc) static CORE_ADDR -i386_push_arguments (int nargs, struct value **args, CORE_ADDR sp, - int struct_return, CORE_ADDR struct_addr) +i386_push_dummy_call (struct gdbarch *gdbarch, struct regcache *regcache, + CORE_ADDR dummy_addr, int nargs, struct value **args, + CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr) { - sp = legacy_push_arguments (nargs, args, sp, struct_return, struct_addr); - - if (struct_return) + char buf[4]; + int i; + + /* Push arguments in reverse order. */ + for (i = nargs - 1; i >= 0; i--) { - char buf[4]; + int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i])); + + /* The System V ABI says that: + + "An argument's size is increased, if necessary, to make it a + multiple of [32-bit] words. This may require tail padding, + depending on the size of the argument." + + This makes sure the stack says word-aligned. */ + sp -= (len + 3) & ~3; + write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len); + } + /* Push value address. */ + if (struct_return) + { sp -= 4; store_unsigned_integer (buf, 4, struct_addr); write_memory (sp, buf, 4); } + /* Store return address. */ + sp -= 4; + store_unsigned_integer (buf, 4, dummy_addr); + write_memory (sp, buf, 4); + + /* Finally, update the stack pointer... */ + store_unsigned_integer (buf, 4, sp); + regcache_cooked_write (regcache, I386_ESP_REGNUM, buf); + + /* ...and fake a frame pointer. */ + regcache_cooked_write (regcache, I386_EBP_REGNUM, buf); + return sp; } /* These registers are used for returning integers (and on some targets also for returning `struct' and `union' values when their size and alignment match an integer type). */ -#define LOW_RETURN_REGNUM 0 /* %eax */ -#define HIGH_RETURN_REGNUM 2 /* %edx */ +#define LOW_RETURN_REGNUM I386_EAX_REGNUM /* %eax */ +#define HIGH_RETURN_REGNUM I386_EDX_REGNUM /* %edx */ /* Extract from an array REGBUF containing the (raw) register state, a function return value of TYPE, and copy that, in virtual format, @@ -909,7 +1089,7 @@ i386_extract_return_value (struct type *type, struct regcache *regcache, its contents to the desired type. This is probably not exactly how it would happen on the target itself, but it is the best we can do. */ - regcache_raw_read (regcache, FP0_REGNUM, buf); + regcache_raw_read (regcache, I386_ST0_REGNUM, buf); convert_typed_floating (buf, builtin_type_i387_ext, valbuf, type); } else @@ -971,7 +1151,7 @@ i386_store_return_value (struct type *type, struct regcache *regcache, not exactly how it would happen on the target itself, but it is the best we can do. */ convert_typed_floating (valbuf, type, buf, builtin_type_i387_ext); - regcache_raw_write (regcache, FP0_REGNUM, buf); + regcache_raw_write (regcache, I386_ST0_REGNUM, buf); /* Set the top of the floating-point register stack to 7. The actual value doesn't really matter, but 7 is what a normal @@ -1012,10 +1192,10 @@ i386_store_return_value (struct type *type, struct regcache *regcache, static CORE_ADDR i386_extract_struct_value_address (struct regcache *regcache) { - ULONGEST addr; + char buf[4]; - regcache_raw_read_unsigned (regcache, LOW_RETURN_REGNUM, &addr); - return addr; + regcache_cooked_read (regcache, I386_EAX_REGNUM, buf); + return extract_unsigned_integer (buf, 4); } @@ -1057,7 +1237,8 @@ i386_use_struct_convention (int gcc_p, struct type *type) static struct type * i386_register_type (struct gdbarch *gdbarch, int regnum) { - if (regnum == PC_REGNUM || regnum == DEPRECATED_FP_REGNUM || regnum == SP_REGNUM) + if (regnum == I386_EIP_REGNUM + || regnum == I386_EBP_REGNUM || regnum == I386_ESP_REGNUM) return lookup_pointer_type (builtin_type_void); if (i386_fp_regnum_p (regnum)) @@ -1073,7 +1254,7 @@ i386_register_type (struct gdbarch *gdbarch, int regnum) } /* Map a cooked register onto a raw register or memory. For the i386, - the MMX registers need to be mapped onto floating-point registers. */ + the MMX registers need to be mapped onto floating point registers. */ static int i386_mmx_regnum_to_fp_regnum (struct regcache *regcache, int regnum) @@ -1274,36 +1455,27 @@ i386_print_insn (bfd_vma pc, disassemble_info *info) static int i386_svr4_pc_in_sigtramp (CORE_ADDR pc, char *name) { + /* UnixWare uses _sigacthandler. The origin of the other symbols is + currently unknown. */ return (name && (strcmp ("_sigreturn", name) == 0 || strcmp ("_sigacthandler", name) == 0 || strcmp ("sigvechandler", name) == 0)); } -/* Get address of the pushed ucontext (sigcontext) on the stack for - all three variants of SVR4 sigtramps. */ +/* Assuming NEXT_FRAME is for a frame following a SVR4 sigtramp + routine, return the address of the associated sigcontext (ucontext) + structure. */ static CORE_ADDR -i386_svr4_sigcontext_addr (struct frame_info *frame) +i386_svr4_sigcontext_addr (struct frame_info *next_frame) { - int sigcontext_offset = -1; - char *name = NULL; - - find_pc_partial_function (get_frame_pc (frame), &name, NULL, NULL); - if (name) - { - if (strcmp (name, "_sigreturn") == 0) - sigcontext_offset = 132; - else if (strcmp (name, "_sigacthandler") == 0) - sigcontext_offset = 80; - else if (strcmp (name, "sigvechandler") == 0) - sigcontext_offset = 120; - } + char buf[4]; + CORE_ADDR sp; - gdb_assert (sigcontext_offset != -1); + frame_unwind_register (next_frame, I386_ESP_REGNUM, buf); + sp = extract_unsigned_integer (buf, 4); - if (get_next_frame (frame)) - return get_frame_base (get_next_frame (frame)) + sigcontext_offset; - return read_register (SP_REGNUM) + sigcontext_offset; + return read_memory_unsigned_integer (sp + 8, 4); } @@ -1342,8 +1514,8 @@ i386_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) set_gdbarch_pc_in_sigtramp (gdbarch, i386_svr4_pc_in_sigtramp); tdep->sigcontext_addr = i386_svr4_sigcontext_addr; - tdep->sc_pc_offset = 14 * 4; - tdep->sc_sp_offset = 7 * 4; + tdep->sc_pc_offset = 36 + 14 * 4; + tdep->sc_sp_offset = 36 + 17 * 4; tdep->jb_pc_offset = 20; } @@ -1407,6 +1579,7 @@ i386_register_reggroup_p (struct gdbarch *gdbarch, int regnum, int fp_regnum_p = (i386_fp_regnum_p (regnum) || i386_fpc_regnum_p (regnum)); int mmx_regnum_p = (i386_mmx_regnum_p (regnum)); + if (group == i386_mmx_reggroup) return mmx_regnum_p; if (group == i386_sse_reggroup) @@ -1417,10 +1590,11 @@ i386_register_reggroup_p (struct gdbarch *gdbarch, int regnum, return fp_regnum_p; if (group == general_reggroup) return (!fp_regnum_p && !mmx_regnum_p && !sse_regnum_p); + return default_register_reggroup_p (gdbarch, regnum, group); } - + static struct gdbarch * i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) { @@ -1436,10 +1610,6 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) tdep = XMALLOC (struct gdbarch_tdep); gdbarch = gdbarch_alloc (&info, tdep); - /* NOTE: cagney/2002-12-06: This can be deleted when this arch is - ready to unwind the PC first (see frame.c:get_prev_frame()). */ - set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default); - /* The i386 default settings don't include the SSE registers. FIXME: kettenis/20020614: They do include the FPU registers for now, which probably is not quite right. */ @@ -1464,15 +1634,17 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) alignment. */ set_gdbarch_long_double_bit (gdbarch, 96); - /* NOTE: tm-i386aix.h, tm-i386bsd.h, tm-i386os9k.h, tm-ptx.h, - tm-symmetry.h currently override this. Sigh. */ + /* The default ABI includes general-purpose registers and + floating-point registers. */ set_gdbarch_num_regs (gdbarch, I386_NUM_GREGS + I386_NUM_FREGS); + set_gdbarch_register_name (gdbarch, i386_register_name); + set_gdbarch_register_type (gdbarch, i386_register_type); - set_gdbarch_sp_regnum (gdbarch, 4); /* %esp */ - set_gdbarch_deprecated_fp_regnum (gdbarch, 5); /* %ebp */ - set_gdbarch_pc_regnum (gdbarch, 8); /* %eip */ - set_gdbarch_ps_regnum (gdbarch, 9); /* %eflags */ - set_gdbarch_fp0_regnum (gdbarch, 16); /* %st(0) */ + /* Register numbers of various important registers. */ + set_gdbarch_sp_regnum (gdbarch, I386_ESP_REGNUM); /* %esp */ + set_gdbarch_pc_regnum (gdbarch, I386_EIP_REGNUM); /* %eip */ + set_gdbarch_ps_regnum (gdbarch, I386_EFLAGS_REGNUM); /* %eflags */ + set_gdbarch_fp0_regnum (gdbarch, I386_ST0_REGNUM); /* %st(0) */ /* Use the "default" register numbering scheme for stabs and COFF. */ set_gdbarch_stab_reg_to_regnum (gdbarch, i386_stab_reg_to_regnum); @@ -1485,39 +1657,24 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* We don't define ECOFF_REG_TO_REGNUM, since ECOFF doesn't seem to be in use on any of the supported i386 targets. */ - set_gdbarch_register_name (gdbarch, i386_register_name); - set_gdbarch_deprecated_register_size (gdbarch, 4); - set_gdbarch_deprecated_register_bytes (gdbarch, I386_SIZEOF_GREGS + I386_SIZEOF_FREGS); - set_gdbarch_register_type (gdbarch, i386_register_type); - set_gdbarch_print_float_info (gdbarch, i387_print_float_info); set_gdbarch_get_longjmp_target (gdbarch, i386_get_longjmp_target); /* Call dummy code. */ - set_gdbarch_deprecated_call_dummy_words (gdbarch, NULL); - set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0); + set_gdbarch_push_dummy_call (gdbarch, i386_push_dummy_call); set_gdbarch_register_convertible (gdbarch, i386_register_convertible); set_gdbarch_register_convert_to_virtual (gdbarch, i386_register_convert_to_virtual); set_gdbarch_register_convert_to_raw (gdbarch, i386_register_convert_to_raw); - /* "An argument's size is increased, if necessary, to make it a - multiple of [32-bit] words. This may require tail padding, - depending on the size of the argument" -- from the x86 ABI. */ - set_gdbarch_parm_boundary (gdbarch, 32); - set_gdbarch_extract_return_value (gdbarch, i386_extract_return_value); - set_gdbarch_deprecated_push_arguments (gdbarch, i386_push_arguments); - set_gdbarch_deprecated_push_return_address (gdbarch, i386_push_return_address); - set_gdbarch_deprecated_pop_frame (gdbarch, i386_pop_frame); set_gdbarch_store_return_value (gdbarch, i386_store_return_value); set_gdbarch_extract_struct_value_address (gdbarch, i386_extract_struct_value_address); set_gdbarch_use_struct_convention (gdbarch, i386_use_struct_convention); - set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, i386_frame_init_saved_regs); set_gdbarch_skip_prologue (gdbarch, i386_skip_prologue); /* Stack grows downward. */ @@ -1527,17 +1684,7 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_decr_pc_after_break (gdbarch, 1); set_gdbarch_function_start_offset (gdbarch, 0); - /* The following redefines make backtracing through sigtramp work. - They manufacture a fake sigtramp frame and obtain the saved pc in - sigtramp from the sigcontext structure which is pushed by the - kernel on the user stack, along with a pointer to it. */ - set_gdbarch_frame_args_skip (gdbarch, 8); - set_gdbarch_frameless_function_invocation (gdbarch, - i386_frameless_function_invocation); - set_gdbarch_deprecated_frame_chain (gdbarch, i386_frame_chain); - set_gdbarch_deprecated_frame_saved_pc (gdbarch, i386_frame_saved_pc); - set_gdbarch_deprecated_saved_pc_after_call (gdbarch, i386_saved_pc_after_call); set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown); set_gdbarch_pc_in_sigtramp (gdbarch, i386_pc_in_sigtramp); @@ -1548,16 +1695,23 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_print_insn (gdbarch, i386_print_insn); + set_gdbarch_unwind_dummy_id (gdbarch, i386_unwind_dummy_id); + set_gdbarch_save_dummy_frame_tos (gdbarch, i386_save_dummy_frame_tos); + + set_gdbarch_unwind_pc (gdbarch, i386_unwind_pc); + /* Add the i386 register groups. */ i386_add_reggroups (gdbarch); set_gdbarch_register_reggroup_p (gdbarch, i386_register_reggroup_p); - /* Should be using push_dummy_call. */ - set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp); + frame_base_set_default (gdbarch, &i386_frame_base); /* Hook in ABI-specific overrides, if they have been registered. */ gdbarch_init_osabi (info, gdbarch); + frame_unwind_append_predicate (gdbarch, i386_sigtramp_frame_p); + frame_unwind_append_predicate (gdbarch, i386_frame_p); + return gdbarch; } diff --git a/gdb/i386-tdep.h b/gdb/i386-tdep.h index 1b569d9..b2c2dff 100644 --- a/gdb/i386-tdep.h +++ b/gdb/i386-tdep.h @@ -136,8 +136,6 @@ extern int i386_mxcsr_regnum_p (int regnum); #define FCOFF_REGNUM FIOFF_REGNUM #define FDS_REGNUM FOSEG_REGNUM #define FDOFF_REGNUM FOOFF_REGNUM -#define IS_FP_REGNUM(n) i386_fp_regnum_p (n) -#define IS_SSE_REGNUM(n) i386_sse_regnum_p (n) #define I386_NUM_GREGS 16 #define I386_NUM_FREGS 16 @@ -146,16 +144,6 @@ extern int i386_mxcsr_regnum_p (int regnum); #define I386_SSE_NUM_REGS (I386_NUM_GREGS + I386_NUM_FREGS \ + I386_NUM_XREGS) -/* Sizes of individual register sets. These cover the entire register - file, so summing up the sizes of those portions actually present - yields DEPRECATED_REGISTER_BYTES. */ -#define I386_SIZEOF_GREGS (I386_NUM_GREGS * 4) -#define I386_SIZEOF_FREGS (8 * 10 + 8 * 4) -#define I386_SIZEOF_XREGS (8 * 16 + 4) - -#define I386_SSE_SIZEOF_REGS (I386_SIZEOF_GREGS + I386_SIZEOF_FREGS \ - + I386_SIZEOF_XREGS) - /* Size of the largest register. */ #define I386_MAX_REGISTER_SIZE 16 @@ -178,7 +166,6 @@ extern void i386_svr4_init_abi (struct gdbarch_info, struct gdbarch *); /* Functions exported from i386bsd-tdep.c. */ -extern CORE_ADDR i386bsd_sigcontext_addr (struct frame_info *frame); extern void i386bsd_init_abi (struct gdbarch_info, struct gdbarch *); #endif /* i386-tdep.h */ diff --git a/gdb/i386bsd-tdep.c b/gdb/i386bsd-tdep.c index c0c544d..d91be26 100644 --- a/gdb/i386bsd-tdep.c +++ b/gdb/i386bsd-tdep.c @@ -41,26 +41,19 @@ i386bsd_pc_in_sigtramp (CORE_ADDR pc, char *name) return (pc >= tdep->sigtramp_start && pc < tdep->sigtramp_end); } -/* Assuming FRAME is for a BSD sigtramp routine, return the address of - the associated sigcontext structure. +/* Assuming NEXT_FRAME is for a frame following a BSD sigtramp + routine, return the address of the associated sigcontext structure. */ - Note: This function is used for Solaris 2 too, so don't make it - static. */ - -CORE_ADDR -i386bsd_sigcontext_addr (struct frame_info *frame) +static CORE_ADDR +i386bsd_sigcontext_addr (struct frame_info *next_frame) { - struct frame_info *next_frame = get_next_frame (frame); + char buf[4]; + CORE_ADDR sp; - if (next_frame) - /* If this isn't the top frame, the next frame must be for the - signal handler itself. A pointer to the sigcontext structure - is passed as the third argument to the signal handler. */ - return read_memory_unsigned_integer (get_frame_base (next_frame) + 16, 4); + frame_unwind_register (next_frame, SP_REGNUM, buf); + sp = extract_unsigned_integer (buf, 4); - /* This is the top frame. We'll have to find the address of the - sigcontext structure by looking at the stack pointer. */ - return read_memory_unsigned_integer (read_register (SP_REGNUM) + 8, 4); + return read_memory_unsigned_integer (sp + 8, 4); } /* Return the start address of the sigtramp routine. */ |