[patch RFC] Re: Notes on a frame_unwind_address_in_block problem

Mark Kettenis mark.kettenis@xs4all.nl
Thu Feb 22 21:28:00 GMT 2007


> 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);
>  
> 



More information about the Gdb-patches mailing list