2002-11-08 20:42:00 +01:00
|
|
|
/* Code dealing with dummy stack frames, for GDB, the GNU debugger.
|
|
|
|
|
|
|
|
Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
|
|
|
|
1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
|
|
|
|
Foundation, Inc.
|
|
|
|
|
|
|
|
This file is part of GDB.
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
Boston, MA 02111-1307, USA. */
|
|
|
|
|
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
#include "dummy-frame.h"
|
|
|
|
#include "regcache.h"
|
|
|
|
#include "frame.h"
|
|
|
|
#include "inferior.h"
|
|
|
|
#include "gdb_assert.h"
|
2003-01-18 Andrew Cagney <ac131313@redhat.com>
* dummy-frame.h (dummy_frame_id_unwind): Delete declaration.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
(struct frame_unwind): Declare opaque.
(dummy_frame_p): Declare function.
* dummy-frame.c (dummy_frame_id_unwind): Make static.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
* dummy-frame.c: Include "frame-unwind.h".
(dummy_frame_p): New function.
(dummy_frame_unwind): New variable.
* frame.c: Include "frame-unwind.h".
(frame_pc_unwind, frame_id_unwind, frame_register_unwind): Update
to use the new unwind field.
(set_unwind_by_pc): Delete function.
(create_new_frame, get_prev_frame): Set unwind field using
frame_unwind_find_by_pc.
(trad_frame_unwind, trad_frame_unwinder): New variables.
* frame.h (trad_frame_unwind): Declare variable.
(frame_id_unwind_ftype): Delete declaration.
(frame_pc_unwind_ftype, frame_register_unwind_ftype): Ditto.
(struct frame_unwind): Declare opaque.
(struct frame_info): Replace the fields id_unwind, pc_unwind and
register_unwind with a single unwind pointer.
* frame-unwind.h, frame-unwind.c: New files.
* Makefile.in (SFILES): Add frame-unwind.c.
(frame_unwind_h): Define.
(COMMON_OBS): Add frame-unwind.o.
(frame-unwind.o): Specify dependencies.
(frame.o, dummy-frame.o): Update dependencies.
2003-01-18 18:25:23 +01:00
|
|
|
#include "frame-unwind.h"
|
2003-05-05 20:33:11 +02:00
|
|
|
#include "command.h"
|
|
|
|
#include "gdbcmd.h"
|
2002-11-08 20:42:00 +01:00
|
|
|
|
2003-03-17 15:23:50 +01:00
|
|
|
static void dummy_frame_this_id (struct frame_info *next_frame,
|
|
|
|
void **this_prologue_cache,
|
|
|
|
struct frame_id *this_id);
|
|
|
|
|
2002-11-08 20:42:00 +01:00
|
|
|
/* Dummy frame. This saves the processor state just prior to setting
|
|
|
|
up the inferior function call. Older targets save the registers
|
|
|
|
on the target stack (but that really slows down function calls). */
|
|
|
|
|
|
|
|
struct dummy_frame
|
|
|
|
{
|
|
|
|
struct dummy_frame *next;
|
|
|
|
|
2002-11-15 23:16:25 +01:00
|
|
|
/* These values belong to the caller (the previous frame, the frame
|
|
|
|
that this unwinds back to). */
|
2002-11-08 20:42:00 +01:00
|
|
|
CORE_ADDR pc;
|
|
|
|
CORE_ADDR fp;
|
|
|
|
CORE_ADDR sp;
|
|
|
|
CORE_ADDR top;
|
2002-12-13 17:40:25 +01:00
|
|
|
struct frame_id id;
|
2002-11-08 20:42:00 +01:00
|
|
|
struct regcache *regcache;
|
|
|
|
|
|
|
|
/* Address range of the call dummy code. Look for PC in the range
|
|
|
|
[LO..HI) (after allowing for DECR_PC_AFTER_BREAK). */
|
|
|
|
CORE_ADDR call_lo;
|
|
|
|
CORE_ADDR call_hi;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct dummy_frame *dummy_frame_stack = NULL;
|
|
|
|
|
|
|
|
/* Function: find_dummy_frame(pc, fp, sp)
|
|
|
|
|
|
|
|
Search the stack of dummy frames for one matching the given PC and
|
2002-11-24 16:06:08 +01:00
|
|
|
FP/SP. Unlike pc_in_dummy_frame(), this function doesn't need to
|
2002-11-08 20:42:00 +01:00
|
|
|
adjust for DECR_PC_AFTER_BREAK. This is because it is only legal
|
|
|
|
to call this function after the PC has been adjusted. */
|
|
|
|
|
2002-11-09 00:12:52 +01:00
|
|
|
static struct dummy_frame *
|
|
|
|
find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
|
2002-11-08 20:42:00 +01:00
|
|
|
{
|
|
|
|
struct dummy_frame *dummyframe;
|
|
|
|
|
|
|
|
for (dummyframe = dummy_frame_stack; dummyframe != NULL;
|
|
|
|
dummyframe = dummyframe->next)
|
|
|
|
{
|
|
|
|
/* Does the PC fall within the dummy frame's breakpoint
|
|
|
|
instruction. If not, discard this one. */
|
|
|
|
if (!(pc >= dummyframe->call_lo && pc < dummyframe->call_hi))
|
|
|
|
continue;
|
|
|
|
/* Does the FP match? */
|
|
|
|
if (dummyframe->top != 0)
|
|
|
|
{
|
|
|
|
/* If the target architecture explicitly saved the
|
|
|
|
top-of-stack before the inferior function call, assume
|
|
|
|
that that same architecture will always pass in an FP
|
|
|
|
(frame base) value that eactly matches that saved TOS.
|
|
|
|
Don't check the saved SP and SP as they can lead to false
|
|
|
|
hits. */
|
|
|
|
if (fp != dummyframe->top)
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* An older target that hasn't explicitly or implicitly
|
|
|
|
saved the dummy frame's top-of-stack. Try matching the
|
|
|
|
FP against the saved SP and FP. NOTE: If you're trying
|
|
|
|
to fix a problem with GDB not correctly finding a dummy
|
|
|
|
frame, check the comments that go with FRAME_ALIGN() and
|
2003-06-16 18:47:44 +02:00
|
|
|
UNWIND_DUMMY_ID(). */
|
2002-11-08 20:42:00 +01:00
|
|
|
if (fp != dummyframe->fp && fp != dummyframe->sp)
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* The FP matches this dummy frame. */
|
2002-11-09 00:12:52 +01:00
|
|
|
return dummyframe;
|
2002-11-08 20:42:00 +01:00
|
|
|
}
|
|
|
|
|
2002-11-09 00:12:52 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct regcache *
|
2003-05-15 21:04:29 +02:00
|
|
|
deprecated_find_dummy_frame_regcache (CORE_ADDR pc, CORE_ADDR fp)
|
2002-11-09 00:12:52 +01:00
|
|
|
{
|
|
|
|
struct dummy_frame *dummy = find_dummy_frame (pc, fp);
|
|
|
|
if (dummy != NULL)
|
|
|
|
return dummy->regcache;
|
|
|
|
else
|
|
|
|
return NULL;
|
2002-11-08 20:42:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
char *
|
|
|
|
deprecated_generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
|
|
|
|
{
|
2003-05-15 21:04:29 +02:00
|
|
|
struct regcache *regcache = deprecated_find_dummy_frame_regcache (pc, fp);
|
2002-11-08 20:42:00 +01:00
|
|
|
if (regcache == NULL)
|
|
|
|
return NULL;
|
|
|
|
return deprecated_grub_regcache_for_registers (regcache);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function: pc_in_call_dummy (pc, sp, fp)
|
|
|
|
|
|
|
|
Return true if the PC falls in a dummy frame created by gdb for an
|
|
|
|
inferior call. The code below which allows DECR_PC_AFTER_BREAK is
|
|
|
|
for infrun.c, which may give the function a PC without that
|
|
|
|
subtracted out. */
|
|
|
|
|
|
|
|
int
|
|
|
|
generic_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp)
|
2002-11-24 16:06:08 +01:00
|
|
|
{
|
|
|
|
return pc_in_dummy_frame (pc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return non-zero if the PC falls in a dummy frame.
|
|
|
|
|
|
|
|
The code below which allows DECR_PC_AFTER_BREAK is for infrun.c,
|
|
|
|
which may give the function a PC without that subtracted out.
|
|
|
|
|
|
|
|
FIXME: cagney/2002-11-23: This is silly. Surely "infrun.c" can
|
|
|
|
figure out what the real PC (as in the resume address) is BEFORE
|
|
|
|
calling this function (Oh, and I'm not even sure that this function
|
|
|
|
is called with an decremented PC, the call to pc_in_call_dummy() in
|
2003-05-03 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (DEPRECATED_REGISTER_SIZE): Rename REGISTER_SIZE.
(DEPRECATED_SIZEOF_CALL_DUMMY_WORDS): Rename
SIZEOF_CALL_DUMMY_WORDS.
(DEPRECATED_CALL_DUMMY_WORDS): Rename CALL_DUMMY_WORDS.
(DEPRECATED_FIX_CALL_DUMMY): Rename FIX_CALL_DUMMY.
(DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET): Rename
CALL_DUMMY_BREAKPOINT_OFFSET.
(DEPRECATED_CALL_DUMMY_START_OFFSET): Rename
CALL_DUMMY_START_OFFSET.
(DEPRECATED_CALL_DUMMY_LENGTH): Rename CALL_DUMMY_LENGTH.
* gdbarch.h, gdbarch.c: Re-generate.
* alpha-tdep.c, alphafbsd-tdep.c, arm-linux-tdep.c: Update.
* arm-tdep.c, avr-tdep.c, breakpoint.c, cris-tdep.c: Update.
* dummy-frame.c, dummy-frame.h, frv-tdep.c, gdbarch.c: Update.
* gdbarch.h, gdbarch.sh, h8300-tdep.c, hppa-tdep.c: Update.
* i386-tdep.c, ia64-tdep.c, infcall.c, inferior.h: Update.
* m68hc11-tdep.c, m68k-tdep.c, mcore-tdep.c: Update.
* mips-tdep.c, mn10300-tdep.c, ns32k-tdep.c: Update.
* rs6000-tdep.c, s390-tdep.c, sh-tdep.c, sol-thread.c: Update.
* sparc-tdep.c, target.c, v850-tdep.c, valops.c: Update.
* vax-tdep.c, x86-64-tdep.c, xstormy16-tdep.c: Update.
* config/ia64/tm-ia64.h, config/m68k/tm-vx68.h: Update.
* config/mips/tm-mips.h, config/pa/nm-hppah.h: Update.
* config/pa/tm-hppa.h, config/pa/tm-hppa64.h: Update.
* config/s390/tm-s390.h, config/sparc/tm-sp64.h: Update.
* config/sparc/tm-sparc.h: Update.
Index: doc/ChangeLog
2003-05-03 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Make
CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS, CALL_DUMMY_LENGTH,
FIX_CALL_DUMMY, CALL_DUMMY_BREAKPOINT_OFFSET and
CALL_DUMMY_BREAKPOINT_OFFSET deprecated.
Index: mi/ChangeLog
2003-05-03 Andrew Cagney <cagney@redhat.com>
* mi-main.c (mi_cmd_data_write_register_values): Replace
REGISTER_SIZE with DEPRECATED_REGISTER_SIZE.
Index: testsuite/ChangeLog
2003-05-03 Andrew Cagney <cagney@redhat.com>
* gdb.base/watchpoint.exp: Rename CALL_DUMMY_BREAKPOINT_OFFSET to
DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET in comments.
2003-05-05 19:56:57 +02:00
|
|
|
that file is conditional on
|
|
|
|
!DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET_P yet generic dummy
|
|
|
|
targets set DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET. True?). */
|
2002-11-24 16:06:08 +01:00
|
|
|
|
|
|
|
int
|
|
|
|
pc_in_dummy_frame (CORE_ADDR pc)
|
2002-11-08 20:42:00 +01:00
|
|
|
{
|
|
|
|
struct dummy_frame *dummyframe;
|
|
|
|
for (dummyframe = dummy_frame_stack;
|
|
|
|
dummyframe != NULL;
|
|
|
|
dummyframe = dummyframe->next)
|
|
|
|
{
|
|
|
|
if ((pc >= dummyframe->call_lo)
|
|
|
|
&& (pc < dummyframe->call_hi + DECR_PC_AFTER_BREAK))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function: read_register_dummy
|
|
|
|
Find a saved register from before GDB calls a function in the inferior */
|
|
|
|
|
|
|
|
CORE_ADDR
|
|
|
|
deprecated_read_register_dummy (CORE_ADDR pc, CORE_ADDR fp, int regno)
|
|
|
|
{
|
2003-05-15 21:04:29 +02:00
|
|
|
struct regcache *dummy_regs = deprecated_find_dummy_frame_regcache (pc, fp);
|
2002-11-08 20:42:00 +01:00
|
|
|
|
|
|
|
if (dummy_regs)
|
|
|
|
{
|
|
|
|
/* NOTE: cagney/2002-08-12: Replaced a call to
|
|
|
|
regcache_raw_read_as_address() with a call to
|
|
|
|
regcache_cooked_read_unsigned(). The old, ...as_address
|
2003-05-22 20:37:05 +02:00
|
|
|
function was eventually calling extract_unsigned_integer (nee
|
2002-11-08 20:42:00 +01:00
|
|
|
extract_address) to unpack the registers value. The below is
|
|
|
|
doing an unsigned extract so that it is functionally
|
|
|
|
equivalent. The read needs to be cooked as, otherwise, it
|
|
|
|
will never correctly return the value of a register in the
|
|
|
|
[NUM_REGS .. NUM_REGS+NUM_PSEUDO_REGS) range. */
|
|
|
|
ULONGEST val;
|
|
|
|
regcache_cooked_read_unsigned (dummy_regs, regno, &val);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Save all the registers on the dummy frame stack. Most ports save the
|
|
|
|
registers on the target stack. This results in lots of unnecessary memory
|
|
|
|
references, which are slow when debugging via a serial line. Instead, we
|
|
|
|
save all the registers internally, and never write them to the stack. The
|
|
|
|
registers get restored when the called function returns to the entry point,
|
|
|
|
where a breakpoint is laying in wait. */
|
|
|
|
|
|
|
|
void
|
|
|
|
generic_push_dummy_frame (void)
|
|
|
|
{
|
|
|
|
struct dummy_frame *dummy_frame;
|
2002-12-09 02:40:25 +01:00
|
|
|
CORE_ADDR fp = get_frame_base (get_current_frame ());
|
2002-11-08 20:42:00 +01:00
|
|
|
|
|
|
|
/* check to see if there are stale dummy frames,
|
|
|
|
perhaps left over from when a longjump took us out of a
|
|
|
|
function that was called by the debugger */
|
|
|
|
|
|
|
|
dummy_frame = dummy_frame_stack;
|
|
|
|
while (dummy_frame)
|
|
|
|
if (INNER_THAN (dummy_frame->fp, fp)) /* stale -- destroy! */
|
|
|
|
{
|
|
|
|
dummy_frame_stack = dummy_frame->next;
|
|
|
|
regcache_xfree (dummy_frame->regcache);
|
|
|
|
xfree (dummy_frame);
|
|
|
|
dummy_frame = dummy_frame_stack;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
dummy_frame = dummy_frame->next;
|
|
|
|
|
|
|
|
dummy_frame = xmalloc (sizeof (struct dummy_frame));
|
|
|
|
dummy_frame->regcache = regcache_xmalloc (current_gdbarch);
|
|
|
|
|
|
|
|
dummy_frame->pc = read_pc ();
|
|
|
|
dummy_frame->sp = read_sp ();
|
|
|
|
dummy_frame->top = 0;
|
|
|
|
dummy_frame->fp = fp;
|
2002-12-13 17:40:25 +01:00
|
|
|
dummy_frame->id = get_frame_id (get_current_frame ());
|
2002-11-08 20:42:00 +01:00
|
|
|
regcache_cpy (dummy_frame->regcache, current_regcache);
|
|
|
|
dummy_frame->next = dummy_frame_stack;
|
|
|
|
dummy_frame_stack = dummy_frame;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
generic_save_dummy_frame_tos (CORE_ADDR sp)
|
|
|
|
{
|
|
|
|
dummy_frame_stack->top = sp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Record the upper/lower bounds on the address of the call dummy. */
|
|
|
|
|
|
|
|
void
|
|
|
|
generic_save_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi)
|
|
|
|
{
|
|
|
|
dummy_frame_stack->call_lo = lo;
|
|
|
|
dummy_frame_stack->call_hi = hi;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Restore the machine state from either the saved dummy stack or a
|
|
|
|
real stack frame. */
|
|
|
|
|
|
|
|
void
|
|
|
|
generic_pop_current_frame (void (*popper) (struct frame_info * frame))
|
|
|
|
{
|
|
|
|
struct frame_info *frame = get_current_frame ();
|
2002-11-24 16:06:08 +01:00
|
|
|
if (get_frame_type (frame) == DUMMY_FRAME)
|
|
|
|
/* NOTE: cagney/2002-22-23: Does this ever occure? Surely a dummy
|
|
|
|
frame will have already been poped by the "infrun.c" code. */
|
2002-11-08 20:42:00 +01:00
|
|
|
generic_pop_dummy_frame ();
|
|
|
|
else
|
|
|
|
(*popper) (frame);
|
|
|
|
}
|
|
|
|
|
2003-01-19 18:39:16 +01:00
|
|
|
/* Discard the innermost dummy frame from the dummy frame stack
|
|
|
|
(passed in as a parameter). */
|
|
|
|
|
|
|
|
static void
|
|
|
|
discard_innermost_dummy (struct dummy_frame **stack)
|
|
|
|
{
|
|
|
|
struct dummy_frame *tbd = (*stack);
|
|
|
|
(*stack) = (*stack)->next;
|
|
|
|
regcache_xfree (tbd->regcache);
|
|
|
|
xfree (tbd);
|
|
|
|
}
|
|
|
|
|
2002-11-08 20:42:00 +01:00
|
|
|
void
|
|
|
|
generic_pop_dummy_frame (void)
|
|
|
|
{
|
|
|
|
struct dummy_frame *dummy_frame = dummy_frame_stack;
|
|
|
|
|
|
|
|
/* FIXME: what if the first frame isn't the right one, eg..
|
|
|
|
because one call-by-hand function has done a longjmp into another one? */
|
|
|
|
|
|
|
|
if (!dummy_frame)
|
|
|
|
error ("Can't pop dummy frame!");
|
|
|
|
regcache_cpy (current_regcache, dummy_frame->regcache);
|
|
|
|
flush_cached_frames ();
|
|
|
|
|
2003-01-19 18:39:16 +01:00
|
|
|
discard_innermost_dummy (&dummy_frame_stack);
|
2002-11-08 20:42:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Given a call-dummy dummy-frame, return the registers. Here the
|
|
|
|
register value is taken from the local copy of the register buffer. */
|
|
|
|
|
2003-01-18 Andrew Cagney <ac131313@redhat.com>
* dummy-frame.h (dummy_frame_id_unwind): Delete declaration.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
(struct frame_unwind): Declare opaque.
(dummy_frame_p): Declare function.
* dummy-frame.c (dummy_frame_id_unwind): Make static.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
* dummy-frame.c: Include "frame-unwind.h".
(dummy_frame_p): New function.
(dummy_frame_unwind): New variable.
* frame.c: Include "frame-unwind.h".
(frame_pc_unwind, frame_id_unwind, frame_register_unwind): Update
to use the new unwind field.
(set_unwind_by_pc): Delete function.
(create_new_frame, get_prev_frame): Set unwind field using
frame_unwind_find_by_pc.
(trad_frame_unwind, trad_frame_unwinder): New variables.
* frame.h (trad_frame_unwind): Declare variable.
(frame_id_unwind_ftype): Delete declaration.
(frame_pc_unwind_ftype, frame_register_unwind_ftype): Ditto.
(struct frame_unwind): Declare opaque.
(struct frame_info): Replace the fields id_unwind, pc_unwind and
register_unwind with a single unwind pointer.
* frame-unwind.h, frame-unwind.c: New files.
* Makefile.in (SFILES): Add frame-unwind.c.
(frame_unwind_h): Define.
(COMMON_OBS): Add frame-unwind.o.
(frame-unwind.o): Specify dependencies.
(frame.o, dummy-frame.o): Update dependencies.
2003-01-18 18:25:23 +01:00
|
|
|
static void
|
2003-03-17 15:23:50 +01:00
|
|
|
dummy_frame_prev_register (struct frame_info *next_frame,
|
|
|
|
void **this_prologue_cache,
|
|
|
|
int regnum, int *optimized,
|
|
|
|
enum lval_type *lvalp, CORE_ADDR *addrp,
|
|
|
|
int *realnum, void *bufferp)
|
2002-11-08 20:42:00 +01:00
|
|
|
{
|
2003-03-17 15:23:50 +01:00
|
|
|
struct dummy_frame *dummy;
|
|
|
|
struct frame_id id;
|
|
|
|
|
|
|
|
/* Call the ID method which, if at all possible, will set the
|
|
|
|
prologue cache. */
|
|
|
|
dummy_frame_this_id (next_frame, this_prologue_cache, &id);
|
|
|
|
dummy = (*this_prologue_cache);
|
2002-11-09 00:12:52 +01:00
|
|
|
gdb_assert (dummy != NULL);
|
2002-11-08 20:42:00 +01:00
|
|
|
|
|
|
|
/* Describe the register's location. Generic dummy frames always
|
|
|
|
have the register value in an ``expression''. */
|
|
|
|
*optimized = 0;
|
|
|
|
*lvalp = not_lval;
|
|
|
|
*addrp = 0;
|
|
|
|
*realnum = -1;
|
|
|
|
|
|
|
|
/* If needed, find and return the value of the register. */
|
|
|
|
if (bufferp != NULL)
|
|
|
|
{
|
|
|
|
/* Return the actual value. */
|
|
|
|
/* Use the regcache_cooked_read() method so that it, on the fly,
|
|
|
|
constructs either a raw or pseudo register from the raw
|
|
|
|
register cache. */
|
2002-11-09 00:12:52 +01:00
|
|
|
regcache_cooked_read (dummy->regcache, regnum, bufferp);
|
2002-11-08 20:42:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-03-17 15:23:50 +01:00
|
|
|
/* Assuming that THIS frame is a dummy (remember, the NEXT and not
|
|
|
|
THIS frame is passed in), return the ID of THIS frame. That ID is
|
|
|
|
determined by examining the NEXT frame's unwound registers using
|
|
|
|
the method unwind_dummy_id(). As a side effect, THIS dummy frame's
|
|
|
|
dummy cache is located and and saved in THIS_PROLOGUE_CACHE. */
|
2003-01-18 Andrew Cagney <ac131313@redhat.com>
* dummy-frame.h (dummy_frame_id_unwind): Delete declaration.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
(struct frame_unwind): Declare opaque.
(dummy_frame_p): Declare function.
* dummy-frame.c (dummy_frame_id_unwind): Make static.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
* dummy-frame.c: Include "frame-unwind.h".
(dummy_frame_p): New function.
(dummy_frame_unwind): New variable.
* frame.c: Include "frame-unwind.h".
(frame_pc_unwind, frame_id_unwind, frame_register_unwind): Update
to use the new unwind field.
(set_unwind_by_pc): Delete function.
(create_new_frame, get_prev_frame): Set unwind field using
frame_unwind_find_by_pc.
(trad_frame_unwind, trad_frame_unwinder): New variables.
* frame.h (trad_frame_unwind): Declare variable.
(frame_id_unwind_ftype): Delete declaration.
(frame_pc_unwind_ftype, frame_register_unwind_ftype): Ditto.
(struct frame_unwind): Declare opaque.
(struct frame_info): Replace the fields id_unwind, pc_unwind and
register_unwind with a single unwind pointer.
* frame-unwind.h, frame-unwind.c: New files.
* Makefile.in (SFILES): Add frame-unwind.c.
(frame_unwind_h): Define.
(COMMON_OBS): Add frame-unwind.o.
(frame-unwind.o): Specify dependencies.
(frame.o, dummy-frame.o): Update dependencies.
2003-01-18 18:25:23 +01:00
|
|
|
|
|
|
|
static void
|
2003-03-17 15:23:50 +01:00
|
|
|
dummy_frame_this_id (struct frame_info *next_frame,
|
|
|
|
void **this_prologue_cache,
|
|
|
|
struct frame_id *this_id)
|
2002-12-13 17:40:25 +01:00
|
|
|
{
|
2003-03-17 15:23:50 +01:00
|
|
|
struct dummy_frame *dummy = (*this_prologue_cache);
|
|
|
|
if (dummy != NULL)
|
|
|
|
{
|
|
|
|
(*this_id) = dummy->id;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* When unwinding a normal frame, the stack structure is determined
|
|
|
|
by analyzing the frame's function's code (be it using brute force
|
|
|
|
prologue analysis, or the dwarf2 CFI). In the case of a dummy
|
|
|
|
frame, that simply isn't possible. The The PC is either the
|
|
|
|
program entry point, or some random address on the stack. Trying
|
|
|
|
to use that PC to apply standard frame ID unwind techniques is
|
|
|
|
just asking for trouble. */
|
|
|
|
if (gdbarch_unwind_dummy_id_p (current_gdbarch))
|
|
|
|
{
|
|
|
|
/* Use an architecture specific method to extract the prev's
|
|
|
|
dummy ID from the next frame. Note that this method uses
|
|
|
|
frame_register_unwind to obtain the register values needed to
|
|
|
|
determine the dummy frame's ID. */
|
|
|
|
(*this_id) = gdbarch_unwind_dummy_id (current_gdbarch, next_frame);
|
|
|
|
}
|
|
|
|
else if (frame_relative_level (next_frame) < 0)
|
|
|
|
{
|
|
|
|
/* We're unwinding a sentinel frame, the PC of which is pointing
|
|
|
|
at a stack dummy. Fake up the dummy frame's ID using the
|
|
|
|
same sequence as is found a traditional unwinder. Once all
|
|
|
|
architectures supply the unwind_dummy_id method, this code
|
|
|
|
can go away. */
|
2003-04-28 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (DEPRECATED_TARGET_READ_FP): Replace TARGET_READ_FP.
(DEPRECATED_FP_REGNUM): Replace FP_REGNUM.
* gdbarch.h, gdbarch.c: Re-generate.
* infcall.c (call_function_by_hand): Use DEPRECATED_FP_REGNUM,
DEPRECATED_TARGET_READ_FP, or "sp" to create the dummy frame ID.
* inferior.h (deprecated_read_fp): Rename read_fp.
(generic_target_read_fp): Delete declaration.
* regcache.c (generic_target_read_fp): Delete function.
(deprecated_read_fp): Replace read_fp, use
DEPRECATED_TARGET_READ_FP or DEPRECATED_FP_REGNUM.
* d10v-tdep.c (d10v_read_fp): Delete function.
(d10v_gdbarch_init): Do not set deprecated_read_fp.
* sparc-tdep.c (sparc_gdbarch_init): Do not set
deprecated_target_read_fp to generic_target_read_fp.
* sh-tdep.c (sh_gdbarch_init): Ditto.
* rs6000-tdep.c (rs6000_gdbarch_init): Ditto.
* m68hc11-tdep.c (m68hc11_gdbarch_init): Ditto.
* frv-tdep.c (frv_gdbarch_init): Ditto.
* xstormy16-tdep.c (xstormy16_gdbarch_init): Set
deprecated_fp_regnum.
* x86-64-tdep.c (x86_64_init_abi): Ditto.
* vax-tdep.c (vax_gdbarch_init): Ditto.
* v850-tdep.c (v850_gdbarch_init): Ditto.
* sparc-tdep.c (sparc_gdbarch_init): Ditto.
* sh-tdep.c (sh_gdbarch_init): Ditto.
* s390-tdep.c (s390_gdbarch_init): Ditto.
* rs6000-tdep.c (rs6000_gdbarch_init): Ditto.
* mn10300-tdep.c (mn10300_gdbarch_init): Ditto.
* mcore-tdep.c (mcore_gdbarch_init): Ditto.
* m68k-tdep.c (m68k_gdbarch_init): Ditto.
* m68hc11-tdep.c (m68hc11_gdbarch_init): Ditto.
* ia64-tdep.c (ia64_gdbarch_init): Ditto.
* i386-tdep.c (i386_gdbarch_init): Ditto.
* hppa-tdep.c (hppa_gdbarch_init): Ditto.
* h8300-tdep.c (h8300_gdbarch_init): Ditto.
* frv-tdep.c (frv_gdbarch_init): Ditto.
* cris-tdep.c (cris_gdbarch_init): Ditto.
* avr-tdep.c (avr_gdbarch_init): Ditto.
* arm-tdep.c (arm_gdbarch_init): Ditto.
* alpha-tdep.c (alpha_gdbarch_init): Ditto.
* x86-64-tdep.c (x86_64_init_abi): Set deprecated_target_read_fp.
* v850-tdep.c (v850_gdbarch_init): Ditto.
* sparc-tdep.c (sparc_gdbarch_init): Ditto.
* sh-tdep.c (sh_gdbarch_init): Ditto.
* s390-tdep.c (s390_gdbarch_init): Ditto.
* rs6000-tdep.c (rs6000_gdbarch_init): Ditto.
* mn10300-tdep.c (mn10300_gdbarch_init): Ditto.
* mips-tdep.c (mips_gdbarch_init): Ditto.
* m68hc11-tdep.c (m68hc11_gdbarch_init): Ditto.
* ia64-tdep.c (ia64_gdbarch_init): Ditto.
* hppa-tdep.c (hppa_gdbarch_init): Ditto.
* frv-tdep.c (frv_gdbarch_init): Ditto.
* avr-tdep.c (avr_gdbarch_init): Ditto.
* arm-tdep.c (arm_gdbarch_init): Ditto.
* vax-tdep.c (vax_frame_init_saved_regs): Replace FP_REGNUM with
DEPRECATED_FP_REGNUM.
(vax_push_dummy_frame, vax_pop_frame): Ditto.
* std-regs.c (value_of_builtin_frame_fp_reg): Ditto.
* sparc-tdep.c (sparc_init_extra_frame_info): Ditto.
(sparc_push_dummy_frame, sparc64_read_fp): Ditto.
(sparc32_register_virtual_type): Ditto.
* sh-tdep.c (sh64_frame_chain): Ditto.
(sh64_get_saved_register, sh64_pop_frame): Ditto.
(sh_nofp_frame_init_saved_regs): Ditto.
(sh64_nofp_frame_init_saved_regs): Ditto.
(sh_fp_frame_init_saved_regs): Ditto.
* remote-mips.c (mips_wait, mips_fetch_registers): Ditto.
* remote-e7000.c (fetch_regs_from_dump): Ditto.
* procfs.c (procfs_fetch_registers): Ditto.
(procfs_store_registers): Ditto.
* ns32knbsd-nat.c (fetch_inferior_registers): Ditto.
(store_inferior_registers, fetch_core_registers): Ditto.
(fetch_kcore_registers, clear_regs): Ditto.
* ns32k-tdep.c (ns32k_frame_init_saved_regs): Ditto.
(ns32k_push_dummy_frame, ns32k_pop_frame): Ditto.
* nlm/i386.h (DEPRECATED_FP_REGNUM): Ditto.
* nlm/i386.c (do_status): Ditto.
* mipsv4-nat.c (supply_gregset): Ditto.
* mips-tdep.c: Ditto for comments.
* mips-nat.c (fetch_inferior_registers): Ditto.
(store_inferior_registers, fetch_core_registers): Ditto.
* m68k-tdep.c (m68k_push_dummy_frame): Ditto.
(m68k_pop_frame, m68k_frame_init_saved_regs): Ditto.
* i386-tdep.c (i386_frame_init_saved_regs): Ditto.
(i386_do_pop_frame, i386_register_type): Ditto.
* hppa-tdep.c (hppa_frame_chain): Ditto.
(hppa_push_dummy_frame, find_dummy_frame_regs): Ditto.
(hppa_pop_frame, hppa_read_fp): Ditto.
(skip_prologue_hard_way, hppa_frame_find_saved_regs): Ditto.
* cris-tdep.c (cris_examine, cris_pop_frame): Ditto.
* config/vax/nm-vax.h (REGISTER_U_ADDR): Ditto.
* config/sparc/tm-sparc.h (DEPRECATED_FP_REGNUM): Ditto.
* config/sparc/tm-sp64.h (DEPRECATED_FP_REGNUM): Ditto.
* config/s390/tm-s390.h (DEPRECATED_FP_REGNUM): Ditto.
* config/pa/tm-hppa64.h (DEPRECATED_FP_REGNUM): Ditto.
* config/ia64/tm-ia64.h (DEPRECATED_FP_REGNUM): Ditto.
* blockframe.c: Ditto for comments.
* arch-utils.h: Ditto for comments.
* arch-utils.c (legacy_virtual_frame_pointer): Ditto.
* alphanbsd-tdep.c (fetch_core_registers): Ditto.
* alphabsd-nat.c (fetch_inferior_registers): Ditto.
* alpha-tdep.h: Ditto for comments.
* alpha-tdep.c (alpha_cannot_fetch_register): Ditto.
(alpha_cannot_store_register): Ditto.
(alpha_push_dummy_frame): Ditto.
* alpha-nat.c (supply_gregset): Ditto.
* config/sparc/tm-sp64.h (DEPRECATED_TARGET_READ_FP): Update.
* config/pa/tm-hppa64.h (DEPRECATED_TARGET_READ_FP): Update.
* config/sparc/tm-sparc.h: Update comment.
* hppa-tdep.c (hppa_init_extra_frame_info): Use
deprecated_read_fp instead of TARGET_READ_FP.
(hppa_init_extra_frame_info, hppa_frame_chain): Ditto.
(hppa_push_dummy_frame, hppa_read_fp): Ditto.
* sparc-tdep.c (sparc_init_extra_frame_info): Use
deprecated_read_fp instead of read_fp.
* s390-tdep.c (s390_push_arguments): Ditto.
* ia64-tdep.c (ia64_gdbarch_init): Ditto.
* frame.h: Ditto in comments.
* frame.c (legacy_get_prev_frame): Ditto.
* dummy-frame.c (dummy_frame_this_id): Ditto.
* arm-tdep.c (arm_init_extra_frame_info): Ditto.
2003-04-28 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Replace
read_fp, TARGET_READ_FP and FP_REGNUM, with deprecated_read_fp,
DEPRECATED_TARGET_READ_FP and DEPRECATED_REGNUM.
2003-04-29 03:49:49 +02:00
|
|
|
(*this_id) = frame_id_build (deprecated_read_fp (), read_pc ());
|
2003-03-17 15:23:50 +01:00
|
|
|
}
|
|
|
|
else if (legacy_frame_p (current_gdbarch)
|
|
|
|
&& get_prev_frame (next_frame))
|
|
|
|
{
|
|
|
|
/* Things are looking seriously grim! Assume that the legacy
|
|
|
|
get_prev_frame code has already created THIS frame and linked
|
|
|
|
it in to the frame chain (a pretty bold assumption), extract
|
|
|
|
the ID from THIS base / pc. */
|
2003-04-04 23:04:33 +02:00
|
|
|
(*this_id) = frame_id_build (get_frame_base (get_prev_frame (next_frame)),
|
|
|
|
get_frame_pc (get_prev_frame (next_frame)));
|
2003-03-17 15:23:50 +01:00
|
|
|
}
|
2003-01-16 17:54:57 +01:00
|
|
|
else
|
2003-03-17 15:23:50 +01:00
|
|
|
{
|
|
|
|
/* Outch! We're not trying to find the innermost frame's ID yet
|
|
|
|
we're trying to unwind to a dummy. The architecture must
|
|
|
|
provide the unwind_dummy_id() method. Abandon the unwind
|
|
|
|
process but only after first warning the user. */
|
|
|
|
internal_warning (__FILE__, __LINE__,
|
|
|
|
"Missing unwind_dummy_id architecture method");
|
|
|
|
(*this_id) = null_frame_id;
|
|
|
|
return;
|
|
|
|
}
|
2003-04-10 05:30:36 +02:00
|
|
|
(*this_prologue_cache) = find_dummy_frame ((*this_id).code_addr,
|
|
|
|
(*this_id).stack_addr);
|
2002-12-13 17:40:25 +01:00
|
|
|
}
|
|
|
|
|
2003-01-18 Andrew Cagney <ac131313@redhat.com>
* dummy-frame.h (dummy_frame_id_unwind): Delete declaration.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
(struct frame_unwind): Declare opaque.
(dummy_frame_p): Declare function.
* dummy-frame.c (dummy_frame_id_unwind): Make static.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
* dummy-frame.c: Include "frame-unwind.h".
(dummy_frame_p): New function.
(dummy_frame_unwind): New variable.
* frame.c: Include "frame-unwind.h".
(frame_pc_unwind, frame_id_unwind, frame_register_unwind): Update
to use the new unwind field.
(set_unwind_by_pc): Delete function.
(create_new_frame, get_prev_frame): Set unwind field using
frame_unwind_find_by_pc.
(trad_frame_unwind, trad_frame_unwinder): New variables.
* frame.h (trad_frame_unwind): Declare variable.
(frame_id_unwind_ftype): Delete declaration.
(frame_pc_unwind_ftype, frame_register_unwind_ftype): Ditto.
(struct frame_unwind): Declare opaque.
(struct frame_info): Replace the fields id_unwind, pc_unwind and
register_unwind with a single unwind pointer.
* frame-unwind.h, frame-unwind.c: New files.
* Makefile.in (SFILES): Add frame-unwind.c.
(frame_unwind_h): Define.
(COMMON_OBS): Add frame-unwind.o.
(frame-unwind.o): Specify dependencies.
(frame.o, dummy-frame.o): Update dependencies.
2003-01-18 18:25:23 +01:00
|
|
|
static struct frame_unwind dummy_frame_unwind =
|
|
|
|
{
|
2003-04-05 05:56:00 +02:00
|
|
|
DUMMY_FRAME,
|
2003-03-17 15:23:50 +01:00
|
|
|
dummy_frame_this_id,
|
|
|
|
dummy_frame_prev_register
|
2003-01-18 Andrew Cagney <ac131313@redhat.com>
* dummy-frame.h (dummy_frame_id_unwind): Delete declaration.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
(struct frame_unwind): Declare opaque.
(dummy_frame_p): Declare function.
* dummy-frame.c (dummy_frame_id_unwind): Make static.
(dummy_frame_pc_unwind, dummy_frame_register_unwind): Ditto.
* dummy-frame.c: Include "frame-unwind.h".
(dummy_frame_p): New function.
(dummy_frame_unwind): New variable.
* frame.c: Include "frame-unwind.h".
(frame_pc_unwind, frame_id_unwind, frame_register_unwind): Update
to use the new unwind field.
(set_unwind_by_pc): Delete function.
(create_new_frame, get_prev_frame): Set unwind field using
frame_unwind_find_by_pc.
(trad_frame_unwind, trad_frame_unwinder): New variables.
* frame.h (trad_frame_unwind): Declare variable.
(frame_id_unwind_ftype): Delete declaration.
(frame_pc_unwind_ftype, frame_register_unwind_ftype): Ditto.
(struct frame_unwind): Declare opaque.
(struct frame_info): Replace the fields id_unwind, pc_unwind and
register_unwind with a single unwind pointer.
* frame-unwind.h, frame-unwind.c: New files.
* Makefile.in (SFILES): Add frame-unwind.c.
(frame_unwind_h): Define.
(COMMON_OBS): Add frame-unwind.o.
(frame-unwind.o): Specify dependencies.
(frame.o, dummy-frame.o): Update dependencies.
2003-01-18 18:25:23 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
const struct frame_unwind *
|
|
|
|
dummy_frame_p (CORE_ADDR pc)
|
|
|
|
{
|
|
|
|
if (DEPRECATED_PC_IN_CALL_DUMMY_P ()
|
|
|
|
? DEPRECATED_PC_IN_CALL_DUMMY (pc, 0, 0)
|
|
|
|
: pc_in_dummy_frame (pc))
|
|
|
|
return &dummy_frame_unwind;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
2003-05-05 20:33:11 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
fprint_dummy_frames (struct ui_file *file)
|
|
|
|
{
|
|
|
|
struct dummy_frame *s;
|
|
|
|
for (s = dummy_frame_stack; s != NULL; s = s->next)
|
|
|
|
{
|
|
|
|
gdb_print_host_address (s, file);
|
|
|
|
fprintf_unfiltered (file, ":");
|
|
|
|
fprintf_unfiltered (file, " pc=0x%s", paddr (s->pc));
|
|
|
|
fprintf_unfiltered (file, " fp=0x%s", paddr (s->fp));
|
|
|
|
fprintf_unfiltered (file, " sp=0x%s", paddr (s->sp));
|
|
|
|
fprintf_unfiltered (file, " top=0x%s", paddr (s->top));
|
|
|
|
fprintf_unfiltered (file, " id=");
|
|
|
|
fprint_frame_id (file, s->id);
|
|
|
|
fprintf_unfiltered (file, " call_lo=0x%s", paddr (s->call_lo));
|
|
|
|
fprintf_unfiltered (file, " call_hi=0x%s", paddr (s->call_hi));
|
|
|
|
fprintf_unfiltered (file, "\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
maintenance_print_dummy_frames (char *args, int from_tty)
|
|
|
|
{
|
|
|
|
if (args == NULL)
|
|
|
|
fprint_dummy_frames (gdb_stdout);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
struct ui_file *file = gdb_fopen (args, "w");
|
|
|
|
if (file == NULL)
|
|
|
|
perror_with_name ("maintenance print dummy-frames");
|
|
|
|
fprint_dummy_frames (file);
|
|
|
|
ui_file_delete (file);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
extern void _initialize_dummy_frame (void);
|
|
|
|
|
|
|
|
void
|
|
|
|
_initialize_dummy_frame (void)
|
|
|
|
{
|
|
|
|
add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames,
|
|
|
|
"Print the contents of the internal dummy-frame stack.",
|
|
|
|
&maintenanceprintlist);
|
|
|
|
|
|
|
|
}
|