From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 1085 invoked by alias); 7 Jun 2007 21:00:25 -0000 Received: (qmail 1042 invoked by uid 22791); 7 Jun 2007 21:00:22 -0000 X-Spam-Check-By: sourceware.org Received: from mtagate2.de.ibm.com (HELO mtagate2.de.ibm.com) (195.212.29.151) by sourceware.org (qpsmtpd/0.31) with ESMTP; Thu, 07 Jun 2007 21:00:17 +0000 Received: from d12nrmr1607.megacenter.de.ibm.com (d12nrmr1607.megacenter.de.ibm.com [9.149.167.49]) by mtagate2.de.ibm.com (8.13.8/8.13.8) with ESMTP id l57L0EVZ092968 for ; Thu, 7 Jun 2007 21:00:14 GMT Received: from d12av02.megacenter.de.ibm.com (d12av02.megacenter.de.ibm.com [9.149.165.228]) by d12nrmr1607.megacenter.de.ibm.com (8.13.8/8.13.8/NCO v8.3) with ESMTP id l57L0Eu43719214 for ; Thu, 7 Jun 2007 23:00:14 +0200 Received: from d12av02.megacenter.de.ibm.com (loopback [127.0.0.1]) by d12av02.megacenter.de.ibm.com (8.12.11.20060308/8.13.3) with ESMTP id l57L0EWG020694 for ; Thu, 7 Jun 2007 23:00:14 +0200 Received: from tuxmaker.boeblingen.de.ibm.com (tuxmaker.boeblingen.de.ibm.com [9.152.85.9]) by d12av02.megacenter.de.ibm.com (8.12.11.20060308/8.12.11) with SMTP id l57L0EHw020691 for ; Thu, 7 Jun 2007 23:00:14 +0200 Message-Id: <200706072100.l57L0EHw020691@d12av02.megacenter.de.ibm.com> Received: by tuxmaker.boeblingen.de.ibm.com (sSMTP sendmail emulation); Thu, 7 Jun 2007 23:00:14 +0200 Subject: [rfc][9/13] Eliminate read_register: Uses in skip_trampoline callbacks To: gdb-patches@sourceware.org Date: Thu, 07 Jun 2007 21:00:00 -0000 From: "Ulrich Weigand" X-Mailer: ELM [version 2.5 PL2] MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2007-06/txt/msg00088.txt.bz2 Hello, another callback that forces its implementations to access global state: SKIP_TRAMPOLINE_CODE and its various subroutines, including the langhook skip_trampoline and the C++ ABI hook skip_trampoline. This patch adds a FRAME argument to those callbacks, passes in the current frame from infrun.c, and uses the passed-through frame to access registers in all implementations. Bye, Ulrich ChangeLog: * gdbarch.sh (skip_trampoline_code): Add FRAME argument. * gdbarch.c, gdbarch.h: Regenerate. * arch-utils.c (generic_skip_trampoline_code): Add FRAME argument. * arch-utils.h (generic_skip_trampoline_code): Likewise. * infrun.c (handle_inferior_event): Pass current frame to SKIP_TRAMPOLINE_CODE and skip_language_trampoline. * language.c (unk_lang_trampoline): Add FRAME argument. (skip_language_trampoline): Add FRAME argument. Pass it to skip_trampoline callback. * language.h: Add forward declaration of struct frame_info. (struct language_defn): Add FRAME argument to skip_trampoline. (skip_language_trampoline): Add FRAME argument. * cp-abi.c (cplus_skip_trampoline): Add FRAME argument. Pass it to skip_trampoline callback. * cp-abi.h: Add forward declaration of struct frame_info. (cplus_skip_trampoline): Add FRAME argument. (struct cp_abi_ops): Add FRAME argument to skip_trampoline callback. * gnu-v3-abi.c (gnuv3_skip_trampoline): Add FRAME argument. Pass it to SKIP_TRAMPOLINE_CODE. * objc-lang.c (objc_skip_trampoline): Add FRAME argument. Pass it to SKIP_TRAMPOLINE_CODE. * minsyms.c (find_solib_trampoline_target): Add FRAME argument. * symtab.h (find_solib_trampoline_target): Likewise. * obsd-tdep.c (obsd_skip_solib_resolver): Pass current frame to find_solib_trampoline_target. * arm-tdep.c (arm_skip_stub): Add FRAME argument. Read registers from FRAME instead of calling read_register. * hppa-hpux-tdep.c (hppa_hpux_skip_trampoline_code): Add FRAME argument. Read registers from FRAME instead of using read_register. * hppa-tdep.c (hppa_skip_trampoline_code): Likewise. * hppa-tdep.h (hppa_skip_trampoline_code): Add FRAME argument. * i386-cygwin-tdep.c (i386_cygwin_skip_trampoline_code): Add FRAME argument. * m32c-tdep.c (m32c_skip_trampoline_code): Add FRAME argument. * mips-tdep.c (mips_skip_trampoline_code): Add FRAME argument. Read registers from FRAME instead of using read_signed_register. * ppc-linux-tdep.c (ppc_linux_skip_trampoline_code): Add FRAME argument. (ppc64_standard_linkage_target): Likewise. Read registers from FRAME instead of using read_register. (ppc64_skip_trampoline_code): Add FRAME argument. Pass it to ppc64_standard_linkage_target. * rs6000-tdep.c (rs6000_skip_trampoline_code): Add FRAME argument. Pass it to find_solib_trampoline_target. Read registers from FRAME instead of using read_register. * xstormy16-tdep.c (xstormy16_skip_trampoline_code): Add FRAME argument. diff -urNp gdb-orig/gdb/arch-utils.c gdb-head/gdb/arch-utils.c --- gdb-orig/gdb/arch-utils.c 2007-06-06 17:25:20.071647000 +0200 +++ gdb-head/gdb/arch-utils.c 2007-06-06 19:00:46.850882655 +0200 @@ -96,7 +96,7 @@ legacy_register_sim_regno (int regnum) } CORE_ADDR -generic_skip_trampoline_code (CORE_ADDR pc) +generic_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) { return 0; } diff -urNp gdb-orig/gdb/arch-utils.h gdb-head/gdb/arch-utils.h --- gdb-orig/gdb/arch-utils.h 2007-06-04 22:23:11.000000000 +0200 +++ gdb-head/gdb/arch-utils.h 2007-06-06 19:00:46.854882080 +0200 @@ -77,7 +77,8 @@ int cannot_register_not (int regnum); extern gdbarch_virtual_frame_pointer_ftype legacy_virtual_frame_pointer; -extern CORE_ADDR generic_skip_trampoline_code (CORE_ADDR pc); +extern CORE_ADDR generic_skip_trampoline_code (struct frame_info *frame, + CORE_ADDR pc); extern CORE_ADDR generic_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc); diff -urNp gdb-orig/gdb/arm-tdep.c gdb-head/gdb/arm-tdep.c --- gdb-orig/gdb/arm-tdep.c 2007-06-06 19:00:38.597873893 +0200 +++ gdb-head/gdb/arm-tdep.c 2007-06-06 19:00:46.863880785 +0200 @@ -2373,7 +2373,7 @@ arm_in_call_stub (CORE_ADDR pc, char *na are r0-r9, sl, fp, ip, sp, and lr. */ CORE_ADDR -arm_skip_stub (CORE_ADDR pc) +arm_skip_stub (struct frame_info *frame, CORE_ADDR pc) { char *name; CORE_ADDR start_addr; @@ -2395,7 +2395,7 @@ arm_skip_stub (CORE_ADDR pc) for (regno = 0; regno <= 14; regno++) if (strcmp (&name[10], table[regno]) == 0) - return read_register (regno); + return get_frame_register_unsigned (frame, regno); } return 0; /* not a stub */ diff -urNp gdb-orig/gdb/cp-abi.c gdb-head/gdb/cp-abi.c --- gdb-orig/gdb/cp-abi.c 2007-06-04 22:23:11.000000000 +0200 +++ gdb-head/gdb/cp-abi.c 2007-06-06 19:00:46.868880066 +0200 @@ -122,11 +122,11 @@ cplus_make_method_ptr (gdb_byte *content } CORE_ADDR -cplus_skip_trampoline (CORE_ADDR stop_pc) +cplus_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc) { if (current_cp_abi.skip_trampoline == NULL) return 0; - return (*current_cp_abi.skip_trampoline) (stop_pc); + return (*current_cp_abi.skip_trampoline) (frame, stop_pc); } struct value * diff -urNp gdb-orig/gdb/cp-abi.h gdb-head/gdb/cp-abi.h --- gdb-orig/gdb/cp-abi.h 2007-06-04 22:23:11.000000000 +0200 +++ gdb-head/gdb/cp-abi.h 2007-06-06 19:00:46.872879490 +0200 @@ -31,6 +31,7 @@ struct fn_field; struct type; struct value; struct ui_file; +struct frame_info; /* The functions here that attempt to determine what sort of thing a mangled name refers to may well be revised in the future. It would @@ -173,7 +174,7 @@ void cplus_make_method_ptr (gdb_byte *CO /* Determine if we are currently in a C++ thunk. If so, get the address of the routine we are thunking to and continue to there instead. */ -CORE_ADDR cplus_skip_trampoline (CORE_ADDR stop_pc); +CORE_ADDR cplus_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc); struct cp_abi_ops { @@ -197,7 +198,7 @@ struct cp_abi_ops int (*method_ptr_size) (void); void (*make_method_ptr) (gdb_byte *, CORE_ADDR, int); struct value * (*method_ptr_to_value) (struct value **, struct value *); - CORE_ADDR (*skip_trampoline) (CORE_ADDR); + CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR); }; diff -urNp gdb-orig/gdb/gdbarch.c gdb-head/gdb/gdbarch.c --- gdb-orig/gdb/gdbarch.c 2007-06-06 19:00:38.662864540 +0200 +++ gdb-head/gdb/gdbarch.c 2007-06-06 19:00:46.893876468 +0200 @@ -1314,8 +1314,8 @@ gdbarch_dump (struct gdbarch *current_gd #ifdef SKIP_TRAMPOLINE_CODE fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", - "SKIP_TRAMPOLINE_CODE(pc)", - XSTRING (SKIP_TRAMPOLINE_CODE (pc))); + "SKIP_TRAMPOLINE_CODE(frame, pc)", + XSTRING (SKIP_TRAMPOLINE_CODE (frame, pc))); #endif fprintf_unfiltered (file, "gdbarch_dump: skip_trampoline_code = <0x%lx>\n", @@ -3077,13 +3077,13 @@ set_gdbarch_print_insn (struct gdbarch * } CORE_ADDR -gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc) +gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc) { gdb_assert (gdbarch != NULL); gdb_assert (gdbarch->skip_trampoline_code != NULL); if (gdbarch_debug >= 2) fprintf_unfiltered (gdb_stdlog, "gdbarch_skip_trampoline_code called\n"); - return gdbarch->skip_trampoline_code (pc); + return gdbarch->skip_trampoline_code (frame, pc); } void diff -urNp gdb-orig/gdb/gdbarch.h gdb-head/gdb/gdbarch.h --- gdb-orig/gdb/gdbarch.h 2007-06-06 19:00:38.670863389 +0200 +++ gdb-head/gdb/gdbarch.h 2007-06-06 19:00:46.912873735 +0200 @@ -1000,14 +1000,14 @@ extern void set_gdbarch_print_insn (stru #define TARGET_PRINT_INSN(vma, info) (gdbarch_print_insn (current_gdbarch, vma, info)) #endif -typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (CORE_ADDR pc); -extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, CORE_ADDR pc); +typedef CORE_ADDR (gdbarch_skip_trampoline_code_ftype) (struct frame_info *frame, CORE_ADDR pc); +extern CORE_ADDR gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, struct frame_info *frame, CORE_ADDR pc); extern void set_gdbarch_skip_trampoline_code (struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype *skip_trampoline_code); #if !defined (GDB_TM_FILE) && defined (SKIP_TRAMPOLINE_CODE) #error "Non multi-arch definition of SKIP_TRAMPOLINE_CODE" #endif #if !defined (SKIP_TRAMPOLINE_CODE) -#define SKIP_TRAMPOLINE_CODE(pc) (gdbarch_skip_trampoline_code (current_gdbarch, pc)) +#define SKIP_TRAMPOLINE_CODE(frame, pc) (gdbarch_skip_trampoline_code (current_gdbarch, frame, pc)) #endif /* If IN_SOLIB_DYNSYM_RESOLVE_CODE returns true, and SKIP_SOLIB_RESOLVER diff -urNp gdb-orig/gdb/gdbarch.sh gdb-head/gdb/gdbarch.sh --- gdb-orig/gdb/gdbarch.sh 2007-06-06 19:00:38.678862238 +0200 +++ gdb-head/gdb/gdbarch.sh 2007-06-06 19:00:46.931871001 +0200 @@ -622,7 +622,7 @@ M::int:single_step_through_delay:struct # FIXME: cagney/2003-08-28: Need to find a better way of selecting the # disassembler. Perhaps objdump can handle it? f:TARGET_PRINT_INSN:int:print_insn:bfd_vma vma, struct disassemble_info *info:vma, info::0: -f:=:CORE_ADDR:skip_trampoline_code:CORE_ADDR pc:pc::generic_skip_trampoline_code::0 +f:=:CORE_ADDR:skip_trampoline_code:struct frame_info *frame, CORE_ADDR pc:frame, pc::generic_skip_trampoline_code::0 # If IN_SOLIB_DYNSYM_RESOLVE_CODE returns true, and SKIP_SOLIB_RESOLVER diff -urNp gdb-orig/gdb/gnu-v3-abi.c gdb-head/gdb/gnu-v3-abi.c --- gdb-orig/gdb/gnu-v3-abi.c 2007-06-04 22:23:11.000000000 +0200 +++ gdb-head/gdb/gnu-v3-abi.c 2007-06-06 19:00:46.936870281 +0200 @@ -678,14 +678,14 @@ gnuv3_method_ptr_to_value (struct value of the routine we are thunking to and continue to there instead. */ static CORE_ADDR -gnuv3_skip_trampoline (CORE_ADDR stop_pc) +gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc) { CORE_ADDR real_stop_pc, method_stop_pc; struct minimal_symbol *thunk_sym, *fn_sym; struct obj_section *section; char *thunk_name, *fn_name; - real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc); + real_stop_pc = SKIP_TRAMPOLINE_CODE (frame, stop_pc); if (real_stop_pc == 0) real_stop_pc = stop_pc; @@ -708,7 +708,7 @@ gnuv3_skip_trampoline (CORE_ADDR stop_pc return 0; method_stop_pc = SYMBOL_VALUE_ADDRESS (fn_sym); - real_stop_pc = SKIP_TRAMPOLINE_CODE (method_stop_pc); + real_stop_pc = SKIP_TRAMPOLINE_CODE (frame, method_stop_pc); if (real_stop_pc == 0) real_stop_pc = method_stop_pc; diff -urNp gdb-orig/gdb/hppa-hpux-tdep.c gdb-head/gdb/hppa-hpux-tdep.c --- gdb-orig/gdb/hppa-hpux-tdep.c 2007-06-06 18:56:32.593903385 +0200 +++ gdb-head/gdb/hppa-hpux-tdep.c 2007-06-06 19:00:46.954867691 +0200 @@ -299,7 +299,7 @@ hppa_hpux_in_solib_return_trampoline (CO used in dynamic executables. */ static CORE_ADDR -hppa_hpux_skip_trampoline_code (CORE_ADDR pc) +hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) { long orig_pc = pc; long prev_inst, curr_inst, loc; @@ -310,7 +310,7 @@ hppa_hpux_skip_trampoline_code (CORE_ADD of the function. So we may have to do something special. */ if (pc == hppa_symbol_address("$$dyncall")) { - pc = (CORE_ADDR) read_register (22); + pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22); /* If bit 30 (counting from the left) is on, then pc is the address of the PLT entry for this function, not the address of the function @@ -320,11 +320,11 @@ hppa_hpux_skip_trampoline_code (CORE_ADD } if (pc == hppa_symbol_address("$$dyncall_external")) { - pc = (CORE_ADDR) read_register (22); + pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22); pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8); } else if (pc == hppa_symbol_address("_sr4export")) - pc = (CORE_ADDR) (read_register (22)); + pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22); /* Get the unwind descriptor corresponding to PC, return zero if no unwind was found. */ @@ -498,8 +498,11 @@ hppa_hpux_skip_trampoline_code (CORE_ADD /* Yup. See if the previous instruction loaded rp from sp - 8. */ if (prev_inst == 0x4bc23ff1) - return (read_memory_integer - (read_register (HPPA_SP_REGNUM) - 8, 4)) & ~0x3; + { + CORE_ADDR sp; + sp = get_frame_register_unsigned (frame, HPPA_SP_REGNUM); + return read_memory_integer (sp - 8, 4) & ~0x3; + } else { warning (_("Unable to find restore of %%rp before bv (%%rp).")); @@ -512,8 +515,9 @@ hppa_hpux_skip_trampoline_code (CORE_ADD the PA2.0: BVE, n (rp) */ else if ((curr_inst & 0xffe0f000) == 0xe840d000) { - return (read_memory_integer - (read_register (HPPA_SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3; + CORE_ADDR sp; + sp = get_frame_register_unsigned (frame, HPPA_SP_REGNUM); + return read_memory_integer (sp - 24, TARGET_PTR_BIT / 8) & ~0x3; } /* What about be,n 0(sr0,%rp)? It's just another way we return to @@ -524,8 +528,9 @@ hppa_hpux_skip_trampoline_code (CORE_ADD loaded several instructions before the be instruction. I guess we could check for the previous instruction being mtsp %r1,%sr0 if we want to do sanity checking. */ - return (read_memory_integer - (read_register (HPPA_SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3; + CORE_ADDR sp; + sp = get_frame_register_unsigned (frame, HPPA_SP_REGNUM); + return read_memory_integer (sp - 24, TARGET_PTR_BIT / 8) & ~0x3; } /* Haven't found the branch yet, but we're still in the stub. diff -urNp gdb-orig/gdb/hppa-tdep.c gdb-head/gdb/hppa-tdep.c --- gdb-orig/gdb/hppa-tdep.c 2007-06-06 18:59:45.494403283 +0200 +++ gdb-head/gdb/hppa-tdep.c 2007-06-06 19:00:46.963866397 +0200 @@ -2934,7 +2934,7 @@ hppa_in_solib_call_trampoline (CORE_ADDR systems: $$dyncall, import stubs and PLT stubs. */ CORE_ADDR -hppa_skip_trampoline_code (CORE_ADDR pc) +hppa_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) { unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN]; int dp_rel; @@ -2942,7 +2942,7 @@ hppa_skip_trampoline_code (CORE_ADDR pc) /* $$dyncall handles both PLABELs and direct addresses. */ if (hppa_in_dyncall (pc)) { - pc = read_register (HPPA_R0_REGNUM + 22); + pc = get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 22); /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */ if (pc & 0x2) @@ -2958,9 +2958,9 @@ hppa_skip_trampoline_code (CORE_ADDR pc) pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]); if (dp_rel) - pc += read_register (HPPA_DP_REGNUM); + pc += get_frame_register_unsigned (frame, HPPA_DP_REGNUM); else - pc += read_register (HPPA_R0_REGNUM + 19); + pc += get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 19); /* fallthrough */ } diff -urNp gdb-orig/gdb/hppa-tdep.h gdb-head/gdb/hppa-tdep.h --- gdb-orig/gdb/hppa-tdep.h 2007-06-06 18:56:32.617899932 +0200 +++ gdb-head/gdb/hppa-tdep.h 2007-06-06 19:00:46.968865677 +0200 @@ -246,6 +246,6 @@ extern struct hppa_objfile_private * hppa_init_objfile_priv_data (struct objfile *objfile); extern int hppa_in_solib_call_trampoline (CORE_ADDR pc, char *name); -extern CORE_ADDR hppa_skip_trampoline_code (CORE_ADDR pc); +extern CORE_ADDR hppa_skip_trampoline_code (struct frame_info *, CORE_ADDR pc); #endif /* hppa-tdep.h */ diff -urNp gdb-orig/gdb/i386-cygwin-tdep.c gdb-head/gdb/i386-cygwin-tdep.c --- gdb-orig/gdb/i386-cygwin-tdep.c 2007-06-04 22:23:11.000000000 +0200 +++ gdb-head/gdb/i386-cygwin-tdep.c 2007-06-06 19:00:46.972999000 +0200 @@ -27,7 +27,7 @@ #include "i386-tdep.h" static CORE_ADDR -i386_cygwin_skip_trampoline_code (CORE_ADDR pc) +i386_cygwin_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) { return i386_pe_skip_trampoline_code (pc, NULL); } diff -urNp gdb-orig/gdb/infrun.c gdb-head/gdb/infrun.c --- gdb-orig/gdb/infrun.c 2007-06-06 19:00:38.689860655 +0200 +++ gdb-head/gdb/infrun.c 2007-06-06 19:00:46.993995978 +0200 @@ -2455,9 +2455,9 @@ process_event_stop_test: function. That's what tells us (a) whether we want to step into it at all, and (b) what prologue we want to run to the end of, if we do step into it. */ - real_stop_pc = skip_language_trampoline (stop_pc); + real_stop_pc = skip_language_trampoline (get_current_frame (), stop_pc); if (real_stop_pc == 0) - real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc); + real_stop_pc = SKIP_TRAMPOLINE_CODE (get_current_frame (), stop_pc); if (real_stop_pc != 0) ecs->stop_func_start = real_stop_pc; @@ -2518,7 +2518,8 @@ process_event_stop_test: if (IN_SOLIB_RETURN_TRAMPOLINE (stop_pc, ecs->stop_func_name)) { /* Determine where this trampoline returns. */ - CORE_ADDR real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc); + CORE_ADDR real_stop_pc; + real_stop_pc = SKIP_TRAMPOLINE_CODE (get_current_frame (), stop_pc); if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: stepped into solib return tramp\n"); diff -urNp gdb-orig/gdb/language.c gdb-head/gdb/language.c --- gdb-orig/gdb/language.c 2007-06-04 22:23:11.000000000 +0200 +++ gdb-head/gdb/language.c 2007-06-06 19:00:47.000994971 +0200 @@ -77,7 +77,7 @@ static void unk_lang_print_type (struct static int unk_lang_value_print (struct value *, struct ui_file *, int, enum val_prettyprint); -static CORE_ADDR unk_lang_trampoline (CORE_ADDR pc); +static CORE_ADDR unk_lang_trampoline (struct frame_info *, CORE_ADDR pc); /* Forward declaration */ extern const struct language_defn unknown_language_defn; @@ -1005,7 +1005,7 @@ add_language (const struct language_defn Return the result from the first that returns non-zero, or 0 if all `fail'. */ CORE_ADDR -skip_language_trampoline (CORE_ADDR pc) +skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc) { int i; @@ -1013,7 +1013,7 @@ skip_language_trampoline (CORE_ADDR pc) { if (languages[i]->skip_trampoline) { - CORE_ADDR real_pc = (languages[i]->skip_trampoline) (pc); + CORE_ADDR real_pc = (languages[i]->skip_trampoline) (frame, pc); if (real_pc) return real_pc; } @@ -1130,7 +1130,7 @@ unk_lang_value_print (struct value *val, error (_("internal error - unimplemented function unk_lang_value_print called.")); } -static CORE_ADDR unk_lang_trampoline (CORE_ADDR pc) +static CORE_ADDR unk_lang_trampoline (struct frame_info *frame, CORE_ADDR pc) { return 0; } diff -urNp gdb-orig/gdb/language.h gdb-head/gdb/language.h --- gdb-orig/gdb/language.h 2007-06-04 22:23:11.000000000 +0200 +++ gdb-head/gdb/language.h 2007-06-06 19:00:47.005994251 +0200 @@ -29,6 +29,7 @@ /* Forward decls for prototypes */ struct value; struct objfile; +struct frame_info; struct expression; struct ui_file; @@ -221,7 +222,7 @@ struct language_defn If that PC falls in a trampoline belonging to this language, return the address of the first pc in the real function, or 0 if it isn't a language tramp for this language. */ - CORE_ADDR (*skip_trampoline) (CORE_ADDR pc); + CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR); /* Now come some hooks for lookup_symbol. */ @@ -453,7 +454,7 @@ extern enum language get_frame_language /* Check for a language-specific trampoline. */ -extern CORE_ADDR skip_language_trampoline (CORE_ADDR pc); +extern CORE_ADDR skip_language_trampoline (struct frame_info *, CORE_ADDR pc); /* Return demangled language symbol, or NULL. */ extern char *language_demangle (const struct language_defn *current_language, diff -urNp gdb-orig/gdb/m32c-tdep.c gdb-head/gdb/m32c-tdep.c --- gdb-orig/gdb/m32c-tdep.c 2007-06-04 22:23:11.000000000 +0200 +++ gdb-head/gdb/m32c-tdep.c 2007-06-06 19:00:47.013993100 +0200 @@ -2332,7 +2332,7 @@ m32c_return_value (struct gdbarch *gdbar code sequence seems more fragile. */ static CORE_ADDR -m32c_skip_trampoline_code (CORE_ADDR stop_pc) +m32c_skip_trampoline_code (struct frame_info *frame, CORE_ADDR stop_pc) { struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); diff -urNp gdb-orig/gdb/minsyms.c gdb-head/gdb/minsyms.c --- gdb-orig/gdb/minsyms.c 2007-06-04 22:23:11.000000000 +0200 +++ gdb-head/gdb/minsyms.c 2007-06-06 19:00:47.019992237 +0200 @@ -1047,7 +1047,7 @@ lookup_solib_trampoline_symbol_by_pc (CO a duplicate function in case this matters someday. */ CORE_ADDR -find_solib_trampoline_target (CORE_ADDR pc) +find_solib_trampoline_target (struct frame_info *frame, CORE_ADDR pc) { struct objfile *objfile; struct minimal_symbol *msymbol; diff -urNp gdb-orig/gdb/mips-tdep.c gdb-head/gdb/mips-tdep.c --- gdb-orig/gdb/mips-tdep.c 2007-06-06 19:00:38.704858497 +0200 +++ gdb-head/gdb/mips-tdep.c 2007-06-06 19:00:47.033990223 +0200 @@ -4445,7 +4445,7 @@ mips_breakpoint_from_pc (CORE_ADDR *pcpt gory details. */ static CORE_ADDR -mips_skip_trampoline_code (CORE_ADDR pc) +mips_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) { char *name; CORE_ADDR start_addr; @@ -4458,14 +4458,14 @@ mips_skip_trampoline_code (CORE_ADDR pc) target PC is in $31 ($ra). */ if (strcmp (name, "__mips16_ret_sf") == 0 || strcmp (name, "__mips16_ret_df") == 0) - return read_signed_register (MIPS_RA_REGNUM); + return get_frame_register_signed (frame, MIPS_RA_REGNUM); if (strncmp (name, "__mips16_call_stub_", 19) == 0) { /* If the PC is in __mips16_call_stub_{1..10}, this is a call stub and the target PC is in $2. */ if (name[19] >= '0' && name[19] <= '9') - return read_signed_register (2); + return get_frame_register_signed (frame, 2); /* If the PC at the start of __mips16_call_stub_{s,d}f_{0..10}, i.e. before the jal instruction, this is effectively a call stub @@ -4487,7 +4487,7 @@ mips_skip_trampoline_code (CORE_ADDR pc) So scan down to the lui/addi and extract the target address from those two instructions. */ - CORE_ADDR target_pc = read_signed_register (2); + CORE_ADDR target_pc = get_frame_register_signed (frame, 2); ULONGEST inst; int i; @@ -4518,7 +4518,7 @@ mips_skip_trampoline_code (CORE_ADDR pc) else /* This is the 'return' part of a call stub. The return address is in $r18. */ - return read_signed_register (18); + return get_frame_register_signed (frame, 18); } } return 0; /* not a stub */ diff -urNp gdb-orig/gdb/objc-lang.c gdb-head/gdb/objc-lang.c --- gdb-orig/gdb/objc-lang.c 2007-06-06 17:41:52.697377000 +0200 +++ gdb-head/gdb/objc-lang.c 2007-06-06 19:00:47.040989215 +0200 @@ -571,12 +571,12 @@ objc_create_fundamental_type (struct obj for the user since they are only interested in stepping into the method function anyway. */ static CORE_ADDR -objc_skip_trampoline (CORE_ADDR stop_pc) +objc_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc) { CORE_ADDR real_stop_pc; CORE_ADDR method_stop_pc; - real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc); + real_stop_pc = SKIP_TRAMPOLINE_CODE (frame, stop_pc); if (real_stop_pc != 0) find_objc_msgcall (real_stop_pc, &method_stop_pc); @@ -585,7 +585,7 @@ objc_skip_trampoline (CORE_ADDR stop_pc) if (method_stop_pc) { - real_stop_pc = SKIP_TRAMPOLINE_CODE (method_stop_pc); + real_stop_pc = SKIP_TRAMPOLINE_CODE (frame, method_stop_pc); if (real_stop_pc == 0) real_stop_pc = method_stop_pc; } diff -urNp gdb-orig/gdb/obsd-tdep.c gdb-head/gdb/obsd-tdep.c --- gdb-orig/gdb/obsd-tdep.c 2007-06-04 22:23:11.000000000 +0200 +++ gdb-head/gdb/obsd-tdep.c 2007-06-06 19:00:47.044988640 +0200 @@ -34,5 +34,5 @@ obsd_skip_solib_resolver (struct gdbarch if (msym && SYMBOL_VALUE_ADDRESS (msym) == pc) return frame_pc_unwind (get_current_frame ()); else - return find_solib_trampoline_target (pc); + return find_solib_trampoline_target (get_current_frame (), pc); } diff -urNp gdb-orig/gdb/ppc-linux-tdep.c gdb-head/gdb/ppc-linux-tdep.c --- gdb-orig/gdb/ppc-linux-tdep.c 2007-06-04 22:23:11.000000000 +0200 +++ gdb-head/gdb/ppc-linux-tdep.c 2007-06-06 19:00:47.049987920 +0200 @@ -86,7 +86,7 @@ static CORE_ADDR -ppc_linux_skip_trampoline_code (CORE_ADDR pc) +ppc_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) { gdb_byte buf[4]; struct obj_section *sect; @@ -557,14 +557,16 @@ static struct insn_pattern ppc64_standar standard linkage function will send them. (This doesn't deal with dynamic linker lazy symbol resolution stubs.) */ static CORE_ADDR -ppc64_standard_linkage_target (CORE_ADDR pc, unsigned int *insn) +ppc64_standard_linkage_target (struct frame_info *frame, + CORE_ADDR pc, unsigned int *insn) { - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame)); /* The address of the function descriptor this linkage function references. */ CORE_ADDR desc - = ((CORE_ADDR) read_register (tdep->ppc_gp0_regnum + 2) + = ((CORE_ADDR) get_frame_register_unsigned (frame, + tdep->ppc_gp0_regnum + 2) + (insn_d_field (insn[0]) << 16) + insn_ds_field (insn[2])); @@ -576,13 +578,14 @@ ppc64_standard_linkage_target (CORE_ADDR /* Given that we've begun executing a call trampoline at PC, return the entry point of the function the trampoline will go to. */ static CORE_ADDR -ppc64_skip_trampoline_code (CORE_ADDR pc) +ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) { unsigned int ppc64_standard_linkage_insn[PPC64_STANDARD_LINKAGE_LEN]; if (insns_match_pattern (pc, ppc64_standard_linkage, ppc64_standard_linkage_insn)) - return ppc64_standard_linkage_target (pc, ppc64_standard_linkage_insn); + return ppc64_standard_linkage_target (frame, pc, + ppc64_standard_linkage_insn); else return 0; } diff -urNp gdb-orig/gdb/rs6000-tdep.c gdb-head/gdb/rs6000-tdep.c --- gdb-orig/gdb/rs6000-tdep.c 2007-06-06 19:00:38.719856339 +0200 +++ gdb-head/gdb/rs6000-tdep.c 2007-06-06 19:00:47.060986338 +0200 @@ -1972,7 +1972,7 @@ rs6000_in_solib_return_trampoline (CORE_ code that should be skipped. */ CORE_ADDR -rs6000_skip_trampoline_code (CORE_ADDR pc) +rs6000_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) { unsigned int ii, op; int rel; @@ -2009,7 +2009,7 @@ rs6000_skip_trampoline_code (CORE_ADDR p } /* If pc is in a shared library trampoline, return its target. */ - solib_target_pc = find_solib_trampoline_target (pc); + solib_target_pc = find_solib_trampoline_target (frame, pc); if (solib_target_pc) return solib_target_pc; @@ -2019,7 +2019,7 @@ rs6000_skip_trampoline_code (CORE_ADDR p if (op != trampoline_code[ii]) return 0; } - ii = read_register (11); /* r11 holds destination addr */ + ii = get_frame_register_unsigned (frame, 11); /* r11 holds destination addr */ pc = read_memory_addr (ii, gdbarch_tdep (current_gdbarch)->wordsize); /* (r11) value */ return pc; } diff -urNp gdb-orig/gdb/symtab.h gdb-head/gdb/symtab.h --- gdb-orig/gdb/symtab.h 2007-06-06 00:46:58.000000000 +0200 +++ gdb-head/gdb/symtab.h 2007-06-06 19:00:47.066985474 +0200 @@ -1191,7 +1191,7 @@ extern struct minimal_symbol *lookup_min extern struct minimal_symbol *lookup_solib_trampoline_symbol_by_pc (CORE_ADDR); -extern CORE_ADDR find_solib_trampoline_target (CORE_ADDR); +extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR); extern void init_minimal_symbol_collection (void); diff -urNp gdb-orig/gdb/xstormy16-tdep.c gdb-head/gdb/xstormy16-tdep.c --- gdb-orig/gdb/xstormy16-tdep.c 2007-06-06 18:56:32.866864107 +0200 +++ gdb-head/gdb/xstormy16-tdep.c 2007-06-06 19:00:47.071984755 +0200 @@ -573,7 +573,7 @@ xstormy16_find_jmp_table_entry (CORE_ADD } static CORE_ADDR -xstormy16_skip_trampoline_code (CORE_ADDR pc) +xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) { CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (pc); -- Dr. Ulrich Weigand GNU Toolchain for Linux on System z and Cell BE Ulrich.Weigand@de.ibm.com