This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
Re: [patch RFC] Re: Notes on a frame_unwind_address_in_block problem
- From: Mark Kettenis <mark dot kettenis at xs4all dot nl>
- To: drow at false dot org
- Cc: gdb-patches at sourceware dot org
- Date: Thu, 22 Feb 2007 22:27:51 +0100 (CET)
- Subject: Re: [patch RFC] Re: Notes on a frame_unwind_address_in_block problem
- 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> <20070220123852.GA10630@caradoc.them.org>
> Date: Tue, 20 Feb 2007 07:38:52 -0500
> From: Daniel Jacobowitz <drow@false.org>
>
> 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.
Hi Daniel,
Sorry that I didn't have the time to review this earlier. This still
contains the check to catch recursion in frame_unwind_find_by_frame(),
but that code really shouldn't be necessary now, so I'd prefer it if
you removed it since it is quite ugly.
> 2007-02-20 Daniel Jacobowitz <dan@codesourcery.com>
>
> * 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);
>
>