Add two pointers (saved_regs, extra_info) to struct frame_info.
Introduce new macro FRAME_INIT_SAVED_REGS which replaces
FRAME_FIND_SAVED_REGS.
Document.
Use in mn10300 and rs6000 targets. Fix side effects on ALPHA, MIPS,
Z8K and SPARC targets.
+Sat Dec 12 09:28:13 1998 Andrew Cagney <cagney@b1.cygnus.com>
+
+ * frame.h (struct frame_info): Add CORE_ADDR *saved_regs and
+ struct frame_extra_info *extra_info.
+ (frame_obstack_alloc, frame_saved_regs_zalloc): Prototype.
+ (SIZEOF_FRAME_SAVED_REGS): Provide default.
+ (FRAME_INIT_SAVED_REGS): Provide default.
+ (struct frame_saved_regs): Deprecate.
+ (EXTRA_FRAME_INFO): Deprecate.
+
+ * blockframe.c (frame_obstack_alloc, frame_saved_regs_zalloc): New
+ function.
+ (generic_get_saved_register): Use FRAME_INIT_SAVED_REGS and
+ frame->saved_regs.
+ (frame_cache_obstack): Make static.
+ (get_frame_saved_regs): Deprecate. Copy the saved regs into the
+ frame buffer.
+
+ * stack.c (frame_info): Rewrite using frame->saved_regs and
+ FRAME_INIT_SAVED_REGS.
+ * findvar.c (find_saved_register): Ditto.
+
+ * config/mn10300/tm-mn10300.h (EXTRA_FRAME_INFO): Delete.
+ (FRAME_FIND_SAVED_REGS): Replace with FRAME_INIT_SAVED_REGS. No-op.
+ * mn10300-tdep.c: Update.
+ (analyze_dummy_frame): New function.
+ (struct frame_extra_info): Define.
+ (mn10300_init_extra_frame_info): Update.
+
+ * config/rs6000/tm-rs6000.h: (EXTRA_FRAME_INFO): Delete.
+ (FRAME_FIND_SAVED_REGS): Replace with FRAME_INIT_SAVED_REGS.
+ (FRAME_ARGS_ADDRESS): Replace with function.
+
+ * rs6000-tdep.c (frame_get_saved_regs): Rename from
+ frame_get_cache_fsr.
+ (rs6000_init_extra_frame_info): New function.
+ (rs6000_frame_init_saved_regs): Call frame_get_saved_regs.
+ (FUNCTION_START_OFFSET): Delete references, was ZERO.
+ (rs6000_frame_args_address): New function.
+ (frame_initial_stack_address): Update
+
+ * config/mips/tm-mips.h (EXTRA_FRAME_INFO): Remove saved_regs.
+ (FRAME_INIT_SAVED_REGS): Rename FRAME_FIND_SAVED_REGS, update.
+ * mips-tdep.c (mips_find_saved_regs, read_next_frame_reg,
+ init_extra_frame_info, mips_pop_frame): Update.
+ * config/alpha/tm-alpha.h (FRAME_INIT_SAVED_REGS,
+ EXTRA_FRAME_INFO), alpha-tdep.c (alpha_find_saved_regs,
+ alpha_pop_frame, init_extra_frame_info): Ditto.
+
+ * i960-tdep.c, m88k-tdep.c, h8300-tdep.c: Update.
+ * config/sparc/tm-sparc.h, config/a29k/tm-a29k.h: Define
+ FRAME_INIT_SAVED_REGS as no-op.
+
+ * z8k-tdep.c (z8k_init_frame_saved_regs): Rename
+ get_frame_saved_regs.
+ (examine_frame, z8k_skip_prologue): Update.
+ * config/z8k/tm-z8k.h (FRAME_INIT_SAVED_REGS): Define.
+
1998-12-11 Fernando Nasser <fnasser@totem.to.cygnus.com>
From J.T. Conklin <jtc@redbacknetworks.com>:
* gdbtk-cmds.c, mipsm3-nat.c, hppah-nat.c, infptrace.c,
i386gnu-nat.c, hppab-nat.c, core-aout.c, arm-xdep.c, alpha-nat.c,
altos-xdep.c, pyr-xdep.c, remote-st.c, remote-os9k.c,
- tahoe-tdep.c, pyr-tdep.c, v850ice.c, vax-tdep.c: Replace reg_name
- with REGISTER_NAME.
+ tahoe-tdep.c, pyr-tdep.c, vax-tdep.c: Replace reg_name with
+ REGISTER_NAME.
Thu Dec 10 15:19:40 1998 David Taylor <taylor@texas.cygnus.com>
start-sanitize-sky
* config/mips/tm-txvu.h (STEP_SKIPS_DELAY), txvu-tdep.c
(txvu_step_skips_delay): Change macro to function.
-end-sanitize-sky
+end-sanitize-sky
Thu Nov 26 11:19:15 1998 Andrew Cagney <cagney@amy.cygnus.com>
* config/alpha/tm-alpha.h (ABOUT_TO_RETURN): Replace macro.
/* FIXME: Some of this code should perhaps be merged with mips-tdep.c. */
-/* FIXME: Put this declaration in frame.h. */
-extern struct obstack frame_cache_obstack;
-\f
-
/* Prototypes for local functions. */
static alpha_extra_func_info_t push_sigtramp_desc PARAMS ((CORE_ADDR low_addr));
alpha_extra_func_info_t proc_desc;
int returnreg;
- frame->saved_regs = (struct frame_saved_regs *)
- obstack_alloc (&frame_cache_obstack, sizeof(struct frame_saved_regs));
- memset (frame->saved_regs, 0, sizeof (struct frame_saved_regs));
+ frame_saved_regs_zalloc (frame);
/* If it is the frame for __sigtramp, the saved registers are located
in a sigcontext structure somewhere on the stack. __sigtramp
for (ireg = 0; ireg < 32; ireg++)
{
reg_position = sigcontext_addr + SIGFRAME_REGSAVE_OFF + ireg * 8;
- frame->saved_regs->regs[ireg] = reg_position;
+ frame->saved_regs[ireg] = reg_position;
}
for (ireg = 0; ireg < 32; ireg++)
{
reg_position = sigcontext_addr + SIGFRAME_FPREGSAVE_OFF + ireg * 8;
- frame->saved_regs->regs[FP0_REGNUM + ireg] = reg_position;
+ frame->saved_regs[FP0_REGNUM + ireg] = reg_position;
}
- frame->saved_regs->regs[PC_REGNUM] = sigcontext_addr + SIGFRAME_PC_OFF;
+ frame->saved_regs[PC_REGNUM] = sigcontext_addr + SIGFRAME_PC_OFF;
return;
}
register number. */
if (mask & (1 << returnreg))
{
- frame->saved_regs->regs[returnreg] = reg_position;
+ frame->saved_regs[returnreg] = reg_position;
reg_position += 8;
mask &= ~(1 << returnreg); /* Clear bit for RA so we
don't save again later. */
for (ireg = 0; ireg <= 31 ; ++ireg)
if (mask & (1 << ireg))
{
- frame->saved_regs->regs[ireg] = reg_position;
+ frame->saved_regs[ireg] = reg_position;
reg_position += 8;
}
for (ireg = 0; ireg <= 31 ; ++ireg)
if (mask & (1 << ireg))
{
- frame->saved_regs->regs[FP0_REGNUM+ireg] = reg_position;
+ frame->saved_regs[FP0_REGNUM+ireg] = reg_position;
reg_position += 8;
}
- frame->saved_regs->regs[PC_REGNUM] = frame->saved_regs->regs[returnreg];
+ frame->saved_regs[PC_REGNUM] = frame->saved_regs[returnreg];
}
static CORE_ADDR
{
if (fi->saved_regs == NULL)
alpha_find_saved_regs (fi);
- if (fi->saved_regs->regs[regno])
- return read_memory_integer(fi->saved_regs->regs[regno], 8);
+ if (fi->saved_regs[regno])
+ return read_memory_integer(fi->saved_regs[regno], 8);
}
}
return read_register(regno);
(CORE_ADDR *)NULL,(CORE_ADDR *)NULL);
if (!IN_SIGTRAMP (frame->pc, name))
{
- frame->saved_regs = (struct frame_saved_regs*)
- obstack_alloc (&frame_cache_obstack,
- sizeof (struct frame_saved_regs));
- *frame->saved_regs = temp_saved_regs;
- frame->saved_regs->regs[PC_REGNUM]
- = frame->saved_regs->regs[RA_REGNUM];
+ frame->saved_regs = (CORE_ADDR*)
+ frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
+ memcpy (frame->saved_regs, temp_saved_regs.regs, SIZEOF_FRAME_SAVED_REGS);
+ frame->saved_regs[PC_REGNUM]
+ = frame->saved_regs[RA_REGNUM];
}
}
}
for (regnum = 32; --regnum >= 0; )
if (PROC_REG_MASK(proc_desc) & (1 << regnum))
write_register (regnum,
- read_memory_integer (frame->saved_regs->regs[regnum],
+ read_memory_integer (frame->saved_regs[regnum],
8));
for (regnum = 32; --regnum >= 0; )
if (PROC_FREG_MASK(proc_desc) & (1 << regnum))
write_register (regnum + FP0_REGNUM,
- read_memory_integer (frame->saved_regs->regs[regnum + FP0_REGNUM], 8));
+ read_memory_integer (frame->saved_regs[regnum + FP0_REGNUM], 8));
}
write_register (SP_REGNUM, new_sp);
flush_cached_frames ();
void read_register_stack ();
long read_register_stack_integer ();
\f
+#define FRAME_INIT_SAVED_REGS(fi) /*no-op*/
+
#define EXTRA_FRAME_INFO \
CORE_ADDR saved_msp; \
unsigned int rsize; \
ways in the stack frame. sp is even more special:
the address we return for it IS the sp for the next frame. */
-#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
+#define FRAME_INIT_SAVED_REGS(frame_info) \
do { \
if ((frame_info)->saved_regs == NULL) \
mips_find_saved_regs (frame_info); \
- (frame_saved_regs) = *(frame_info)->saved_regs; \
- (frame_saved_regs).regs[SP_REGNUM] = (frame_info)->frame; \
+ (frame_info)->saved_regs[SP_REGNUM] = (frame_info)->frame; \
} while (0)
extern void mips_find_saved_regs PARAMS ((struct frame_info *));
#define EXTRA_FRAME_INFO \
mips_extra_func_info_t proc_desc; \
- int num_args;\
- struct frame_saved_regs *saved_regs;
+ int num_args;
#define INIT_EXTRA_FRAME_INFO(fromleaf, fci) init_extra_frame_info(fci)
extern void init_extra_frame_info PARAMS ((struct frame_info *));
#ifdef __STDC__
struct frame_info;
-struct frame_saved_regs;
struct type;
struct value;
#endif
-#define EXTRA_FRAME_INFO struct frame_saved_regs fsr; int status; int stack_size;
-
extern void mn10300_init_extra_frame_info PARAMS ((struct frame_info *));
#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) mn10300_init_extra_frame_info (fi)
#define INIT_FRAME_PC /* Not necessary */
-extern void mn10300_frame_find_saved_regs PARAMS ((struct frame_info *,
- struct frame_saved_regs *));
-#define FRAME_FIND_SAVED_REGS(fi, regaddr) regaddr = fi->fsr
+#define FRAME_INIT_SAVED_REGS(fi) /* handled by init_extra_frame_info */
extern CORE_ADDR mn10300_frame_chain PARAMS ((struct frame_info *));
#define FRAME_CHAIN(fi) mn10300_frame_chain (fi)
extern int frameless_function_invocation PARAMS((struct frame_info *));
-/* Functions calling alloca() change the value of the stack pointer. We
- need to use initial stack pointer (which is saved in r31 by gcc) in
- such cases. If a compiler emits traceback table, then we should use the
- alloca register specified in traceback table. FIXME. */
-/* Also, it is a good idea to cache information about frame's saved registers
- in the frame structure to speed things up. See tm-m88k.h. FIXME. */
-
-#define EXTRA_FRAME_INFO \
- CORE_ADDR initial_sp; /* initial stack pointer. */ \
- struct frame_saved_regs *cache_fsr; /* saved registers */
-
#define INIT_FRAME_PC_FIRST(fromleaf, prev) \
prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
#define INIT_FRAME_PC(fromleaf, prev) /* nothing */
-#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \
- fi->initial_sp = 0; \
- fi->cache_fsr = 0; \
- if (fi->next != (CORE_ADDR)0 \
- && fi->pc < TEXT_SEGMENT_BASE) \
- /* We're in get_prev_frame_info */ \
- /* and this is a special signal frame. */ \
- /* (fi->pc will be some low address in the kernel, */ \
- /* to which the signal handler returns). */ \
- fi->signal_handler_caller = 1;
+extern void rs6000_init_extra_frame_info (int fromleaf, struct frame_info *);
+#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) rs6000_init_extra_frame_info (fromleaf, fi)
/* If the kernel has to deliver a signal, it pushes a sigcontext
structure on the stack and then calls the signal handler, passing
extern unsigned long frame_saved_pc PARAMS ((struct frame_info *));
-#define FRAME_ARGS_ADDRESS(FI) \
- (((struct frame_info*)(FI))->initial_sp ? \
- ((struct frame_info*)(FI))->initial_sp : \
- frame_initial_stack_address (FI))
-extern CORE_ADDR frame_initial_stack_address PARAMS ((struct frame_info *));
+extern CORE_ADDR rs6000_frame_args_address PARAMS ((struct frame_info *));
+#define FRAME_ARGS_ADDRESS(FI) rs6000_frame_args_address (FI)
#define FRAME_LOCALS_ADDRESS(FI) FRAME_ARGS_ADDRESS(FI)
not sure if it will be needed. The following macro takes care of gpr's
and fpr's only. */
-#define FRAME_FIND_SAVED_REGS(FRAME_INFO, FRAME_SAVED_REGS) \
-{ \
- int ii; \
- CORE_ADDR frame_addr, func_start; \
- struct rs6000_framedata fdata; \
- \
- /* find the start of the function and collect info about its frame. */ \
- \
- func_start = get_pc_function_start ((FRAME_INFO)->pc) + FUNCTION_START_OFFSET; \
- (void) skip_prologue (func_start, &fdata); \
- memset (&(FRAME_SAVED_REGS), '\0', sizeof (FRAME_SAVED_REGS)); \
- \
- /* if there were any saved registers, figure out parent's stack pointer. */ \
- /* the following is true only if the frame doesn't have a call to alloca(), \
- FIXME. */ \
- if (fdata.saved_fpr == 0 && fdata.saved_gpr == 0 && \
- fdata.lr_offset == 0 && fdata.cr_offset == 0) { \
- frame_addr = 0; \
- \
- } else if ((FRAME_INFO)->prev && (FRAME_INFO)->prev->frame) { \
- frame_addr = (FRAME_INFO)->prev->frame; \
- \
- } else { \
- frame_addr = read_memory_integer ((FRAME_INFO)->frame, 4); \
- } \
- \
- /* if != -1, fdata.saved_fpr is the smallest number of saved_fpr. All \
- fpr's from saved_fpr to f31 are saved. */ \
- if (fdata.saved_fpr >= 0) { \
- int fpr_offset = frame_addr + fdata.fpr_offset; \
- for (ii = fdata.saved_fpr; ii < 32; ii++) { \
- (FRAME_SAVED_REGS).regs [FP0_REGNUM + ii] = fpr_offset; \
- fpr_offset += 8; \
- } \
- } \
- \
- /* if != -1, fdata.saved_gpr is the smallest number of saved_gpr. All \
- gpr's from saved_gpr to r31 are saved. */ \
- if (fdata.saved_gpr >= 0) { \
- int gpr_offset = frame_addr + fdata.gpr_offset; \
- for (ii = fdata.saved_gpr; ii < 32; ii++) { \
- (FRAME_SAVED_REGS).regs [ii] = gpr_offset; \
- gpr_offset += 4; \
- } \
- } \
- \
- /* If != 0, fdata.cr_offset is the offset from the frame that holds \
- the CR */ \
- if (fdata.cr_offset != 0) { \
- (FRAME_SAVED_REGS).regs [CR_REGNUM] = frame_addr + fdata.cr_offset; \
- } \
- \
- /* If != 0, fdata.cr_offset is the offset from the frame that holds \
- the LR */ \
- if (fdata.lr_offset != 0) { \
- (FRAME_SAVED_REGS).regs [LR_REGNUM] = frame_addr + fdata.lr_offset; \
- } \
-}
+extern void rs6000_frame_init_saved_regs PARAMS ((struct frame_info *));
+#define FRAME_INIT_SAVED_REGS(FI) rs6000_frame_init_saved_regs (FI)
-\f
/* Things needed for making the inferior call functions. */
/* Push an empty stack frame, to record the current PC, etc. */
/* time of the register saves. */ \
int sp_offset;
+#define FRAME_INIT_SAVED_REGS(fp) /*no-op*/
+
#define INIT_EXTRA_FRAME_INFO(fromleaf, fci) \
sparc_init_extra_frame_info (fromleaf, fci)
extern void sparc_init_extra_frame_info PARAMS((int, struct frame_info *));
#define FRAME_ARGS_SKIP 8
+#ifdef __STDC__
+struct frame_info;
+#endif
+extern void z8k_frame_init_saved_regs PARAMS ((struct frame_info *));
+#define FRAME_INIT_SAVED_REGS(fi) z8k_frame_init_saved_regs (fi)
\f
/* Things needed for making the inferior call functions.
+Thu Dec 10 16:07:09 1998 Andrew Cagney <cagney@b1.cygnus.com>
+
+ * gdbint.texinfo (FRAME_FIND_SAVED_REGS): Document.
+
Wed Dec 9 21:13:57 1998 Andrew Cagney <cagney@chook>
* gdbint.texinfo (REGISTER_NAME): Replace REGISTER_NAMES.
structure value, as a CORE_ADDR (or an expression that can be used as
one).
-@item EXTRA_FRAME_INFO
-If defined, this must be a list of slots that may be inserted into the
-@code{frame_info} structure defined in @code{frame.h}.
-
@item FLOAT_INFO
If defined, then the `info float' command will print information about
the processor's floating point unit.
nonzero and the given frame's PC is not in @code{main()} or a known
entry point function (such as @code{_start()}).
-@item FRAME_FIND_SAVED_REGS
-stack.c
+@item FRAME_INIT_SAVED_REGS(frame)
+See @file{frame.h}. Determines the address of all registers in the
+current stack frame storing each in @code{frame->saved_regs}. Space for
+@code{frame->saved_regs} shall be allocated by
+@code{FRAME_INIT_SAVED_REGS} using either
+@code{frame_saved_regs_zalloc} or @code{frame_obstack_alloc}.
+
+@var{FRAME_FIND_SAVED_REGS} and @var{EXTRA_FRAME_INFO} are deprecated.
@item FRAME_NUM_ARGS (val, fi)
For the frame described by @var{fi}, set @var{val} to the number of arguments
@item IEEE_FLOAT
Define this if the target system uses IEEE-format floating point numbers.
-@item INIT_EXTRA_FRAME_INFO (fromleaf, fci)
-If defined, this should be a C expression or statement that fills in the
-@code{EXTRA_FRAME_INFO} slots of the given frame @var{fci}.
+@item INIT_EXTRA_FRAME_INFO (fromleaf, frame)
+If additional information about the frame is required this should be
+stored in @code{frame->extra_info}. Space for @code{frame->extra_info}
+is allocated using @code{frame_obstack_alloc}.
@item INIT_FRAME_PC (fromleaf, prev)
This is a C statement that sets the pc of the frame pointed to by
ways in the stack frame. sp is even more special:
the address we return for it IS the sp for the next frame.
- We cache the result of doing this in the frame_cache_obstack, since
- it is fairly expensive. */
+ We cache the result of doing this in the frame_obstack, since it is
+ fairly expensive. */
void
h8300_frame_find_saved_regs (fi, fsr)
struct frame_saved_regs *fsr;
{
register struct frame_saved_regs *cache_fsr;
- extern struct obstack frame_cache_obstack;
CORE_ADDR ip;
struct symtab_and_line sal;
CORE_ADDR limit;
if (!fi->fsr)
{
cache_fsr = (struct frame_saved_regs *)
- obstack_alloc (&frame_cache_obstack,
- sizeof (struct frame_saved_regs));
+ frame_obstack_alloc (sizeof (struct frame_saved_regs));
memset (cache_fsr, '\0', sizeof (struct frame_saved_regs));
fi->fsr = cache_fsr;
ways in the stack frame. sp is even more special:
the address we return for it IS the sp for the next frame.
- We cache the result of doing this in the frame_cache_obstack, since
- it is fairly expensive. */
+ We cache the result of doing this in the frame_obstack, since it is
+ fairly expensive. */
void
frame_find_saved_regs (fi, fsr)
register CORE_ADDR *saved_regs;
register int regnum;
register struct frame_saved_regs *cache_fsr;
- extern struct obstack frame_cache_obstack;
CORE_ADDR ip;
struct symtab_and_line sal;
CORE_ADDR limit;
if (!fi->fsr)
{
cache_fsr = (struct frame_saved_regs *)
- obstack_alloc (&frame_cache_obstack,
- sizeof (struct frame_saved_regs));
+ frame_obstack_alloc (sizeof (struct frame_saved_regs));
memset (cache_fsr, '\0', sizeof (struct frame_saved_regs));
fi->fsr = cache_fsr;
ways in the stack frame. sp is even more special:
the address we return for it IS the sp for the next frame.
- We cache the result of doing this in the frame_cache_obstack, since
- it is fairly expensive. */
+ We cache the result of doing this in the frame_obstack, since it is
+ fairly expensive. */
void
frame_find_saved_regs (fi, fsr)
struct frame_saved_regs *fsr;
{
register struct frame_saved_regs *cache_fsr;
- extern struct obstack frame_cache_obstack;
CORE_ADDR ip;
struct symtab_and_line sal;
CORE_ADDR limit;
if (!fi->fsr)
{
cache_fsr = (struct frame_saved_regs *)
- obstack_alloc (&frame_cache_obstack,
- sizeof (struct frame_saved_regs));
+ frame_obstack_alloc (sizeof (struct frame_saved_regs));
memset (cache_fsr, '\0', sizeof (struct frame_saved_regs));
fi->fsr = cache_fsr;
/* Do not use "TARGET_IS_MIPS64" to test the size of floating point registers */
#define FP_REGISTER_DOUBLE (REGISTER_VIRTUAL_SIZE(FP0_REGNUM) == 8)
-/* FIXME: Put this declaration in frame.h. */
-extern struct obstack frame_cache_obstack;
-
#if 0
static int mips_in_lenient_prologue PARAMS ((CORE_ADDR, CORE_ADDR));
#endif
mips_extra_func_info_t proc_desc;
t_inst inst;
- fci->saved_regs = (struct frame_saved_regs *)
- obstack_alloc (&frame_cache_obstack, sizeof(struct frame_saved_regs));
- memset (fci->saved_regs, 0, sizeof (struct frame_saved_regs));
+ frame_saved_regs_zalloc (fci);
/* If it is the frame for sigtramp, the saved registers are located
in a sigcontext structure somewhere on the stack.
{
reg_position = fci->frame + SIGFRAME_REGSAVE_OFF
+ ireg * SIGFRAME_REG_SIZE;
- fci->saved_regs->regs[ireg] = reg_position;
+ fci->saved_regs[ireg] = reg_position;
}
for (ireg = 0; ireg < MIPS_NUMREGS; ireg++)
{
reg_position = fci->frame + SIGFRAME_FPREGSAVE_OFF
+ ireg * SIGFRAME_REG_SIZE;
- fci->saved_regs->regs[FP0_REGNUM + ireg] = reg_position;
+ fci->saved_regs[FP0_REGNUM + ireg] = reg_position;
}
- fci->saved_regs->regs[PC_REGNUM] = fci->frame + SIGFRAME_PC_OFF;
+ fci->saved_regs[PC_REGNUM] = fci->frame + SIGFRAME_PC_OFF;
return;
}
for (ireg= MIPS_NUMREGS-1; gen_mask; --ireg, gen_mask <<= 1)
if (gen_mask & 0x80000000)
{
- fci->saved_regs->regs[ireg] = reg_position;
+ fci->saved_regs[ireg] = reg_position;
reg_position -= MIPS_REGSIZE;
/* start-sanitize-r5900 */
#ifdef R5900_128BIT_GPR_HACK
/* Check if the s0 and s1 registers were pushed on the stack. */
for (reg = 16; reg < sreg_count+16; reg++)
{
- fci->saved_regs->regs[reg] = reg_position;
+ fci->saved_regs[reg] = reg_position;
reg_position -= MIPS_REGSIZE;
}
}
for (ireg = MIPS_NUMREGS-1; float_mask; --ireg, float_mask <<= 1)
if (float_mask & 0x80000000)
{
- fci->saved_regs->regs[FP0_REGNUM+ireg] = reg_position;
+ fci->saved_regs[FP0_REGNUM+ireg] = reg_position;
reg_position -= MIPS_REGSIZE;
}
- fci->saved_regs->regs[PC_REGNUM] = fci->saved_regs->regs[RA_REGNUM];
+ fci->saved_regs[PC_REGNUM] = fci->saved_regs[RA_REGNUM];
}
static CORE_ADDR
{
if (fi->saved_regs == NULL)
mips_find_saved_regs (fi);
- if (fi->saved_regs->regs[regno])
- return read_memory_integer(fi->saved_regs->regs[regno], MIPS_REGSIZE);
+ if (fi->saved_regs[regno])
+ return read_memory_integer(fi->saved_regs[regno], MIPS_REGSIZE);
}
}
return read_register (regno);
(CORE_ADDR *)NULL,(CORE_ADDR *)NULL);
if (!IN_SIGTRAMP (fci->pc, name))
{
- fci->saved_regs = (struct frame_saved_regs*)
- obstack_alloc (&frame_cache_obstack,
- sizeof (struct frame_saved_regs));
- *fci->saved_regs = temp_saved_regs;
- fci->saved_regs->regs[PC_REGNUM]
- = fci->saved_regs->regs[RA_REGNUM];
+ fci->saved_regs = (CORE_ADDR*)
+ frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
+ memcpy (fci->saved_regs, temp_saved_regs.regs, SIZEOF_FRAME_SAVED_REGS);
+ fci->saved_regs[PC_REGNUM]
+ = fci->saved_regs[RA_REGNUM];
}
}
for (regnum = 0; regnum < NUM_REGS; regnum++)
{
if (regnum != SP_REGNUM && regnum != PC_REGNUM
- && frame->saved_regs->regs[regnum])
+ && frame->saved_regs[regnum])
write_register (regnum,
- read_memory_integer (frame->saved_regs->regs[regnum],
+ read_memory_integer (frame->saved_regs[regnum],
MIPS_REGSIZE));
}
write_register (SP_REGNUM, new_sp);
#include "objfiles.h"
#include "xcoffsolib.h"
-extern struct obstack frame_cache_obstack;
-
extern int errno;
/* Breakpoint shadows for the single step instructions will be kept here. */
static CORE_ADDR branch_dest PARAMS ((int opcode, int instr, CORE_ADDR pc,
CORE_ADDR safety));
-static void frame_get_cache_fsr PARAMS ((struct frame_info *fi,
- struct rs6000_framedata *fdatap));
+static void frame_get_saved_regs PARAMS ((struct frame_info *fi,
+ struct rs6000_framedata *fdatap));
static void pop_dummy_frame PARAMS ((void));
+static CORE_ADDR frame_initial_stack_address PARAMS ((struct frame_info *));
+
+/* Fill in fi->saved_regs */
+
+struct frame_extra_info
+{
+ /* Functions calling alloca() change the value of the stack
+ pointer. We need to use initial stack pointer (which is saved in
+ r31 by gcc) in such cases. If a compiler emits traceback table,
+ then we should use the alloca register specified in traceback
+ table. FIXME. */
+ CORE_ADDR initial_sp; /* initial stack pointer. */ \
+};
+
+void
+rs6000_init_extra_frame_info (fromleaf, fi)
+ int fromleaf;
+ struct frame_info *fi;
+{
+ fi->extra_info = (struct frame_extra_info*)
+ frame_obstack_alloc (sizeof (struct frame_extra_info));
+ fi->extra_info->initial_sp = 0;
+ if (fi->next != (CORE_ADDR) 0
+ && fi->pc < TEXT_SEGMENT_BASE)
+ /* We're in get_prev_frame_info */
+ /* and this is a special signal frame. */
+ /* (fi->pc will be some low address in the kernel, */
+ /* to which the signal handler returns). */
+ fi->signal_handler_caller = 1;
+}
+
+
+void
+rs6000_frame_init_saved_regs (fi)
+ struct frame_info *fi;
+{
+ frame_get_saved_regs (fi, NULL);
+}
+
+CORE_ADDR
+rs6000_frame_args_address (fi)
+ struct frame_info *fi;
+{
+ if (fi->extra_info->initial_sp != 0)
+ return fi->extra_info->initial_sp;
+ else
+ return frame_initial_stack_address (fi);
+}
+
+
/* Calculate the destination of a branch/jump. Return -1 if not a branch. */
static CORE_ADDR
pc = read_register(PC_REGNUM);
store_address (pc_targ, 4, pc);
- skip_prologue (get_pc_function_start (pc) + FUNCTION_START_OFFSET, &fdata);
+ skip_prologue (get_pc_function_start (pc), &fdata);
dummy_frame_addr [dummy_frame_count++] = sp;
still in the link register, otherwise walk the frames and retrieve the
saved %pc value in the previous frame. */
- addr = get_pc_function_start (frame->pc) + FUNCTION_START_OFFSET;
+ addr = get_pc_function_start (frame->pc);
(void) skip_prologue (addr, &fdata);
if (fdata.frameless)
return 0;
}
- func_start += FUNCTION_START_OFFSET;
(void) skip_prologue (func_start, &fdata);
return fdata.frameless;
}
return generic_read_register_dummy(fi->pc, fi->frame, PC_REGNUM);
#endif /* GENERIC_DUMMY_FRAMES */
- func_start = get_pc_function_start (fi->pc) + FUNCTION_START_OFFSET;
+ func_start = get_pc_function_start (fi->pc);
/* If we failed to find the start of the function, it is a mistake
to inspect the instructions. */
in which case the framedata are read. */
static void
-frame_get_cache_fsr (fi, fdatap)
+frame_get_saved_regs (fi, fdatap)
struct frame_info *fi;
struct rs6000_framedata *fdatap;
{
CORE_ADDR frame_addr;
struct rs6000_framedata work_fdata;
- if (fi->cache_fsr)
+ if (fi->saved_regs)
return;
- if (fdatap == NULL) {
- fdatap = &work_fdata;
- (void) skip_prologue (get_pc_function_start (fi->pc), fdatap);
- }
+ if (fdatap == NULL)
+ {
+ fdatap = &work_fdata;
+ (void) skip_prologue (get_pc_function_start (fi->pc), fdatap);
+ }
+
+ frame_saved_regs_zalloc (fi);
- fi->cache_fsr = (struct frame_saved_regs *)
- obstack_alloc (&frame_cache_obstack, sizeof (struct frame_saved_regs));
- memset (fi->cache_fsr, '\0', sizeof (struct frame_saved_regs));
+ /* If there were any saved registers, figure out parent's stack
+ pointer. */
+ /* The following is true only if the frame doesn't have a call to
+ alloca(), FIXME. */
- if (fi->prev && fi->prev->frame)
+ if (fdatap->saved_fpr == 0 && fdatap->saved_gpr == 0
+ && fdatap->lr_offset == 0 && fdatap->cr_offset == 0)
+ frame_addr = 0;
+ else if (fi->prev && fi->prev->frame)
frame_addr = fi->prev->frame;
else
frame_addr = read_memory_integer (fi->frame, 4);
/* if != -1, fdatap->saved_fpr is the smallest number of saved_fpr.
All fpr's from saved_fpr to fp31 are saved. */
- if (fdatap->saved_fpr >= 0) {
- int fpr_offset = frame_addr + fdatap->fpr_offset;
- for (ii = fdatap->saved_fpr; ii < 32; ii++) {
- fi->cache_fsr->regs [FP0_REGNUM + ii] = fpr_offset;
- fpr_offset += 8;
+ if (fdatap->saved_fpr >= 0)
+ {
+ int i;
+ int fpr_offset = frame_addr + fdatap->fpr_offset;
+ for (i = fdatap->saved_fpr; i < 32; i++)
+ {
+ fi->saved_regs [FP0_REGNUM + i] = fpr_offset;
+ fpr_offset += 8;
+ }
}
- }
/* if != -1, fdatap->saved_gpr is the smallest number of saved_gpr.
All gpr's from saved_gpr to gpr31 are saved. */
-
- if (fdatap->saved_gpr >= 0) {
- int gpr_offset = frame_addr + fdatap->gpr_offset;
- for (ii = fdatap->saved_gpr; ii < 32; ii++) {
- fi->cache_fsr->regs [ii] = gpr_offset;
- gpr_offset += 4;
+
+ if (fdatap->saved_gpr >= 0)
+ {
+ int i;
+ int gpr_offset = frame_addr + fdatap->gpr_offset;
+ for (i = fdatap->saved_gpr; i < 32; i++)
+ {
+ fi->saved_regs [i] = gpr_offset;
+ gpr_offset += 4;
+ }
}
- }
/* If != 0, fdatap->cr_offset is the offset from the frame that holds
the CR. */
if (fdatap->cr_offset != 0)
- fi->cache_fsr->regs [CR_REGNUM] = frame_addr + fdatap->cr_offset;
+ fi->saved_regs [CR_REGNUM] = frame_addr + fdatap->cr_offset;
/* If != 0, fdatap->lr_offset is the offset from the frame that holds
the LR. */
if (fdatap->lr_offset != 0)
- fi->cache_fsr->regs [LR_REGNUM] = frame_addr + fdatap->lr_offset;
+ fi->saved_regs [LR_REGNUM] = frame_addr + fdatap->lr_offset;
}
/* Return the address of a frame. This is the inital %sp value when the frame
was first allocated. For functions calling alloca(), it might be saved in
an alloca register. */
-CORE_ADDR
+static CORE_ADDR
frame_initial_stack_address (fi)
struct frame_info *fi;
{
/* if the initial stack pointer (frame address) of this frame is known,
just return it. */
- if (fi->initial_sp)
- return fi->initial_sp;
+ if (fi->extra_info->initial_sp)
+ return fi->extra_info->initial_sp;
/* find out if this function is using an alloca register.. */
/* if saved registers of this frame are not known yet, read and cache them. */
- if (!fi->cache_fsr)
- frame_get_cache_fsr (fi, &fdata);
+ if (!fi->saved_regs)
+ frame_get_saved_regs (fi, &fdata);
/* If no alloca register used, then fi->frame is the value of the %sp for
this frame, and it is good enough. */
- if (fdata.alloca_reg < 0) {
- fi->initial_sp = fi->frame;
- return fi->initial_sp;
- }
+ if (fdata.alloca_reg < 0)
+ {
+ fi->extra_info->initial_sp = fi->frame;
+ return fi->extra_info->initial_sp;
+ }
/* This function has an alloca register. If this is the top-most frame
(with the lowest address), the value in alloca register is good. */
if (!fi->next)
- return fi->initial_sp = read_register (fdata.alloca_reg);
+ return fi->extra_info->initial_sp = read_register (fdata.alloca_reg);
/* Otherwise, this is a caller frame. Callee has usually already saved
registers, but there are exceptions (such as when the callee
for (callee_fi = fi->next; callee_fi; callee_fi = callee_fi->next) {
- if (!callee_fi->cache_fsr)
- frame_get_cache_fsr (callee_fi, NULL);
+ if (!callee_fi->saved_regs)
+ frame_get_saved_regs (callee_fi, NULL);
/* this is the address in which alloca register is saved. */
- tmpaddr = callee_fi->cache_fsr->regs [fdata.alloca_reg];
+ tmpaddr = callee_fi->saved_regs [fdata.alloca_reg];
if (tmpaddr) {
- fi->initial_sp = read_memory_integer (tmpaddr, 4);
- return fi->initial_sp;
+ fi->extra_info->initial_sp = read_memory_integer (tmpaddr, 4);
+ return fi->extra_info->initial_sp;
}
/* Go look into deeper levels of the frame chain to see if any one of
/* If alloca register was not saved, by the callee (or any of its callees)
then the value in the register is still good. */
- return fi->initial_sp = read_register (fdata.alloca_reg);
+ fi->extra_info->initial_sp = read_register (fdata.alloca_reg);
+ return fi->extra_info->initial_sp;
}
CORE_ADDR
return pc;
}
-int
+static CORE_ADDR examine_frame PARAMS ((CORE_ADDR, CORE_ADDR *regs, CORE_ADDR));
+static CORE_ADDR
examine_frame (pc, regs, sp)
CORE_ADDR pc;
- struct frame_saved_regs *regs;
+ CORE_ADDR *regs;
CORE_ADDR sp;
{
int w = read_memory_short (pc);
int regno;
for (regno = 0; regno < NUM_REGS; regno++)
- regs->regs[regno] = 0;
+ regs[regno] = 0;
while (IS_PUSHW (w) || IS_PUSHL (w))
{
/* work out which register is being pushed to where */
if (IS_PUSHL (w))
{
- regs->regs[w & 0xf] = offset;
- regs->regs[(w & 0xf) + 1] = offset + 2;
+ regs[w & 0xf] = offset;
+ regs[(w & 0xf) + 1] = offset + 2;
offset += 4;
}
else
{
- regs->regs[w & 0xf] = offset;
+ regs[w & 0xf] = offset;
offset += 2;
}
pc += 2;
/* Subtracting a value from the sp, so were in a function
which needs stack space for locals, but has no fp. We fake up
the values as if we had an fp */
- regs->regs[FP_REGNUM] = sp;
+ regs[FP_REGNUM] = sp;
}
else
{
/* This one didn't have an fp, we'll fake it up */
- regs->regs[SP_REGNUM] = sp;
+ regs[SP_REGNUM] = sp;
}
/* stack pointer contains address of next frame */
- /* regs->regs[fp_regnum()] = fp;*/
- regs->regs[SP_REGNUM] = sp;
+ /* regs[fp_regnum()] = fp;*/
+ regs[SP_REGNUM] = sp;
return pc;
}
z8k_skip_prologue (start_pc)
CORE_ADDR start_pc;
{
- struct frame_saved_regs dummy;
+ CORE_ADDR dummy[NUM_REGS];
- return examine_frame (start_pc, &dummy, 0);
+ return examine_frame (start_pc, dummy, 0);
}
CORE_ADDR
the address we return for it IS the sp for the next frame. */
void
-get_frame_saved_regs (frame_info, frame_saved_regs)
+z8k_frame_init_saved_regs (frame_info)
struct frame_info *frame_info;
- struct frame_saved_regs *frame_saved_regs;
-
{
CORE_ADDR pc;
int w;
- memset (frame_saved_regs, '\0', sizeof (*frame_saved_regs));
+ frame_saved_regs_zalloc (frame_info);
pc = get_pc_function_start (frame_info->pc);
-/* wander down the instruction stream */
- examine_frame (pc, frame_saved_regs, frame_info->frame);
+ /* wander down the instruction stream */
+ examine_frame (pc, frame_info->saved_regs, frame_info->frame);
}
return 0;
}
+#if 0
/* Put here the code to store, into a struct frame_saved_regs,
the addresses of the saved registers of frame described by FRAME_INFO.
This includes special registers such as pc and fp saved in special
fsrp->regs[FP_REGNUM] = fip->frame;
}
+#endif
int
saved_pc_after_call ()
projects / external / binutils.git / commitdiff