From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 24398 invoked by alias); 20 Feb 2007 12:39:22 -0000 Received: (qmail 24377 invoked by uid 22791); 20 Feb 2007 12:39:17 -0000 X-Spam-Check-By: sourceware.org Received: from nevyn.them.org (HELO nevyn.them.org) (66.93.172.17) by sourceware.org (qpsmtpd/0.31.1) with ESMTP; Tue, 20 Feb 2007 12:38:57 +0000 Received: from dsl093-172-095.pit1.dsl.speakeasy.net ([66.93.172.95] helo=caradoc.them.org) by nevyn.them.org with esmtp (Exim 4.63) (envelope-from ) id 1HJUGi-0007X7-Fy; Tue, 20 Feb 2007 07:38:52 -0500 Received: from drow by caradoc.them.org with local (Exim 4.63) (envelope-from ) id 1HJUGi-0002ln-8B; Tue, 20 Feb 2007 07:38:52 -0500 Date: Tue, 20 Feb 2007 12:39:00 -0000 From: Daniel Jacobowitz To: Mark Kettenis , gdb-patches@sourceware.org Subject: Re: [patch RFC] Re: Notes on a frame_unwind_address_in_block problem Message-ID: <20070220123852.GA10630@caradoc.them.org> Mail-Followup-To: Mark Kettenis , gdb-patches@sourceware.org References: <200701011954.l01Js85r031019@brahms.sibelius.xs4all.nl> <20070101200248.GA19073@nevyn.them.org> <200701031137.l03Bb0rT031898@brahms.sibelius.xs4all.nl> <20070103161257.GA14162@nevyn.them.org> <200701032027.l03KRv4h000275@brahms.sibelius.xs4all.nl> <20070103203007.GA23392@nevyn.them.org> <200701032158.l03LwPeq026191@brahms.sibelius.xs4all.nl> <20070103220223.GK17935@nevyn.them.org> <200701032223.l03MN8u0001386@brahms.sibelius.xs4all.nl> <20070103222853.GA26905@nevyn.them.org> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20070103222853.GA26905@nevyn.them.org> User-Agent: Mutt/1.5.13 (2006-08-11) X-IsSubscribed: yes 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-02/txt/msg00240.txt.bz2 On Wed, Jan 03, 2007 at 05:28:54PM -0500, Daniel Jacobowitz wrote: > On Wed, Jan 03, 2007 at 11:23:08PM +0100, Mark Kettenis wrote: > > Hmm, well, you need to commit that one first, because the > > frame_func_unwind() change will depend on it. > > > > But perhaps we should give people a few days to comment... > > There's a call to frame_unwind_address_in_block in frame_func_unwind, > so this is circular - got to break the loop one way or another. > > It will be simpler if I do both; once I've admitted it's got to be > done, the mechanical change won't take but a few minutes. I'll > take care of it (but not today). Here we go. It's not too bad, all considered. Mark, thanks again for your help in finding a less hideous solution to this problem - I really appreciate it. Does this look OK to commit? I've tested it on x86_64-linux (where, with glibc HEAD, it fixes the remaining signal-related failures). And I built everything listed in MAINTAINERS using gdb_mbuild.sh. Related fixes in next message. -- Daniel Jacobowitz CodeSourcery 2007-02-20 Daniel Jacobowitz * dwarf2-frame.c (dwarf2_frame_cache, dwarf2_frame_this_id) (dwarf2_frame_sniffer): Update. (dwarf2_signal_frame_this_id): New function. (dwarf2_signal_frame_unwind): Use it. (dwarf2_frame_base_sniffer): Use frame_unwind_address_in_block. * frame-unwind.c (searching_for_unwind): New. (clear_searching_flag): New. (frame_unwind_find_by_frame): Assert that this function is not entered recursively. * frame.c (frame_func_unwind): Add this_type argument. (get_frame_func): Update. (frame_unwind_address_in_block): Add this_type argument and check it. Fix a typo. (get_frame_address_in_block): Update. * frame.h (enum frame_type): Move higher in the file. (frame_unwind_address_in_block, frame_func_unwind): Add enum frame_type argument. * alpha-mdebug-tdep.c, alpha-tdep.c, amd64-tdep.c, amd64obsd-tdep.c, arm-tdep.c, avr-tdep.c, cris-tdep.c, frv-tdep.c, h8300-tdep.c, hppa-tdep.c, i386-tdep.c, i386obsd-tdep.c, ia64-tdep.c, libunwind-frame.c, m32c-tdep.c, m32r-linux-tdep.c, m32r-tdep.c, m68hc11-tdep.c, m68k-tdep.c, m88k-tdep.c, mips-mdebug-tdep.c, mips-tdep.c, mn10300-tdep.c, mt-tdep.c, rs6000-tdep.c, s390-tdep.c, score-tdep.c, sh-tdep.c, sh64-tdep.c, sparc-tdep.c, sparc64obsd-tdep.c, spu-tdep.c, v850-tdep.c, vax-tdep.c, xstormy16-tdep.c, xtensa-tdep.c: Update calls to frame_func_unwind and frame_unwind_address_in_block to specify the frame type. Use frame_unwind_address_in_block instead of frame_pc_unwind in sniffers. --- gdb/alpha-mdebug-tdep.c | 7 +++--- gdb/alpha-tdep.c | 2 - gdb/amd64-tdep.c | 2 - gdb/amd64obsd-tdep.c | 4 ++- gdb/arm-tdep.c | 6 +++-- gdb/avr-tdep.c | 4 +-- gdb/cris-tdep.c | 8 ++++--- gdb/dwarf2-frame.c | 34 +++++++++++++++++++++++++------- gdb/frame-unwind.c | 28 ++++++++++++++++++++++++-- gdb/frame.c | 26 +++++++++++++++++------- gdb/frame.h | 51 ++++++++++++++++++++++++++++++------------------ gdb/frv-tdep.c | 5 ++-- gdb/h8300-tdep.c | 2 - gdb/hppa-tdep.c | 21 +++++++++++++------ gdb/i386-tdep.c | 2 - gdb/i386obsd-tdep.c | 4 ++- gdb/ia64-tdep.c | 2 - gdb/libunwind-frame.c | 5 +++- gdb/m32c-tdep.c | 5 ++-- gdb/m32r-linux-tdep.c | 2 - gdb/m32r-tdep.c | 4 +-- gdb/m68hc11-tdep.c | 4 +-- gdb/m68k-tdep.c | 2 - gdb/m88k-tdep.c | 7 +----- gdb/mips-mdebug-tdep.c | 5 ++-- gdb/mips-tdep.c | 12 ++++++----- gdb/mn10300-tdep.c | 9 +++++--- gdb/mt-tdep.c | 9 +++----- gdb/rs6000-tdep.c | 5 ++-- gdb/s390-tdep.c | 9 ++++---- gdb/score-tdep.c | 3 +- gdb/sh-tdep.c | 2 - gdb/sh64-tdep.c | 2 - gdb/sparc-tdep.c | 9 ++------ gdb/sparc64obsd-tdep.c | 8 ++++--- gdb/spu-tdep.c | 2 - gdb/v850-tdep.c | 2 - gdb/vax-tdep.c | 3 +- gdb/xstormy16-tdep.c | 2 - gdb/xtensa-tdep.c | 2 - 40 files changed, 208 insertions(+), 113 deletions(-) Index: src/gdb/alpha-mdebug-tdep.c =================================================================== --- src.orig/gdb/alpha-mdebug-tdep.c 2007-02-19 13:55:34.000000000 -0500 +++ src/gdb/alpha-mdebug-tdep.c 2007-02-19 14:43:19.000000000 -0500 @@ -246,7 +246,8 @@ alpha_mdebug_frame_this_id (struct frame struct alpha_mdebug_unwind_cache *info = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache); - *this_id = frame_id_build (info->vfp, frame_func_unwind (next_frame)); + *this_id = frame_id_build (info->vfp, + frame_func_unwind (next_frame, NORMAL_FRAME)); } /* Retrieve the value of REGNUM in FRAME. Don't give up! */ @@ -311,7 +312,7 @@ static const struct frame_unwind alpha_m const struct frame_unwind * alpha_mdebug_frame_sniffer (struct frame_info *next_frame) { - CORE_ADDR pc = frame_pc_unwind (next_frame); + CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); struct mdebug_extra_func_info *proc_desc; /* If this PC does not map to a PDR, then clearly this isn't an @@ -368,7 +369,7 @@ static const struct frame_base alpha_mde static const struct frame_base * alpha_mdebug_frame_base_sniffer (struct frame_info *next_frame) { - CORE_ADDR pc = frame_pc_unwind (next_frame); + CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); struct mdebug_extra_func_info *proc_desc; /* If this PC does not map to a PDR, then clearly this isn't an Index: src/gdb/alpha-tdep.c =================================================================== --- src.orig/gdb/alpha-tdep.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/alpha-tdep.c 2007-02-19 14:43:05.000000000 -0500 @@ -820,7 +820,7 @@ alpha_sigtramp_frame_this_id (struct fra code_addr = 0; } else - code_addr = frame_func_unwind (next_frame); + code_addr = frame_func_unwind (next_frame, SIGTRAMP_FRAME); /* The stack address is trivially read from the sigcontext. */ stack_addr = alpha_sigtramp_register_address (info->sigcontext_addr, Index: src/gdb/amd64-tdep.c =================================================================== --- src.orig/gdb/amd64-tdep.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/amd64-tdep.c 2007-02-19 14:42:58.000000000 -0500 @@ -833,7 +833,7 @@ amd64_frame_cache (struct frame_info *ne cache = amd64_alloc_frame_cache (); *this_cache = cache; - cache->pc = frame_func_unwind (next_frame); + cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); if (cache->pc != 0) amd64_analyze_prologue (cache->pc, frame_pc_unwind (next_frame), cache); Index: src/gdb/amd64obsd-tdep.c =================================================================== --- src.orig/gdb/amd64obsd-tdep.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/amd64obsd-tdep.c 2007-02-19 14:42:47.000000000 -0500 @@ -356,7 +356,9 @@ amd64obsd_trapframe_cache(struct frame_i cache = trad_frame_cache_zalloc (next_frame); *this_cache = cache; - func = frame_func_unwind (next_frame); + /* NORMAL_FRAME matches the type in amd64obsd_trapframe_unwind, but + SIGTRAMP_FRAME might be more appropriate. */ + func = frame_func_unwind (next_frame, NORMAL_FRAME); sp = frame_unwind_register_unsigned (next_frame, AMD64_RSP_REGNUM); find_pc_partial_function (func, &name, NULL, NULL); Index: src/gdb/arm-tdep.c =================================================================== --- src.orig/gdb/arm-tdep.c 2007-02-19 13:55:34.000000000 -0500 +++ src/gdb/arm-tdep.c 2007-02-19 14:41:27.000000000 -0500 @@ -929,7 +929,7 @@ arm_prologue_this_id (struct frame_info *this_cache = arm_make_prologue_cache (next_frame); cache = *this_cache; - func = frame_func_unwind (next_frame); + func = frame_func_unwind (next_frame, NORMAL_FRAME); /* This is meant to halt the backtrace at "_start". Make sure we don't halt it at a generic dummy frame. */ @@ -1034,9 +1034,11 @@ struct frame_unwind arm_stub_unwind = { static const struct frame_unwind * arm_stub_unwind_sniffer (struct frame_info *next_frame) { + CORE_ADDR addr_in_block; char dummy[4]; - if (in_plt_section (frame_unwind_address_in_block (next_frame), NULL) + addr_in_block = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); + if (in_plt_section (addr_in_block, NULL) || target_read_memory (frame_pc_unwind (next_frame), dummy, 4) != 0) return &arm_stub_unwind; Index: src/gdb/avr-tdep.c =================================================================== --- src.orig/gdb/avr-tdep.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/avr-tdep.c 2007-02-19 14:41:19.000000000 -0500 @@ -875,7 +875,7 @@ avr_frame_unwind_cache (struct frame_inf info->size = 0; info->prologue_type = AVR_PROLOGUE_NONE; - pc = frame_func_unwind (next_frame); + pc = frame_func_unwind (next_frame, NORMAL_FRAME); if ((pc > 0) && (pc < frame_pc_unwind (next_frame))) avr_scan_prologue (pc, info); @@ -958,7 +958,7 @@ avr_frame_this_id (struct frame_info *ne struct frame_id id; /* The FUNC is easy. */ - func = frame_func_unwind (next_frame); + func = frame_func_unwind (next_frame, NORMAL_FRAME); /* Hopefully the prologue analysis either correctly determined the frame's base (which is the SP from the previous frame), or set Index: src/gdb/cris-tdep.c =================================================================== --- src.orig/gdb/cris-tdep.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/cris-tdep.c 2007-02-19 14:41:08.000000000 -0500 @@ -792,9 +792,11 @@ cris_frame_unwind_cache (struct frame_in /* Prologue analysis does the rest... */ if (cris_version () == 32) - crisv32_scan_prologue (frame_func_unwind (next_frame), next_frame, info); + crisv32_scan_prologue (frame_func_unwind (next_frame, NORMAL_FRAME), + next_frame, info); else - cris_scan_prologue (frame_func_unwind (next_frame), next_frame, info); + cris_scan_prologue (frame_func_unwind (next_frame, NORMAL_FRAME), + next_frame, info); return info; } @@ -814,7 +816,7 @@ cris_frame_this_id (struct frame_info *n struct frame_id id; /* The FUNC is easy. */ - func = frame_func_unwind (next_frame); + func = frame_func_unwind (next_frame, NORMAL_FRAME); /* Hopefully the prologue analysis either correctly determined the frame's base (which is the SP from the previous frame), or set Index: src/gdb/dwarf2-frame.c =================================================================== --- src.orig/gdb/dwarf2-frame.c 2007-02-19 13:55:34.000000000 -0500 +++ src/gdb/dwarf2-frame.c 2007-02-19 14:40:11.000000000 -0500 @@ -848,7 +848,7 @@ dwarf2_frame_cache (struct frame_info *n frame_unwind_address_in_block does just this. It's not clear how reliable the method is though; there is the potential for the register state pre-call being different to that on return. */ - fs->pc = frame_unwind_address_in_block (next_frame); + fs->pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); /* Find the correct FDE. */ fde = dwarf2_frame_find_fde (&fs->pc); @@ -1011,7 +1011,22 @@ dwarf2_frame_this_id (struct frame_info if (cache->undefined_retaddr) return; - (*this_id) = frame_id_build (cache->cfa, frame_func_unwind (next_frame)); + (*this_id) = frame_id_build (cache->cfa, + frame_func_unwind (next_frame, NORMAL_FRAME)); +} + +static void +dwarf2_signal_frame_this_id (struct frame_info *next_frame, void **this_cache, + struct frame_id *this_id) +{ + struct dwarf2_frame_cache *cache = + dwarf2_frame_cache (next_frame, this_cache); + + if (cache->undefined_retaddr) + return; + + (*this_id) = frame_id_build (cache->cfa, + frame_func_unwind (next_frame, SIGTRAMP_FRAME)); } static void @@ -1179,7 +1194,7 @@ static const struct frame_unwind dwarf2_ static const struct frame_unwind dwarf2_signal_frame_unwind = { SIGTRAMP_FRAME, - dwarf2_frame_this_id, + dwarf2_signal_frame_this_id, dwarf2_frame_prev_register }; @@ -1188,8 +1203,12 @@ dwarf2_frame_sniffer (struct frame_info { /* Grab an address that is guarenteed to reside somewhere within the function. frame_pc_unwind(), for a no-return next function, can - end up returning something past the end of this function's body. */ - CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame); + end up returning something past the end of this function's body. + If the frame we're sniffing for is a signal frame whose start + address is placed on the stack by the OS, its FDE must + extend one byte before its start address or we will miss it. */ + CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame, + NORMAL_FRAME); struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr); if (!fde) return NULL; @@ -1233,8 +1252,9 @@ static const struct frame_base dwarf2_fr const struct frame_base * dwarf2_frame_base_sniffer (struct frame_info *next_frame) { - CORE_ADDR pc = frame_pc_unwind (next_frame); - if (dwarf2_frame_find_fde (&pc)) + CORE_ADDR block_addr = frame_unwind_address_in_block (next_frame, + NORMAL_FRAME); + if (dwarf2_frame_find_fde (&block_addr)) return &dwarf2_frame_base; return NULL; Index: src/gdb/frame-unwind.c =================================================================== --- src.orig/gdb/frame-unwind.c 2007-02-19 13:55:34.000000000 -0500 +++ src/gdb/frame-unwind.c 2007-02-19 14:36:33.000000000 -0500 @@ -28,6 +28,8 @@ static struct gdbarch_data *frame_unwind_data; +static int searching_for_unwind; + struct frame_unwind_table_entry { frame_unwind_sniffer_ftype *sniffer; @@ -83,6 +85,12 @@ frame_unwind_prepend_unwinder (struct gd (*table->osabi_head) = entry; } +static void +clear_searching_flag (void *arg) +{ + searching_for_unwind = 0; +} + const struct frame_unwind * frame_unwind_find_by_frame (struct frame_info *next_frame, void **this_cache) { @@ -90,6 +98,15 @@ frame_unwind_find_by_frame (struct frame struct gdbarch *gdbarch = get_frame_arch (next_frame); struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data); struct frame_unwind_table_entry *entry; + struct cleanup *back_to; + + /* Check if we were re-entered, and assert instead of running out + of stack. This happens if the sniffer calls anything which + requires NEXT_FRAME's unwinder. */ + gdb_assert (!searching_for_unwind); + searching_for_unwind = 1; + back_to = make_cleanup (clear_searching_flag, NULL); + for (entry = table->list; entry != NULL; entry = entry->next) { if (entry->sniffer != NULL) @@ -97,15 +114,22 @@ frame_unwind_find_by_frame (struct frame const struct frame_unwind *desc = NULL; desc = entry->sniffer (next_frame); if (desc != NULL) - return desc; + { + do_cleanups (back_to); + return desc; + } } if (entry->unwinder != NULL) { if (entry->unwinder->sniffer (entry->unwinder, next_frame, this_cache)) - return entry->unwinder; + { + do_cleanups (back_to); + return entry->unwinder; + } } } + do_cleanups (back_to); internal_error (__FILE__, __LINE__, _("frame_unwind_find_by_frame failed")); } Index: src/gdb/frame.c =================================================================== --- src.orig/gdb/frame.c 2007-02-19 13:55:34.000000000 -0500 +++ src/gdb/frame.c 2007-02-19 14:36:01.000000000 -0500 @@ -471,13 +471,13 @@ frame_pc_unwind (struct frame_info *this } CORE_ADDR -frame_func_unwind (struct frame_info *fi) +frame_func_unwind (struct frame_info *fi, enum frame_type this_type) { if (!fi->prev_func.p) { /* Make certain that this, and not the adjacent, function is found. */ - CORE_ADDR addr_in_block = frame_unwind_address_in_block (fi); + CORE_ADDR addr_in_block = frame_unwind_address_in_block (fi, this_type); fi->prev_func.p = 1; fi->prev_func.addr = get_pc_function_start (addr_in_block); if (frame_debug) @@ -491,7 +491,7 @@ frame_func_unwind (struct frame_info *fi CORE_ADDR get_frame_func (struct frame_info *fi) { - return frame_func_unwind (fi->next); + return frame_func_unwind (fi->next, get_frame_type (fi)); } static int @@ -1496,20 +1496,31 @@ get_frame_pc (struct frame_info *frame) return frame_pc_unwind (frame->next); } -/* Return an address of that falls within the frame's code block. */ +/* Return an address that falls within NEXT_FRAME's caller's code + block, assuming that the caller is a THIS_TYPE frame. */ CORE_ADDR -frame_unwind_address_in_block (struct frame_info *next_frame) +frame_unwind_address_in_block (struct frame_info *next_frame, + enum frame_type this_type) { /* A draft address. */ CORE_ADDR pc = frame_pc_unwind (next_frame); + /* If NEXT_FRAME was called by a signal frame or dummy frame, then + we shold not adjust the unwound PC. These frames may not call + their next frame in the normal way; the operating system or GDB + may have pushed their resume address manually onto the stack, so + it may be the very first instruction. Even if the resume address + was not manually pushed, they expect to be returned to. */ + if (this_type != NORMAL_FRAME) + return pc; + /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel), and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS frame's PC ends up pointing at the instruction fallowing the "call". Adjust that PC value so that it falls on the call instruction (which, hopefully, falls within THIS frame's code - block. So far it's proved to be a very good approximation. See + block). So far it's proved to be a very good approximation. See get_frame_type() for why ->type can't be used. */ if (next_frame->level >= 0 && get_frame_type (next_frame) == NORMAL_FRAME) @@ -1520,7 +1531,8 @@ frame_unwind_address_in_block (struct fr CORE_ADDR get_frame_address_in_block (struct frame_info *this_frame) { - return frame_unwind_address_in_block (this_frame->next); + return frame_unwind_address_in_block (this_frame->next, + get_frame_type (this_frame)); } static int Index: src/gdb/frame.h =================================================================== --- src.orig/gdb/frame.h 2007-02-19 13:55:34.000000000 -0500 +++ src/gdb/frame.h 2007-02-19 14:34:33.000000000 -0500 @@ -184,6 +184,25 @@ extern int frame_id_inner (struct frame_ extern void fprint_frame_id (struct ui_file *file, struct frame_id id); +/* Frame types. Some are real, some are signal trampolines, and some + are completely artificial (dummy). */ + +enum frame_type +{ + /* A true stack frame, created by the target program during normal + execution. */ + NORMAL_FRAME, + /* A fake frame, created by GDB when performing an inferior function + call. */ + DUMMY_FRAME, + /* In a signal handler, various OSs handle this in various ways. + The main thing is that the frame may be far from normal. */ + SIGTRAMP_FRAME, + /* Sentinel or registers frame. This frame obtains register values + direct from the inferior's registers. */ + SENTINEL_FRAME +}; + /* For every stopped thread, GDB tracks two frames: current and selected. Current frame is the inner most frame of the selected thread. Selected frame is the one being examined by the the GDB @@ -265,7 +284,13 @@ extern CORE_ADDR get_frame_pc (struct fr the frame's block. */ extern CORE_ADDR get_frame_address_in_block (struct frame_info *this_frame); -extern CORE_ADDR frame_unwind_address_in_block (struct frame_info *next_frame); + +/* Similar to get_frame_address_in_block, find an address in the + block which logically called NEXT_FRAME, assuming it is a THIS_TYPE + frame. */ + +extern CORE_ADDR frame_unwind_address_in_block (struct frame_info *next_frame, + enum frame_type this_type); /* The frame's inner-most bound. AKA the stack-pointer. Confusingly known as top-of-stack. */ @@ -277,9 +302,13 @@ extern CORE_ADDR frame_sp_unwind (struct /* Following on from the `resume' address. Return the entry point address of the function containing that resume address, or zero if that function isn't known. */ -extern CORE_ADDR frame_func_unwind (struct frame_info *fi); extern CORE_ADDR get_frame_func (struct frame_info *fi); +/* Similar to get_frame_func, find the start of the function which + logically called NEXT_FRAME, assuming it is a THIS_TYPE frame. */ +extern CORE_ADDR frame_func_unwind (struct frame_info *next_frame, + enum frame_type this_type); + /* Closely related to the resume address, various symbol table attributes that are determined by the PC. Note that for a normal frame, the PC refers to the resume address after the return, and @@ -375,24 +404,8 @@ extern CORE_ADDR get_frame_args_address for an invalid frame). */ extern int frame_relative_level (struct frame_info *fi); -/* Return the frame's type. Some are real, some are signal - trampolines, and some are completely artificial (dummy). */ +/* Return the frame's type. */ -enum frame_type -{ - /* A true stack frame, created by the target program during normal - execution. */ - NORMAL_FRAME, - /* A fake frame, created by GDB when performing an inferior function - call. */ - DUMMY_FRAME, - /* In a signal handler, various OSs handle this in various ways. - The main thing is that the frame may be far from normal. */ - SIGTRAMP_FRAME, - /* Sentinel or registers frame. This frame obtains register values - direct from the inferior's registers. */ - SENTINEL_FRAME -}; extern enum frame_type get_frame_type (struct frame_info *); /* For frames where we can not unwind further, describe why. */ Index: src/gdb/frv-tdep.c =================================================================== --- src.orig/gdb/frv-tdep.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/frv-tdep.c 2007-02-19 16:39:55.000000000 -0500 @@ -1016,7 +1016,8 @@ frv_frame_unwind_cache (struct frame_inf info->saved_regs = trad_frame_alloc_saved_regs (next_frame); /* Prologue analysis does the rest... */ - frv_analyze_prologue (frame_func_unwind (next_frame), next_frame, info); + frv_analyze_prologue (frame_func_unwind (next_frame, NORMAL_FRAME), + next_frame, info); return info; } @@ -1346,7 +1347,7 @@ frv_frame_this_id (struct frame_info *ne struct frame_id id; /* The FUNC is easy. */ - func = frame_func_unwind (next_frame); + func = frame_func_unwind (next_frame, NORMAL_FRAME); /* Check if the stack is empty. */ msym_stack = lookup_minimal_symbol ("_stack", NULL, NULL); Index: src/gdb/h8300-tdep.c =================================================================== --- src.orig/gdb/h8300-tdep.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/h8300-tdep.c 2007-02-19 14:29:32.000000000 -0500 @@ -447,7 +447,7 @@ h8300_frame_cache (struct frame_info *ne cache->saved_regs[E_PC_REGNUM] = -BINWORD; - cache->pc = frame_func_unwind (next_frame); + cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); current_pc = frame_pc_unwind (next_frame); if (cache->pc != 0) h8300_analyze_prologue (cache->pc, current_pc, cache); Index: src/gdb/hppa-tdep.c =================================================================== --- src.orig/gdb/hppa-tdep.c 2007-02-19 13:55:34.000000000 -0500 +++ src/gdb/hppa-tdep.c 2007-02-19 14:29:26.000000000 -0500 @@ -1787,9 +1787,14 @@ hppa_skip_prologue (CORE_ADDR pc) static struct unwind_table_entry * hppa_find_unwind_entry_in_block (struct frame_info *f) { - CORE_ADDR pc; + CORE_ADDR pc = frame_unwind_address_in_block (f, NORMAL_FRAME); - pc = frame_unwind_address_in_block (f); + /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the + result of frame_unwind_address_in_block implies a problem. + The bits should have been removed earlier, before the return + value of frame_pc_unwind. That might be happening already; + if it isn't, it should be fixed. Then this call can be + removed. */ pc = gdbarch_addr_bits_remove (get_frame_arch (f), pc); return find_unwind_entry (pc); } @@ -1899,7 +1904,7 @@ hppa_frame_cache (struct frame_info *nex if ((u->Region_description & 0x2) == 0) start_pc = u->region_start; else - start_pc = frame_func_unwind (next_frame); + start_pc = frame_func_unwind (next_frame, NORMAL_FRAME); prologue_end = skip_prologue_hard_way (start_pc, 0); end_pc = frame_pc_unwind (next_frame); @@ -2267,7 +2272,7 @@ hppa_fallback_frame_cache (struct frame_ (*this_cache) = cache; cache->saved_regs = trad_frame_alloc_saved_regs (next_frame); - start_pc = frame_func_unwind (next_frame); + start_pc = frame_func_unwind (next_frame, NORMAL_FRAME); if (start_pc) { CORE_ADDR cur_pc = frame_pc_unwind (next_frame); @@ -2326,7 +2331,8 @@ hppa_fallback_frame_this_id (struct fram { struct hppa_frame_cache *info = hppa_fallback_frame_cache (next_frame, this_cache); - (*this_id) = frame_id_build (info->base, frame_func_unwind (next_frame)); + (*this_id) = frame_id_build (info->base, + frame_func_unwind (next_frame, NORMAL_FRAME)); } static void @@ -2409,7 +2415,8 @@ hppa_stub_frame_this_id (struct frame_in = hppa_stub_frame_unwind_cache (next_frame, this_prologue_cache); if (info) - *this_id = frame_id_build (info->base, frame_func_unwind (next_frame)); + *this_id = frame_id_build (info->base, + frame_func_unwind (next_frame, NORMAL_FRAME)); else *this_id = null_frame_id; } @@ -2441,7 +2448,7 @@ static const struct frame_unwind hppa_st static const struct frame_unwind * hppa_stub_unwind_sniffer (struct frame_info *next_frame) { - CORE_ADDR pc = frame_pc_unwind (next_frame); + CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); struct gdbarch *gdbarch = get_frame_arch (next_frame); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); Index: src/gdb/i386-tdep.c =================================================================== --- src.orig/gdb/i386-tdep.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/i386-tdep.c 2007-02-19 14:28:52.000000000 -0500 @@ -949,7 +949,7 @@ i386_frame_cache (struct frame_info *nex /* For normal frames, %eip is stored at 4(%ebp). */ cache->saved_regs[I386_EIP_REGNUM] = 4; - cache->pc = frame_func_unwind (next_frame); + cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); if (cache->pc != 0) i386_analyze_prologue (cache->pc, frame_pc_unwind (next_frame), cache); Index: src/gdb/i386obsd-tdep.c =================================================================== --- src.orig/gdb/i386obsd-tdep.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/i386obsd-tdep.c 2007-02-19 14:28:41.000000000 -0500 @@ -353,7 +353,9 @@ i386obsd_trapframe_cache(struct frame_in cache = trad_frame_cache_zalloc (next_frame); *this_cache = cache; - func = frame_func_unwind (next_frame); + /* NORMAL_FRAME matches the type in i386obsd_trapframe_unwind, but + SIGTRAMP_FRAME might be more appropriate. */ + func = frame_func_unwind (next_frame, NORMAL_FRAME); sp = frame_unwind_register_unsigned (next_frame, I386_ESP_REGNUM); find_pc_partial_function (func, &name, NULL, NULL); Index: src/gdb/ia64-tdep.c =================================================================== --- src.orig/gdb/ia64-tdep.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/ia64-tdep.c 2007-02-19 14:27:10.000000000 -0500 @@ -1555,7 +1555,7 @@ ia64_frame_cache (struct frame_info *nex cache->cfm = cfm; - cache->pc = frame_func_unwind (next_frame); + cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); if (cache->pc != 0) examine_prologue (cache->pc, frame_pc_unwind (next_frame), next_frame, cache); Index: src/gdb/libunwind-frame.c =================================================================== --- src.orig/gdb/libunwind-frame.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/libunwind-frame.c 2007-02-19 14:26:49.000000000 -0500 @@ -141,7 +141,10 @@ libunwind_frame_cache (struct frame_info /* Allocate a new cache. */ cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache); - cache->func_addr = frame_func_unwind (next_frame); + /* We can assume we are unwinding a normal frame. Even if this is + for a signal trampoline, ia64 signal "trampolines" use a normal + subroutine call to start the signal handler. */ + cache->func_addr = frame_func_unwind (next_frame, NORMAL_FRAME); if (cache->func_addr == 0 && frame_relative_level (next_frame) > 0 && get_frame_type (next_frame) != SIGTRAMP_FRAME) Index: src/gdb/m32c-tdep.c =================================================================== --- src.orig/gdb/m32c-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/m32c-tdep.c 2007-02-19 13:59:05.000000000 -0500 @@ -1836,7 +1836,7 @@ m32c_analyze_frame_prologue (struct fram { if (! *this_prologue_cache) { - CORE_ADDR func_start = frame_func_unwind (next_frame); + CORE_ADDR func_start = frame_func_unwind (next_frame, NORMAL_FRAME); CORE_ADDR stop_addr = frame_pc_unwind (next_frame); /* If we couldn't find any function containing the PC, then @@ -1900,7 +1900,8 @@ m32c_this_id (struct frame_info *next_fr CORE_ADDR base = m32c_frame_base (next_frame, this_prologue_cache); if (base) - *this_id = frame_id_build (base, frame_func_unwind (next_frame)); + *this_id = frame_id_build (base, + frame_func_unwind (next_frame, NORMAL_FRAME)); /* Otherwise, leave it unset, and that will terminate the backtrace. */ } Index: src/gdb/m32r-linux-tdep.c =================================================================== --- src.orig/gdb/m32r-linux-tdep.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/m32r-linux-tdep.c 2007-02-19 14:03:30.000000000 -0500 @@ -250,7 +250,7 @@ m32r_linux_sigtramp_frame_cache (struct if (addr) sigcontext_addr += 128; else - addr = frame_func_unwind (next_frame); + addr = frame_func_unwind (next_frame, NORMAL_FRAME); } cache->pc = addr; Index: src/gdb/m32r-tdep.c =================================================================== --- src.orig/gdb/m32r-tdep.c 2007-02-19 13:57:27.000000000 -0500 +++ src/gdb/m32r-tdep.c 2007-02-19 14:03:17.000000000 -0500 @@ -536,7 +536,7 @@ m32r_frame_unwind_cache (struct frame_in info->uses_frame = 0; scan_limit = frame_pc_unwind (next_frame); - for (pc = frame_func_unwind (next_frame); + for (pc = frame_func_unwind (next_frame, NORMAL_FRAME); pc > 0 && pc < scan_limit; pc += 2) { if ((pc & 2) == 0) @@ -835,7 +835,7 @@ m32r_frame_this_id (struct frame_info *n struct frame_id id; /* The FUNC is easy. */ - func = frame_func_unwind (next_frame); + func = frame_func_unwind (next_frame, NORMAL_FRAME); /* Check if the stack is empty. */ msym_stack = lookup_minimal_symbol ("_stack", NULL, NULL); Index: src/gdb/m68hc11-tdep.c =================================================================== --- src.orig/gdb/m68hc11-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/m68hc11-tdep.c 2007-02-19 14:03:01.000000000 -0500 @@ -798,7 +798,7 @@ m68hc11_frame_unwind_cache (struct frame (*this_prologue_cache) = info; info->saved_regs = trad_frame_alloc_saved_regs (next_frame); - info->pc = frame_func_unwind (next_frame); + info->pc = frame_func_unwind (next_frame, NORMAL_FRAME); info->size = 0; info->return_kind = m68hc11_get_return_insn (info->pc); @@ -889,7 +889,7 @@ m68hc11_frame_this_id (struct frame_info struct frame_id id; /* The FUNC is easy. */ - func = frame_func_unwind (next_frame); + func = frame_func_unwind (next_frame, NORMAL_FRAME); /* Hopefully the prologue analysis either correctly determined the frame's base (which is the SP from the previous frame), or set Index: src/gdb/m68k-tdep.c =================================================================== --- src.orig/gdb/m68k-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/m68k-tdep.c 2007-02-19 14:02:53.000000000 -0500 @@ -819,7 +819,7 @@ m68k_frame_cache (struct frame_info *nex /* For normal frames, %pc is stored at 4(%fp). */ cache->saved_regs[M68K_PC_REGNUM] = 4; - cache->pc = frame_func_unwind (next_frame); + cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); if (cache->pc != 0) m68k_analyze_prologue (cache->pc, frame_pc_unwind (next_frame), cache); Index: src/gdb/m88k-tdep.c =================================================================== --- src.orig/gdb/m88k-tdep.c 2007-01-29 12:37:47.000000000 -0500 +++ src/gdb/m88k-tdep.c 2007-02-19 14:02:45.000000000 -0500 @@ -659,12 +659,9 @@ m88k_frame_cache (struct frame_info *nex cache->saved_regs = trad_frame_alloc_saved_regs (next_frame); cache->fp_offset = -1; - cache->pc = frame_func_unwind (next_frame); + cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); if (cache->pc != 0) - { - CORE_ADDR addr_in_block = frame_unwind_address_in_block (next_frame); - m88k_analyze_prologue (cache->pc, addr_in_block, cache); - } + m88k_analyze_prologue (cache->pc, frame_pc_unwind (next_frame), cache); /* Calculate the stack pointer used in the prologue. */ if (cache->fp_offset != -1) Index: src/gdb/mips-mdebug-tdep.c =================================================================== --- src.orig/gdb/mips-mdebug-tdep.c 2007-02-19 13:55:34.000000000 -0500 +++ src/gdb/mips-mdebug-tdep.c 2007-02-19 14:02:39.000000000 -0500 @@ -386,7 +386,8 @@ mips_mdebug_frame_this_id (struct frame_ { struct mips_frame_cache *info = mips_mdebug_frame_cache (next_frame, this_cache); - (*this_id) = frame_id_build (info->base, frame_func_unwind (next_frame)); + (*this_id) = frame_id_build (info->base, + frame_func_unwind (next_frame, NORMAL_FRAME)); } static void @@ -412,7 +413,7 @@ static const struct frame_unwind mips_md static const struct frame_unwind * mips_mdebug_frame_sniffer (struct frame_info *next_frame) { - CORE_ADDR pc = frame_pc_unwind (next_frame); + CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); CORE_ADDR startaddr = 0; struct mdebug_extra_func_info *proc_desc; int kernel_trap; Index: src/gdb/mips-tdep.c =================================================================== --- src.orig/gdb/mips-tdep.c 2007-02-19 13:55:34.000000000 -0500 +++ src/gdb/mips-tdep.c 2007-02-19 16:44:38.000000000 -0500 @@ -1666,7 +1666,8 @@ mips_insn16_frame_this_id (struct frame_ { struct mips_frame_cache *info = mips_insn16_frame_cache (next_frame, this_cache); - (*this_id) = frame_id_build (info->base, frame_func_unwind (next_frame)); + (*this_id) = frame_id_build (info->base, + frame_func_unwind (next_frame, NORMAL_FRAME)); } static void @@ -1692,7 +1693,7 @@ static const struct frame_unwind mips_in static const struct frame_unwind * mips_insn16_frame_sniffer (struct frame_info *next_frame) { - CORE_ADDR pc = frame_pc_unwind (next_frame); + CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); if (mips_pc_is_mips16 (pc)) return &mips_insn16_frame_unwind; return NULL; @@ -1986,7 +1987,8 @@ mips_insn32_frame_this_id (struct frame_ { struct mips_frame_cache *info = mips_insn32_frame_cache (next_frame, this_cache); - (*this_id) = frame_id_build (info->base, frame_func_unwind (next_frame)); + (*this_id) = frame_id_build (info->base, + frame_func_unwind (next_frame, NORMAL_FRAME)); } static void @@ -2012,7 +2014,7 @@ static const struct frame_unwind mips_in static const struct frame_unwind * mips_insn32_frame_sniffer (struct frame_info *next_frame) { - CORE_ADDR pc = frame_pc_unwind (next_frame); + CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); if (! mips_pc_is_mips16 (pc)) return &mips_insn32_frame_unwind; return NULL; @@ -2107,7 +2109,7 @@ static const struct frame_unwind * mips_stub_frame_sniffer (struct frame_info *next_frame) { struct obj_section *s; - CORE_ADDR pc = frame_pc_unwind (next_frame); + CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); if (in_plt_section (pc, NULL)) return &mips_stub_frame_unwind; Index: src/gdb/mn10300-tdep.c =================================================================== --- src.orig/gdb/mn10300-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/mn10300-tdep.c 2007-02-19 14:44:23.000000000 -0500 @@ -850,9 +850,12 @@ mn10300_frame_unwind_cache (struct frame frame_id_build (trad_frame_get_this_base (cache), start)); else - trad_frame_set_id (cache, - frame_id_build (trad_frame_get_this_base (cache), - frame_func_unwind (next_frame))); + { + start = frame_func_unwind (next_frame, NORMAL_FRAME); + trad_frame_set_id (cache, + frame_id_build (trad_frame_get_this_base (cache), + start)); + } (*this_prologue_cache) = cache; return cache; Index: src/gdb/mt-tdep.c =================================================================== --- src.orig/gdb/mt-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/mt-tdep.c 2007-02-19 14:00:49.000000000 -0500 @@ -891,7 +891,7 @@ mt_frame_unwind_cache (struct frame_info frame_unwind_unsigned_register (next_frame, MT_SP_REGNUM, &sp); frame_unwind_unsigned_register (next_frame, MT_FP_REGNUM, &fp); - start_addr = frame_func_unwind (next_frame); + start_addr = frame_func_unwind (next_frame, NORMAL_FRAME); /* Return early if GDB couldn't find the function. */ if (start_addr == 0) @@ -1041,10 +1041,9 @@ mt_frame_this_id (struct frame_info *nex mt_frame_unwind_cache (next_frame, this_prologue_cache); if (!(info == NULL || info->prev_sp == 0)) - { - (*this_id) = frame_id_build (info->prev_sp, - frame_func_unwind (next_frame)); - } + (*this_id) = frame_id_build (info->prev_sp, + frame_func_unwind (next_frame, NORMAL_FRAME)); + return; } Index: src/gdb/rs6000-tdep.c =================================================================== --- src.orig/gdb/rs6000-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/rs6000-tdep.c 2007-02-19 14:00:20.000000000 -0500 @@ -2970,7 +2970,7 @@ rs6000_frame_cache (struct frame_info *n (*this_cache) = cache; cache->saved_regs = trad_frame_alloc_saved_regs (next_frame); - func = frame_func_unwind (next_frame); + func = frame_func_unwind (next_frame, NORMAL_FRAME); pc = frame_pc_unwind (next_frame); skip_prologue (func, pc, &fdata); @@ -3122,7 +3122,8 @@ rs6000_frame_this_id (struct frame_info { struct rs6000_frame_cache *info = rs6000_frame_cache (next_frame, this_cache); - (*this_id) = frame_id_build (info->base, frame_func_unwind (next_frame)); + (*this_id) = frame_id_build (info->base, + frame_func_unwind (next_frame, NORMAL_FRAME)); } static void Index: src/gdb/s390-tdep.c =================================================================== --- src.orig/gdb/s390-tdep.c 2007-02-19 13:55:34.000000000 -0500 +++ src/gdb/s390-tdep.c 2007-02-19 13:59:56.000000000 -0500 @@ -1232,7 +1232,7 @@ s390_prologue_frame_unwind_cache (struct bother searching for it -- with modern compilers this would be mostly pointless anyway. Trust that we'll either have valid DWARF-2 CFI data or else a valid backchain ... */ - func = frame_func_unwind (next_frame); + func = frame_func_unwind (next_frame, NORMAL_FRAME); if (!func) return 0; @@ -1556,14 +1556,15 @@ static const struct frame_unwind s390_st static const struct frame_unwind * s390_stub_frame_sniffer (struct frame_info *next_frame) { - CORE_ADDR pc = frame_pc_unwind (next_frame); + CORE_ADDR addr_in_block; bfd_byte insn[S390_MAX_INSTR_SIZE]; /* If the current PC points to non-readable memory, we assume we have trapped due to an invalid function pointer call. We handle the non-existing current function like a PLT stub. */ - if (in_plt_section (pc, NULL) - || s390_readinstruction (insn, pc) < 0) + addr_in_block = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); + if (in_plt_section (addr_in_block, NULL) + || s390_readinstruction (insn, frame_pc_unwind (next_frame)) < 0) return &s390_stub_frame_unwind; return NULL; } Index: src/gdb/score-tdep.c =================================================================== --- src.orig/gdb/score-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/score-tdep.c 2007-02-19 14:00:34.000000000 -0500 @@ -801,7 +801,8 @@ score_prologue_this_id (struct frame_inf { struct score_frame_cache *info = score_make_prologue_cache (next_frame, this_cache); - (*this_id) = frame_id_build (info->base, frame_func_unwind (next_frame)); + (*this_id) = frame_id_build (info->base, + frame_func_unwind (next_frame, NORMAL_FRAME)); } static void Index: src/gdb/sh-tdep.c =================================================================== --- src.orig/gdb/sh-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/sh-tdep.c 2007-02-19 13:59:47.000000000 -0500 @@ -2215,7 +2215,7 @@ sh_frame_cache (struct frame_info *next_ if (cache->base == 0) return cache; - cache->pc = frame_func_unwind (next_frame); + cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); current_pc = frame_pc_unwind (next_frame); if (cache->pc != 0) sh_analyze_prologue (cache->pc, current_pc, cache); Index: src/gdb/sh64-tdep.c =================================================================== --- src.orig/gdb/sh64-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/sh64-tdep.c 2007-02-19 13:59:42.000000000 -0500 @@ -2254,7 +2254,7 @@ sh64_frame_cache (struct frame_info *nex if (cache->base == 0) return cache; - cache->pc = frame_func_unwind (next_frame); + cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); if (cache->pc != 0) sh64_analyze_prologue (current_gdbarch, cache, cache->pc, current_pc); Index: src/gdb/sparc-tdep.c =================================================================== --- src.orig/gdb/sparc-tdep.c 2007-01-29 12:37:48.000000000 -0500 +++ src/gdb/sparc-tdep.c 2007-02-19 13:59:36.000000000 -0500 @@ -699,12 +699,9 @@ sparc_frame_cache (struct frame_info *ne cache = sparc_alloc_frame_cache (); *this_cache = cache; - cache->pc = frame_func_unwind (next_frame); + cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); if (cache->pc != 0) - { - CORE_ADDR addr_in_block = frame_unwind_address_in_block (next_frame); - sparc_analyze_prologue (cache->pc, addr_in_block, cache); - } + sparc_analyze_prologue (cache->pc, frame_pc_unwind (next_frame), cache); if (cache->frameless_p) { @@ -1054,7 +1051,7 @@ sparc32_stabs_argument_has_addr (struct static int sparc32_dwarf2_struct_return_p (struct frame_info *next_frame) { - CORE_ADDR pc = frame_unwind_address_in_block (next_frame); + CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); struct symbol *sym = find_pc_function (pc); if (sym) Index: src/gdb/sparc64obsd-tdep.c =================================================================== --- src.orig/gdb/sparc64obsd-tdep.c 2007-02-19 13:55:34.000000000 -0500 +++ src/gdb/sparc64obsd-tdep.c 2007-02-19 13:55:54.000000000 -0500 @@ -205,7 +205,7 @@ sparc64obsd_sigtramp_frame_sniffer (stru /* Kernel debugging support. */ static struct sparc_frame_cache * -sparc64obsd_trapframe_cache(struct frame_info *next_frame, void **this_cache) +sparc64obsd_trapframe_cache (struct frame_info *next_frame, void **this_cache) { struct sparc_frame_cache *cache; CORE_ADDR sp, trapframe_addr; @@ -267,15 +267,17 @@ static const struct frame_unwind sparc64 static const struct frame_unwind * sparc64obsd_trapframe_sniffer (struct frame_info *next_frame) { + CORE_ADDR pc; ULONGEST pstate; char *name; /* Check whether we are in privileged mode, and bail out if we're not. */ - pstate = frame_unwind_register_unsigned(next_frame, SPARC64_PSTATE_REGNUM); + pstate = frame_unwind_register_unsigned (next_frame, SPARC64_PSTATE_REGNUM); if ((pstate & SPARC64_PSTATE_PRIV) == 0) return NULL; - find_pc_partial_function (frame_pc_unwind (next_frame), &name, NULL, NULL); + pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); + find_pc_partial_function (pc, &name, NULL, NULL); if (name && strcmp (name, "Lslowtrap_reenter") == 0) return &sparc64obsd_trapframe_unwind; Index: src/gdb/spu-tdep.c =================================================================== --- src.orig/gdb/spu-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/spu-tdep.c 2007-02-19 13:58:13.000000000 -0500 @@ -587,7 +587,7 @@ spu_frame_unwind_cache (struct frame_inf info->local_base = 0; /* Find the start of the current function, and analyze its prologue. */ - info->func = frame_func_unwind (next_frame); + info->func = frame_func_unwind (next_frame, NORMAL_FRAME); if (info->func == 0) { /* Fall back to using the current PC as frame ID. */ Index: src/gdb/v850-tdep.c =================================================================== --- src.orig/gdb/v850-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/v850-tdep.c 2007-02-19 13:59:27.000000000 -0500 @@ -856,7 +856,7 @@ v850_frame_cache (struct frame_info *nex if (cache->base == 0) return cache; - cache->pc = frame_func_unwind (next_frame); + cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); current_pc = frame_pc_unwind (next_frame); if (cache->pc != 0) v850_analyze_prologue (cache->pc, current_pc, cache); Index: src/gdb/vax-tdep.c =================================================================== --- src.orig/gdb/vax-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/vax-tdep.c 2007-02-19 13:59:20.000000000 -0500 @@ -384,7 +384,8 @@ vax_frame_this_id (struct frame_info *ne if (cache->base == 0) return; - (*this_id) = frame_id_build (cache->base, frame_func_unwind (next_frame)); + (*this_id) = frame_id_build (cache->base, + frame_func_unwind (next_frame, NORMAL_FRAME)); } static void Index: src/gdb/xstormy16-tdep.c =================================================================== --- src.orig/gdb/xstormy16-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/xstormy16-tdep.c 2007-02-19 13:59:13.000000000 -0500 @@ -655,7 +655,7 @@ xstormy16_frame_cache (struct frame_info if (cache->base == 0) return cache; - cache->pc = frame_func_unwind (next_frame); + cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME); current_pc = frame_pc_unwind (next_frame); if (cache->pc) xstormy16_analyze_prologue (cache->pc, current_pc, cache, next_frame); Index: src/gdb/xtensa-tdep.c =================================================================== --- src.orig/gdb/xtensa-tdep.c 2007-02-19 13:57:28.000000000 -0500 +++ src/gdb/xtensa-tdep.c 2007-02-19 13:58:06.000000000 -0500 @@ -924,7 +924,7 @@ xtensa_frame_cache (struct frame_info *n cache->ws = ws & ~(1 << wb); } - cache->pc = ((frame_func_unwind (next_frame) & 0xc0000000) + cache->pc = ((frame_func_unwind (next_frame, NORMAL_FRAME) & 0xc0000000) | (ra & 0x3fffffff)); cache->ps = (ps & ~PS_CALLINC_MASK) | ((WINSIZE(ra)/4) << PS_CALLINC_SHIFT);