From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 19269 invoked by alias); 22 Feb 2007 21:28:20 -0000 Received: (qmail 19254 invoked by uid 22791); 22 Feb 2007 21:28:15 -0000 X-Spam-Check-By: sourceware.org Received: from sibelius.xs4all.nl (HELO brahms.sibelius.xs4all.nl) (82.92.89.47) by sourceware.org (qpsmtpd/0.31) with ESMTP; Thu, 22 Feb 2007 21:28:00 +0000 Received: from brahms.sibelius.xs4all.nl (kettenis@localhost.sibelius.xs4all.nl [127.0.0.1]) by brahms.sibelius.xs4all.nl (8.14.0/8.14.0) with ESMTP id l1MLRqZu020992; Thu, 22 Feb 2007 22:27:52 +0100 (CET) Received: (from kettenis@localhost) by brahms.sibelius.xs4all.nl (8.14.0/8.14.0/Submit) id l1MLRpfW003517; Thu, 22 Feb 2007 22:27:51 +0100 (CET) Date: Thu, 22 Feb 2007 21:28:00 -0000 Message-Id: <200702222127.l1MLRpfW003517@brahms.sibelius.xs4all.nl> From: Mark Kettenis To: drow@false.org CC: gdb-patches@sourceware.org In-reply-to: <20070220123852.GA10630@caradoc.them.org> (message from Daniel Jacobowitz on Tue, 20 Feb 2007 07:38:52 -0500) 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> Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2007-02/txt/msg00282.txt.bz2 > Date: Tue, 20 Feb 2007 07:38:52 -0500 > From: Daniel Jacobowitz > > 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 > > * 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); > >