+2003-03-23 Andrew Cagney <cagney@redhat.com>
+
+ * gdbarch.sh (DEPRECATED_FRAME_CHAIN): Replace FRAME_CHAIN.
+ (DEPRECATED_FRAME_CHAIN_VALID): Replace FRAME_CHAIN_VALID.
+ * gdbarch.h, gdbarch.c: Regenerate.
+ * valops.c (hand_function_call): Update.
+ * objfiles.h (DEPRECATED_FRAME_CHAIN_VALID): Update.
+ * frame.c (legacy_saved_regs_this_id): Update.
+ (legacy_get_prev_frame, get_prev_frame, legacy_frame_p): Update.
+ * dummy-frame.h: Update.
+ * config/sparc/tm-sparc.h (DEPRECATED_FRAME_CHAIN): Update.
+ * config/pa/tm-hppa.h (DEPRECATED_FRAME_CHAIN_VALID): Update.
+ * config/m68k/tm-vx68.h (DEPRECATED_FRAME_CHAIN): Update.
+ * config/m68k/tm-os68k.h (DEPRECATED_FRAME_CHAIN): Update.
+ * config/m68k/tm-sun3.h: Update.
+ * blockframe.c (inside_main_func, frame_chain_valid): Update.
+ * xstormy16-tdep.c (xstormy16_gdbarch_init): Update.
+ * x86-64-tdep.c (x86_64_init_abi): Update.
+ * vax-tdep.c (vax_gdbarch_init): Update.
+ * v850-tdep.c (v850_gdbarch_init): Update.
+ * sparc-tdep.c (sparc_frame_chain, sparc_gdbarch_init): Update.
+ * sh-tdep.c (sh_gdbarch_init): Update.
+ * s390-tdep.c (s390_gdbarch_init): Update.
+ * rs6000-tdep.c (rs6000_frame_saved_pc): Update.
+ (rs6000_gdbarch_init, rs6000_frame_saved_pc): Update.
+ (frame_get_saved_regs): Update.
+ * ppc-linux-tdep.c (ppc_linux_init_abi): Update.
+ * ns32k-tdep.c (ns32k_gdbarch_init): Update.
+ * mn10300-tdep.c (mn10300_gdbarch_init): Update.
+ * mips-tdep.c (mips_gdbarch_init): Update.
+ * mcore-tdep.c (mcore_gdbarch_init): Update.
+ * m68k-tdep.c (m68k_gdbarch_init): Update.
+ * m68hc11-tdep.c (m68hc11_gdbarch_init): Update.
+ * ia64-tdep.c (ia64_gdbarch_init): Update.
+ * i386-tdep.c (i386_frame_num_args, i386_gdbarch_init): Update.
+ * i386-interix-tdep.c (i386_interix_init_abi): Update.
+ (i386_interix_back_one_frame): Update.
+ * hppa-tdep.c (hppa_gdbarch_init): Update.
+ (hppa_init_extra_frame_info): Update.
+ * h8300-tdep.c (h8300_gdbarch_init): Update.
+ * frv-tdep.c (frv_gdbarch_init): Update.
+ * cris-tdep.c (cris_gdbarch_init): Update.
+ * avr-tdep.c (avr_gdbarch_init): Update.
+ * arm-tdep.c (arm_gdbarch_init): Update.
+ * alpha-tdep.c (alpha_gdbarch_init): Update.
+
2003-03-22 Richard Earnshaw <rearnsha@arm.com>
* arm-tdep.h (arm_float_model): Add AUTO and LAST values.
static gdbarch_skip_prologue_ftype alpha_skip_prologue;
static gdbarch_saved_pc_after_call_ftype alpha_saved_pc_after_call;
-static gdbarch_frame_chain_ftype alpha_frame_chain;
static gdbarch_push_arguments_ftype alpha_push_arguments;
static gdbarch_fix_call_dummy_ftype alpha_fix_call_dummy;
set_gdbarch_saved_pc_after_call (gdbarch, alpha_saved_pc_after_call);
- set_gdbarch_frame_chain (gdbarch, alpha_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, alpha_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, alpha_frame_saved_pc);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, alpha_frame_init_saved_regs);
set_gdbarch_push_arguments (gdbarch, arm_push_arguments);
/* Frame handling. */
- set_gdbarch_frame_chain_valid (gdbarch, arm_frame_chain_valid);
+ set_gdbarch_deprecated_frame_chain_valid (gdbarch, arm_frame_chain_valid);
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, arm_init_extra_frame_info);
set_gdbarch_read_fp (gdbarch, arm_read_fp);
- set_gdbarch_frame_chain (gdbarch, arm_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, arm_frame_chain);
set_gdbarch_frameless_function_invocation
(gdbarch, arm_frameless_function_invocation);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, arm_frame_saved_pc);
avr_remote_translate_xfer_address);
set_gdbarch_frame_args_skip (gdbarch, 0);
set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue); /* ??? */
- set_gdbarch_frame_chain (gdbarch, avr_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, avr_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, avr_frame_saved_pc);
set_gdbarch_frame_args_address (gdbarch, avr_frame_address);
set_gdbarch_frame_locals_address (gdbarch, avr_frame_address);
void _initialize_blockframe (void);
-/* Is ADDR inside the startup file? Note that if your machine
- has a way to detect the bottom of the stack, there is no need
- to call this function from FRAME_CHAIN_VALID; the reason for
- doing so is that some machines have no way of detecting bottom
- of stack.
+/* Is ADDR inside the startup file? Note that if your machine has a
+ way to detect the bottom of the stack, there is no need to call
+ this function from DEPRECATED_FRAME_CHAIN_VALID; the reason for
+ doing so is that some machines have no way of detecting bottom of
+ stack.
A PC of zero is always considered to be the bottom of the stack. */
that correspond to the main() function. See comments above for why
we might want to do this.
- Typically called from FRAME_CHAIN_VALID.
+ Typically called from DEPRECATED_FRAME_CHAIN_VALID.
A PC of zero is always considered to be the bottom of the stack. */
if (symfile_objfile == 0)
return 0;
- /* If the addr range is not set up at symbol reading time, set it up now.
- This is for FRAME_CHAIN_VALID_ALTERNATE. I do this for coff, because
- it is unable to set it up and symbol reading time. */
+ /* If the addr range is not set up at symbol reading time, set it up
+ now. This is for DEPRECATED_FRAME_CHAIN_VALID_ALTERNATE. I do
+ this for coff, because it is unable to set it up and symbol
+ reading time. */
if (symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC &&
symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
that correspond to the process entry point function. See comments
in objfiles.h for why we might want to do this.
- Typically called from FRAME_CHAIN_VALID.
+ Typically called from DEPRECATED_FRAME_CHAIN_VALID.
A PC of zero is always considered to be the bottom of the stack. */
if (inside_entry_file (frame_pc_unwind (fi)))
return 0;
- /* If the architecture has a custom FRAME_CHAIN_VALID, call it now. */
- if (FRAME_CHAIN_VALID_P ())
- return FRAME_CHAIN_VALID (fp, fi);
+ /* If the architecture has a custom DEPRECATED_FRAME_CHAIN_VALID,
+ call it now. */
+ if (DEPRECATED_FRAME_CHAIN_VALID_P ())
+ return DEPRECATED_FRAME_CHAIN_VALID (fp, fi);
return 1;
}
If our current frame pointer is zero, we're at the top; else read out
the saved FP from memory pointed to by the current FP. */
-#undef FRAME_CHAIN
-#define FRAME_CHAIN(thisframe) ((thisframe)->frame? read_memory_integer ((thisframe)->frame, 4): 0)
+#undef DEPRECATED_FRAME_CHAIN
+#define DEPRECATED_FRAME_CHAIN(thisframe) ((thisframe)->frame? read_memory_integer ((thisframe)->frame, 4): 0)
/* The code which tries to deal with this bug is never harmful on a sun3. */
#define SUN_FIXED_LBRAC_BUG (0)
-/* On the sun3 the kernel pushes a sigcontext on the user stack and then
- `calls' _sigtramp in user code. _sigtramp saves the floating point status
- on the stack and calls the signal handler function. The stack does not
- contain enough information to allow a normal backtrace, but sigcontext
- contains the saved user pc/sp. FRAME_CHAIN and friends in tm-m68k.h and
- m68k_find_saved_regs deal with this situation by manufacturing a fake frame
- for _sigtramp.
- SIG_PC_FP_OFFSET is the offset from the signal handler frame to the
- saved pc in sigcontext.
- SIG_SP_FP_OFFSET is the offset from the signal handler frame to the end
- of sigcontext which is identical to the saved sp at SIG_PC_FP_OFFSET - 4.
+/* On the sun3 the kernel pushes a sigcontext on the user stack and
+ then `calls' _sigtramp in user code. _sigtramp saves the floating
+ point status on the stack and calls the signal handler
+ function. The stack does not contain enough information to allow a
+ normal backtrace, but sigcontext contains the saved user
+ pc/sp. DEPRECATED_FRAME_CHAIN and friends in tm-m68k.h and
+ m68k_find_saved_regs deal with this situation by manufacturing a
+ fake frame for _sigtramp. SIG_PC_FP_OFFSET is the offset from the
+ signal handler frame to the saved pc in sigcontext.
+ SIG_SP_FP_OFFSET is the offset from the signal handler frame to the
+ end of sigcontext which is identical to the saved sp at
+ SIG_PC_FP_OFFSET - 4.
Please note that it is impossible to correctly backtrace from a breakpoint
in _sigtramp as _sigtramp modifies the stack pointer a few times. */
If our current frame pointer is zero, we're at the top; else read out
the saved FP from memory pointed to by the current FP. */
-#undef FRAME_CHAIN
-#define FRAME_CHAIN(thisframe) ((thisframe)->frame? read_memory_integer ((thisframe)->frame, 4): 0)
+#undef DEPRECATED_FRAME_CHAIN
+#define DEPRECATED_FRAME_CHAIN(thisframe) ((thisframe)->frame? read_memory_integer ((thisframe)->frame, 4): 0)
/* FIXME, Longjmp information stolen from Sun-3 config. Dunno if right. */
/* Offsets (in target ints) into jmp_buf. Not defined by Sun, but at least
/* Describe the pointer in each stack frame to the previous stack frame
(its caller). */
-/* FRAME_CHAIN takes a frame's nominal address and produces the
- frame's chain-pointer. */
+/* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and produces
+ the frame's chain-pointer. */
/* In the case of the PA-RISC, the frame's nominal address
is the address of a 4-byte word containing the calling frame's
address (previous FP). */
#if !GDB_MULTI_ARCH
-#define FRAME_CHAIN(thisframe) hppa_frame_chain (thisframe)
+#define DEPRECATED_FRAME_CHAIN(thisframe) hppa_frame_chain (thisframe)
extern CORE_ADDR hppa_frame_chain (struct frame_info *);
#endif
#if !GDB_MULTI_ARCH
extern int hppa_frame_chain_valid (CORE_ADDR, struct frame_info *);
-#define FRAME_CHAIN_VALID(chain, thisframe) hppa_frame_chain_valid (chain, thisframe)
+#define DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe) hppa_frame_chain_valid (chain, thisframe)
#endif
/* Define other aspects of the stack frame. */
#define CANNOT_STORE_REGISTER(regno) ((regno) == G0_REGNUM)
/*
- * FRAME_CHAIN and FRAME_INFO definitions, collected here for convenience.
- */
+ * DEPRECATED_FRAME_CHAIN and FRAME_INFO definitions, collected here
+ * for convenience. */
#if !defined (GDB_MULTI_ARCH) || (GDB_MULTI_ARCH == 0)
/*
/* Describe the pointer in each stack frame to the previous stack frame
(its caller). */
-/* FRAME_CHAIN takes a frame's nominal address
- and produces the frame's chain-pointer. */
+/* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and produces
+ the frame's chain-pointer. */
/* In the case of the Sun 4, the frame-chain's nominal address
is held in the frame pointer register.
sparc_init_extra_frame_info (FROMLEAF, FCI)
extern void sparc_init_extra_frame_info (int, struct frame_info *);
-#define FRAME_CHAIN(THISFRAME) (sparc_frame_chain (THISFRAME))
+#define DEPRECATED_FRAME_CHAIN(THISFRAME) (sparc_frame_chain (THISFRAME))
extern CORE_ADDR sparc_frame_chain (struct frame_info *);
/* A macro that tells us whether the function invocation represented
set_gdbarch_frame_args_skip (gdbarch, 0);
set_gdbarch_frameless_function_invocation
(gdbarch, cris_frameless_function_invocation);
- set_gdbarch_frame_chain (gdbarch, cris_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, cris_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, cris_frame_saved_pc);
set_gdbarch_saved_pc_after_call (gdbarch, cris_saved_pc_after_call);
+2003-03-23 Andrew Cagney <cagney@redhat.com>
+
+ * gdbint.texinfo (Algorithms, Target Architecture Definition):
+ Deprecate FRAME_CHAIN and FRAME_CHAIN_VALID.
+
2003-03-18 J. Brobecker <brobecker@gnat.com>
* gdbint.texinfo (Algorithms): Add new section describing the
value, if your frames are nonstandard.)
@cindex frame chain
-Given a @value{GDBN} frame, define @code{FRAME_CHAIN} to determine the
-address of the calling function's frame. This will be used to create a
-new @value{GDBN} frame struct, and then
+Given a @value{GDBN} frame, define @code{DEPRECATED_FRAME_CHAIN} to
+determine the address of the calling function's frame. This will be
+used to create a new @value{GDBN} frame struct, and then
@code{DEPRECATED_INIT_EXTRA_FRAME_INFO} and
@code{DEPRECATED_INIT_FRAME_PC} will be called for the new frame.
@findex FRAME_ARGS_ADDRESS_CORRECT
See @file{stack.c}.
-@item FRAME_CHAIN(@var{frame})
-@findex FRAME_CHAIN
+@item DEPRECATED_FRAME_CHAIN(@var{frame})
+@findex DEPRECATED_FRAME_CHAIN
Given @var{frame}, return a pointer to the calling frame.
-@item FRAME_CHAIN_VALID(@var{chain}, @var{thisframe})
-@findex FRAME_CHAIN_VALID
+@item DEPRECATED_FRAME_CHAIN_VALID(@var{chain}, @var{thisframe})
+@findex DEPRECATED_FRAME_CHAIN_VALID
Define this to be an expression that returns zero if the given frame is an
outermost frame, with no caller, and nonzero otherwise. Most normal
situations can be handled without defining this macro, including @code{NULL}
is probably to define CALL_DUMMY to be empty, CALL_DUMMY_LENGTH to
zero, and CALL_DUMMY_LOCATION to AT_ENTRY. Then you must remember
to define PUSH_RETURN_ADDRESS, because no call instruction will be
- being executed by the target. Also FRAME_CHAIN_VALID as
+ being executed by the target. Also DEPRECATED_FRAME_CHAIN_VALID as
generic_{file,func}_frame_chain_valid and FIX_CALL_DUMMY as
generic_fix_call_dummy. */
this to after the ffi test; I'd rather have backtraces from
start go curfluy than have an abort called from main not show
main. */
- gdb_assert (FRAME_CHAIN_P ());
- base = FRAME_CHAIN (next_frame);
+ gdb_assert (DEPRECATED_FRAME_CHAIN_P ());
+ base = DEPRECATED_FRAME_CHAIN (next_frame);
if (!frame_chain_valid (base, next_frame))
return;
Note that the pc-unwind is intentionally performed before the
frame chain. This is ok since, for old targets, both
- frame_pc_unwind (nee, FRAME_SAVED_PC) and FRAME_CHAIN()) assume
- THIS_FRAME's data structures have already been initialized (using
+ frame_pc_unwind (nee, DEPRECATED_FRAME_SAVED_PC) and
+ DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures
+ have already been initialized (using
DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
doesn't matter.
this to after the ffi test; I'd rather have backtraces from
start go curfluy than have an abort called from main not show
main. */
- gdb_assert (FRAME_CHAIN_P ());
- address = FRAME_CHAIN (this_frame);
+ gdb_assert (DEPRECATED_FRAME_CHAIN_P ());
+ address = DEPRECATED_FRAME_CHAIN (this_frame);
if (!frame_chain_valid (address, this_frame))
return 0;
DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC.
This should also return a flag saying whether to keep the new
frame, or whether to discard it, because on some machines (e.g.
- mips) it is really awkward to have FRAME_CHAIN_VALID called
- BEFORE DEPRECATED_INIT_EXTRA_FRAME_INFO (there is no good way to
- get information deduced in FRAME_CHAIN_VALID into the extra
- fields of the new frame). std_frame_pc(fromleaf, prev)
+ mips) it is really awkward to have DEPRECATED_FRAME_CHAIN_VALID
+ called BEFORE DEPRECATED_INIT_EXTRA_FRAME_INFO (there is no good
+ way to get information deduced in DEPRECATED_FRAME_CHAIN_VALID
+ into the extra fields of the new frame). std_frame_pc(fromleaf,
+ prev)
This is the default setting for INIT_PREV_FRAME. It just does
what the default DEPRECATED_INIT_FRAME_PC does. Some machines
means that the convolution below - needing to carefully order a
frame's initialization - isn't needed.
- The irony here though, is that FRAME_CHAIN(), at least for a more
- up-to-date architecture, always calls FRAME_SAVED_PC(), and
- FRAME_SAVED_PC() computes the PC but without first needing the
- frame! Instead of the convolution below, we could have simply
- called FRAME_SAVED_PC() and been done with it! Note that
- FRAME_SAVED_PC() is being superseed by frame_pc_unwind() and that
- function does have somewhere to cache that PC value. */
+ The irony here though, is that DEPRECATED_FRAME_CHAIN(), at least
+ for a more up-to-date architecture, always calls
+ FRAME_SAVED_PC(), and FRAME_SAVED_PC() computes the PC but
+ without first needing the frame! Instead of the convolution
+ below, we could have simply called FRAME_SAVED_PC() and been done
+ with it! Note that FRAME_SAVED_PC() is being superseed by
+ frame_pc_unwind() and that function does have somewhere to cache
+ that PC value. */
if (DEPRECATED_INIT_FRAME_PC_FIRST_P ())
prev->pc = (DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf, prev));
/* If ->frame and ->pc are unchanged, we are in the process of
getting ourselves into an infinite backtrace. Some architectures
- check this in FRAME_CHAIN or thereabouts, but it seems like there
- is no reason this can't be an architecture-independent check. */
+ check this in DEPRECATED_FRAME_CHAIN or thereabouts, but it seems
+ like there is no reason this can't be an architecture-independent
+ check. */
if (prev->frame == this_frame->frame
&& prev->pc == this_frame->pc)
{
Note that the pc-unwind is intentionally performed before the
frame chain. This is ok since, for old targets, both
- frame_pc_unwind (nee, FRAME_SAVED_PC) and FRAME_CHAIN()) assume
- THIS_FRAME's data structures have already been initialized (using
+ frame_pc_unwind (nee, FRAME_SAVED_PC) and
+ DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures
+ have already been initialized (using
DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
doesn't matter.
return (DEPRECATED_INIT_FRAME_PC_P ()
|| DEPRECATED_INIT_FRAME_PC_FIRST_P ()
|| DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()
- || FRAME_CHAIN_P ()
+ || DEPRECATED_FRAME_CHAIN_P ()
|| !gdbarch_unwind_dummy_id_p (current_gdbarch)
|| !SAVE_DUMMY_FRAME_TOS_P ());
}
extern void *frame_obstack_zalloc (unsigned long size);
#define FRAME_OBSTACK_ZALLOC(TYPE) ((TYPE *) frame_obstack_zalloc (sizeof (TYPE)))
-/* If FRAME_CHAIN_VALID returns zero it means that the given frame
- is the outermost one and has no caller. */
+/* If DEPRECATED_FRAME_CHAIN_VALID returns zero it means that the
+ given frame is the outermost one and has no caller. */
extern int frame_chain_valid (CORE_ADDR, struct frame_info *);
static gdbarch_register_virtual_type_ftype frv_register_virtual_type;
static gdbarch_register_byte_ftype frv_register_byte;
static gdbarch_breakpoint_from_pc_ftype frv_breakpoint_from_pc;
-static gdbarch_frame_chain_ftype frv_frame_chain;
static gdbarch_skip_prologue_ftype frv_skip_prologue;
static gdbarch_deprecated_extract_return_value_ftype frv_extract_return_value;
static gdbarch_deprecated_extract_struct_value_address_ftype frv_extract_struct_value_address;
set_gdbarch_saved_pc_after_call (gdbarch, frv_saved_pc_after_call);
- set_gdbarch_frame_chain (gdbarch, frv_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, frv_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, frv_frame_saved_pc);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, frv_frame_init_saved_regs);
gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;
CORE_ADDR frame_args_skip;
gdbarch_frameless_function_invocation_ftype *frameless_function_invocation;
- gdbarch_frame_chain_ftype *frame_chain;
- gdbarch_frame_chain_valid_ftype *frame_chain_valid;
+ gdbarch_deprecated_frame_chain_ftype *deprecated_frame_chain;
+ gdbarch_deprecated_frame_chain_valid_ftype *deprecated_frame_chain_valid;
gdbarch_deprecated_frame_saved_pc_ftype *deprecated_frame_saved_pc;
gdbarch_unwind_pc_ftype *unwind_pc;
gdbarch_frame_args_address_ftype *frame_args_address;
&& (gdbarch->frame_args_skip == -1))
fprintf_unfiltered (log, "\n\tframe_args_skip");
/* Skip verify of frameless_function_invocation, invalid_p == 0 */
- /* Skip verify of frame_chain, has predicate */
- /* Skip verify of frame_chain_valid, has predicate */
+ /* Skip verify of deprecated_frame_chain, has predicate */
+ /* Skip verify of deprecated_frame_chain_valid, has predicate */
/* Skip verify of deprecated_frame_saved_pc, has predicate */
/* Skip verify of unwind_pc, has predicate */
/* Skip verify of frame_args_address, invalid_p == 0 */
(long) current_gdbarch->deprecated_extract_struct_value_address
/*DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
#endif
+#ifdef DEPRECATED_FRAME_CHAIN_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_FRAME_CHAIN_P()",
+ XSTRING (DEPRECATED_FRAME_CHAIN_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_FRAME_CHAIN_P() = %d\n",
+ DEPRECATED_FRAME_CHAIN_P ());
+#endif
+#ifdef DEPRECATED_FRAME_CHAIN
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_FRAME_CHAIN(frame)",
+ XSTRING (DEPRECATED_FRAME_CHAIN (frame)));
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_FRAME_CHAIN = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_frame_chain
+ /*DEPRECATED_FRAME_CHAIN ()*/);
+#endif
+#ifdef DEPRECATED_FRAME_CHAIN_VALID_P
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_FRAME_CHAIN_VALID_P()",
+ XSTRING (DEPRECATED_FRAME_CHAIN_VALID_P ()));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID_P() = %d\n",
+ DEPRECATED_FRAME_CHAIN_VALID_P ());
+#endif
+#ifdef DEPRECATED_FRAME_CHAIN_VALID
+ fprintf_unfiltered (file,
+ "gdbarch_dump: %s # %s\n",
+ "DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe)",
+ XSTRING (DEPRECATED_FRAME_CHAIN_VALID (chain, thisframe)));
+ if (GDB_MULTI_ARCH)
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_FRAME_CHAIN_VALID = <0x%08lx>\n",
+ (long) current_gdbarch->deprecated_frame_chain_valid
+ /*DEPRECATED_FRAME_CHAIN_VALID ()*/);
+#endif
#ifdef DEPRECATED_FRAME_INIT_SAVED_REGS_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
"gdbarch_dump: FRAME_ARGS_SKIP = %ld\n",
(long) FRAME_ARGS_SKIP);
#endif
-#ifdef FRAME_CHAIN_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "FRAME_CHAIN_P()",
- XSTRING (FRAME_CHAIN_P ()));
- fprintf_unfiltered (file,
- "gdbarch_dump: FRAME_CHAIN_P() = %d\n",
- FRAME_CHAIN_P ());
-#endif
-#ifdef FRAME_CHAIN
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "FRAME_CHAIN(frame)",
- XSTRING (FRAME_CHAIN (frame)));
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: FRAME_CHAIN = <0x%08lx>\n",
- (long) current_gdbarch->frame_chain
- /*FRAME_CHAIN ()*/);
-#endif
-#ifdef FRAME_CHAIN_VALID_P
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "FRAME_CHAIN_VALID_P()",
- XSTRING (FRAME_CHAIN_VALID_P ()));
- fprintf_unfiltered (file,
- "gdbarch_dump: FRAME_CHAIN_VALID_P() = %d\n",
- FRAME_CHAIN_VALID_P ());
-#endif
-#ifdef FRAME_CHAIN_VALID
- fprintf_unfiltered (file,
- "gdbarch_dump: %s # %s\n",
- "FRAME_CHAIN_VALID(chain, thisframe)",
- XSTRING (FRAME_CHAIN_VALID (chain, thisframe)));
- if (GDB_MULTI_ARCH)
- fprintf_unfiltered (file,
- "gdbarch_dump: FRAME_CHAIN_VALID = <0x%08lx>\n",
- (long) current_gdbarch->frame_chain_valid
- /*FRAME_CHAIN_VALID ()*/);
-#endif
#ifdef FRAME_LOCALS_ADDRESS
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
}
int
-gdbarch_frame_chain_p (struct gdbarch *gdbarch)
+gdbarch_deprecated_frame_chain_p (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- return gdbarch->frame_chain != 0;
+ return gdbarch->deprecated_frame_chain != 0;
}
CORE_ADDR
-gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame)
+gdbarch_deprecated_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->frame_chain == 0)
+ if (gdbarch->deprecated_frame_chain == 0)
internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_frame_chain invalid");
+ "gdbarch: gdbarch_deprecated_frame_chain invalid");
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain called\n");
- return gdbarch->frame_chain (frame);
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_chain called\n");
+ return gdbarch->deprecated_frame_chain (frame);
}
void
-set_gdbarch_frame_chain (struct gdbarch *gdbarch,
- gdbarch_frame_chain_ftype frame_chain)
+set_gdbarch_deprecated_frame_chain (struct gdbarch *gdbarch,
+ gdbarch_deprecated_frame_chain_ftype deprecated_frame_chain)
{
- gdbarch->frame_chain = frame_chain;
+ gdbarch->deprecated_frame_chain = deprecated_frame_chain;
}
int
-gdbarch_frame_chain_valid_p (struct gdbarch *gdbarch)
+gdbarch_deprecated_frame_chain_valid_p (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- return gdbarch->frame_chain_valid != 0;
+ return gdbarch->deprecated_frame_chain_valid != 0;
}
int
-gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe)
+gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe)
{
gdb_assert (gdbarch != NULL);
- if (gdbarch->frame_chain_valid == 0)
+ if (gdbarch->deprecated_frame_chain_valid == 0)
internal_error (__FILE__, __LINE__,
- "gdbarch: gdbarch_frame_chain_valid invalid");
+ "gdbarch: gdbarch_deprecated_frame_chain_valid invalid");
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_frame_chain_valid called\n");
- return gdbarch->frame_chain_valid (chain, thisframe);
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_frame_chain_valid called\n");
+ return gdbarch->deprecated_frame_chain_valid (chain, thisframe);
}
void
-set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch,
- gdbarch_frame_chain_valid_ftype frame_chain_valid)
+set_gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch,
+ gdbarch_deprecated_frame_chain_valid_ftype deprecated_frame_chain_valid)
{
- gdbarch->frame_chain_valid = frame_chain_valid;
+ gdbarch->deprecated_frame_chain_valid = deprecated_frame_chain_valid;
}
int
#endif
#endif
-#if defined (FRAME_CHAIN)
-/* Legacy for systems yet to multi-arch FRAME_CHAIN */
-#if !defined (FRAME_CHAIN_P)
-#define FRAME_CHAIN_P() (1)
+#if defined (DEPRECATED_FRAME_CHAIN)
+/* Legacy for systems yet to multi-arch DEPRECATED_FRAME_CHAIN */
+#if !defined (DEPRECATED_FRAME_CHAIN_P)
+#define DEPRECATED_FRAME_CHAIN_P() (1)
#endif
#endif
/* Default predicate for non- multi-arch targets. */
-#if (!GDB_MULTI_ARCH) && !defined (FRAME_CHAIN_P)
-#define FRAME_CHAIN_P() (0)
+#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_FRAME_CHAIN_P)
+#define DEPRECATED_FRAME_CHAIN_P() (0)
#endif
-extern int gdbarch_frame_chain_p (struct gdbarch *gdbarch);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_CHAIN_P)
-#error "Non multi-arch definition of FRAME_CHAIN"
+extern int gdbarch_deprecated_frame_chain_p (struct gdbarch *gdbarch);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_FRAME_CHAIN_P)
+#error "Non multi-arch definition of DEPRECATED_FRAME_CHAIN"
#endif
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_CHAIN_P)
-#define FRAME_CHAIN_P() (gdbarch_frame_chain_p (current_gdbarch))
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_FRAME_CHAIN_P)
+#define DEPRECATED_FRAME_CHAIN_P() (gdbarch_deprecated_frame_chain_p (current_gdbarch))
#endif
/* Default (function) for non- multi-arch platforms. */
-#if (!GDB_MULTI_ARCH) && !defined (FRAME_CHAIN)
-#define FRAME_CHAIN(frame) (internal_error (__FILE__, __LINE__, "FRAME_CHAIN"), 0)
+#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_FRAME_CHAIN)
+#define DEPRECATED_FRAME_CHAIN(frame) (internal_error (__FILE__, __LINE__, "DEPRECATED_FRAME_CHAIN"), 0)
#endif
-typedef CORE_ADDR (gdbarch_frame_chain_ftype) (struct frame_info *frame);
-extern CORE_ADDR gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame);
-extern void set_gdbarch_frame_chain (struct gdbarch *gdbarch, gdbarch_frame_chain_ftype *frame_chain);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_CHAIN)
-#error "Non multi-arch definition of FRAME_CHAIN"
+typedef CORE_ADDR (gdbarch_deprecated_frame_chain_ftype) (struct frame_info *frame);
+extern CORE_ADDR gdbarch_deprecated_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame);
+extern void set_gdbarch_deprecated_frame_chain (struct gdbarch *gdbarch, gdbarch_deprecated_frame_chain_ftype *deprecated_frame_chain);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_FRAME_CHAIN)
+#error "Non multi-arch definition of DEPRECATED_FRAME_CHAIN"
#endif
#if GDB_MULTI_ARCH
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_CHAIN)
-#define FRAME_CHAIN(frame) (gdbarch_frame_chain (current_gdbarch, frame))
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_FRAME_CHAIN)
+#define DEPRECATED_FRAME_CHAIN(frame) (gdbarch_deprecated_frame_chain (current_gdbarch, frame))
#endif
#endif
-#if defined (FRAME_CHAIN_VALID)
-/* Legacy for systems yet to multi-arch FRAME_CHAIN_VALID */
-#if !defined (FRAME_CHAIN_VALID_P)
-#define FRAME_CHAIN_VALID_P() (1)
+#if defined (DEPRECATED_FRAME_CHAIN_VALID)
+/* Legacy for systems yet to multi-arch DEPRECATED_FRAME_CHAIN_VALID */
+#if !defined (DEPRECATED_FRAME_CHAIN_VALID_P)
+#define DEPRECATED_FRAME_CHAIN_VALID_P() (1)
#endif
#endif
/* Default predicate for non- multi-arch targets. */
-#if (!GDB_MULTI_ARCH) && !defined (FRAME_CHAIN_VALID_P)
-#define FRAME_CHAIN_VALID_P() (0)
+#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_FRAME_CHAIN_VALID_P)
+#define DEPRECATED_FRAME_CHAIN_VALID_P() (0)
#endif
-extern int gdbarch_frame_chain_valid_p (struct gdbarch *gdbarch);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_CHAIN_VALID_P)
-#error "Non multi-arch definition of FRAME_CHAIN_VALID"
+extern int gdbarch_deprecated_frame_chain_valid_p (struct gdbarch *gdbarch);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_FRAME_CHAIN_VALID_P)
+#error "Non multi-arch definition of DEPRECATED_FRAME_CHAIN_VALID"
#endif
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_CHAIN_VALID_P)
-#define FRAME_CHAIN_VALID_P() (gdbarch_frame_chain_valid_p (current_gdbarch))
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_FRAME_CHAIN_VALID_P)
+#define DEPRECATED_FRAME_CHAIN_VALID_P() (gdbarch_deprecated_frame_chain_valid_p (current_gdbarch))
#endif
/* Default (function) for non- multi-arch platforms. */
-#if (!GDB_MULTI_ARCH) && !defined (FRAME_CHAIN_VALID)
-#define FRAME_CHAIN_VALID(chain, thisframe) (internal_error (__FILE__, __LINE__, "FRAME_CHAIN_VALID"), 0)
+#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_FRAME_CHAIN_VALID)
+#define DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe) (internal_error (__FILE__, __LINE__, "DEPRECATED_FRAME_CHAIN_VALID"), 0)
#endif
-typedef int (gdbarch_frame_chain_valid_ftype) (CORE_ADDR chain, struct frame_info *thisframe);
-extern int gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe);
-extern void set_gdbarch_frame_chain_valid (struct gdbarch *gdbarch, gdbarch_frame_chain_valid_ftype *frame_chain_valid);
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FRAME_CHAIN_VALID)
-#error "Non multi-arch definition of FRAME_CHAIN_VALID"
+typedef int (gdbarch_deprecated_frame_chain_valid_ftype) (CORE_ADDR chain, struct frame_info *thisframe);
+extern int gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe);
+extern void set_gdbarch_deprecated_frame_chain_valid (struct gdbarch *gdbarch, gdbarch_deprecated_frame_chain_valid_ftype *deprecated_frame_chain_valid);
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_FRAME_CHAIN_VALID)
+#error "Non multi-arch definition of DEPRECATED_FRAME_CHAIN_VALID"
#endif
#if GDB_MULTI_ARCH
-#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FRAME_CHAIN_VALID)
-#define FRAME_CHAIN_VALID(chain, thisframe) (gdbarch_frame_chain_valid (current_gdbarch, chain, thisframe))
+#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_FRAME_CHAIN_VALID)
+#define DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe) (gdbarch_deprecated_frame_chain_valid (current_gdbarch, chain, thisframe))
#endif
#endif
#
v:2:FRAME_ARGS_SKIP:CORE_ADDR:frame_args_skip::::0:-1
f:2:FRAMELESS_FUNCTION_INVOCATION:int:frameless_function_invocation:struct frame_info *fi:fi:::generic_frameless_function_invocation_not::0
-F:2:FRAME_CHAIN:CORE_ADDR:frame_chain:struct frame_info *frame:frame::0:0
-F:2:FRAME_CHAIN_VALID:int:frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
+F:2:DEPRECATED_FRAME_CHAIN:CORE_ADDR:deprecated_frame_chain:struct frame_info *frame:frame::0:0
+F:2:DEPRECATED_FRAME_CHAIN_VALID:int:deprecated_frame_chain_valid:CORE_ADDR chain, struct frame_info *thisframe:chain, thisframe::0:0
# DEPRECATED_FRAME_SAVED_PC has been replaced by UNWIND_PC. Please
# note, per UNWIND_PC's doco, that while the two have similar
# interfaces they have very different underlying implementations.
*/
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, h8300_frame_init_saved_regs);
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, h8300_init_extra_frame_info);
- set_gdbarch_frame_chain (gdbarch, h8300_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, h8300_frame_chain);
set_gdbarch_saved_pc_after_call (gdbarch, h8300_saved_pc_after_call);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, h8300_frame_saved_pc);
set_gdbarch_skip_prologue (gdbarch, h8300_skip_prologue);
if (frame->next && !fromleaf)
return;
- /* If the next frame represents a frameless function invocation
- then we have to do some adjustments that are normally done by
- FRAME_CHAIN. (FRAME_CHAIN is not called in this case.) */
+ /* If the next frame represents a frameless function invocation then
+ we have to do some adjustments that are normally done by
+ DEPRECATED_FRAME_CHAIN. (DEPRECATED_FRAME_CHAIN is not called in
+ this case.) */
if (fromleaf)
{
/* Find the framesize of *this* frame without peeking at the PC
(gdbarch, hppa_extract_struct_value_address);
set_gdbarch_cannot_store_register (gdbarch, hppa_cannot_store_register);
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, hppa_init_extra_frame_info);
- set_gdbarch_frame_chain (gdbarch, hppa_frame_chain);
- set_gdbarch_frame_chain_valid (gdbarch, hppa_frame_chain_valid);
+ set_gdbarch_deprecated_frame_chain (gdbarch, hppa_frame_chain);
+ set_gdbarch_deprecated_frame_chain_valid (gdbarch, hppa_frame_chain_valid);
set_gdbarch_frameless_function_invocation
(gdbarch, hppa_frameless_function_invocation);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, hppa_frame_saved_pc);
/* No... We must be pointing at the frame that was called
by PdxSignalDeliverer; back up across the whole mess. */
- /* Extract the frame for PdxSignalDeliverer.
- Note: FRAME_CHAIN used the "old" frame pointer because we were
- a deliverer. Get the address of the context record that's on
- here frameless. */
+ /* Extract the frame for PdxSignalDeliverer. Note:
+ DEPRECATED_FRAME_CHAIN used the "old" frame pointer because
+ we were a deliverer. Get the address of the context record
+ that's on here frameless. */
context = read_memory_integer (frame->frame, 4); /* an Arg */
/* Now extract the frame pointer contained in the context. */
i386_interix_skip_trampoline_code);
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, i386_interix_back_one_frame);
set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_noop);
- set_gdbarch_frame_chain_valid (gdbarch, i386_interix_frame_chain_valid);
+ set_gdbarch_deprecated_frame_chain_valid (gdbarch, i386_interix_frame_chain_valid);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, i386_interix_frame_saved_pc);
set_gdbarch_name_of_malloc (gdbarch, "_malloc");
}
if (pfi == 0)
{
/* NOTE: This can happen if we are looking at the frame for
- main, because FRAME_CHAIN_VALID won't let us go into start.
- If we have debugging symbols, that's not really a big deal;
- it just means it will only show as many arguments to main as
- are declared. */
+ main, because DEPRECATED_FRAME_CHAIN_VALID won't let us go
+ into start. If we have debugging symbols, that's not really
+ a big deal; it just means it will only show as many arguments
+ to main as are declared. */
return -1;
}
else
set_gdbarch_frame_args_skip (gdbarch, 8);
set_gdbarch_frameless_function_invocation (gdbarch,
i386_frameless_function_invocation);
- set_gdbarch_frame_chain (gdbarch, i386_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, i386_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, i386_frame_saved_pc);
set_gdbarch_saved_pc_after_call (gdbarch, i386_saved_pc_after_call);
set_gdbarch_frame_num_args (gdbarch, i386_frame_num_args);
static gdbarch_register_virtual_type_ftype ia64_register_virtual_type;
static gdbarch_register_byte_ftype ia64_register_byte;
static gdbarch_breakpoint_from_pc_ftype ia64_breakpoint_from_pc;
-static gdbarch_frame_chain_ftype ia64_frame_chain;
static gdbarch_skip_prologue_ftype ia64_skip_prologue;
static gdbarch_deprecated_extract_return_value_ftype ia64_extract_return_value;
static gdbarch_deprecated_extract_struct_value_address_ftype ia64_extract_struct_value_address;
}
}
- write_register (sp_regnum, FRAME_CHAIN (frame));
+ write_register (sp_regnum, DEPRECATED_FRAME_CHAIN (frame));
write_pc (DEPRECATED_FRAME_SAVED_PC (frame));
cfm = read_register (IA64_CFM_REGNUM);
set_gdbarch_saved_pc_after_call (gdbarch, ia64_saved_pc_after_call);
- set_gdbarch_frame_chain (gdbarch, ia64_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, ia64_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, ia64_frame_saved_pc);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, ia64_frame_init_saved_regs);
set_gdbarch_register_convertible (gdbarch, generic_register_convertible_not);
- set_gdbarch_frame_chain (gdbarch, m68hc11_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, m68hc11_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, m68hc11_frame_saved_pc);
set_gdbarch_frame_args_address (gdbarch, m68hc11_frame_args_address);
set_gdbarch_frame_locals_address (gdbarch, m68hc11_frame_locals_address);
/* Describe the pointer in each stack frame to the previous stack frame
(its caller). */
-/* FRAME_CHAIN takes a frame's nominal address and produces the frame's
- chain-pointer.
- In the case of the 68000, the frame's nominal address
- is the address of a 4-byte word containing the calling frame's address. */
+/* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and produces
+ the frame's chain-pointer. In the case of the 68000, the frame's
+ nominal address is the address of a 4-byte word containing the
+ calling frame's address. */
/* If we are chaining from sigtramp, then manufacture a sigtramp frame
(which isn't really on the stack. I'm not sure this is right for anything
m68k_deprecated_extract_return_value);
set_gdbarch_deprecated_store_return_value (gdbarch, m68k_store_return_value);
- set_gdbarch_frame_chain (gdbarch, m68k_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, m68k_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, m68k_frame_saved_pc);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, m68k_frame_init_saved_regs);
set_gdbarch_frameless_function_invocation (gdbarch,
/* Frames: */
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, mcore_init_extra_frame_info);
- set_gdbarch_frame_chain (gdbarch, mcore_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, mcore_frame_chain);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, mcore_frame_init_saved_regs);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, mcore_frame_saved_pc);
set_gdbarch_deprecated_store_return_value (gdbarch, mcore_store_return_value);
set_gdbarch_register_convert_to_raw (gdbarch,
mips_register_convert_to_raw);
- set_gdbarch_frame_chain (gdbarch, mips_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, mips_frame_chain);
set_gdbarch_frameless_function_invocation (gdbarch,
generic_frameless_function_invocation_not);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, mips_frame_saved_pc);
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, mn10300_init_extra_frame_info);
set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_noop);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, mn10300_frame_init_saved_regs);
- set_gdbarch_frame_chain (gdbarch, mn10300_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, mn10300_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, mn10300_frame_saved_pc);
set_gdbarch_deprecated_extract_return_value (gdbarch, mn10300_extract_return_value);
set_gdbarch_deprecated_extract_struct_value_address
set_gdbarch_frameless_function_invocation (gdbarch,
generic_frameless_function_invocation_not);
- set_gdbarch_frame_chain (gdbarch, ns32k_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, ns32k_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, ns32k_frame_saved_pc);
set_gdbarch_frame_args_address (gdbarch, ns32k_frame_args_address);
confused. However, we almost always have debugging information
available for main().
- These variables are used to save the range of PC values which are valid
- within the main() function and within the function containing the process
- entry point. If we always consider the frame for main() as the outermost
- frame when debugging user code, and the frame for the process entry
- point function as the outermost frame when debugging startup code, then
- all we have to do is have FRAME_CHAIN_VALID return false whenever a
- frame's current PC is within the range specified by these variables.
- In essence, we set "ceilings" in the frame chain beyond which we will
+ These variables are used to save the range of PC values which are
+ valid within the main() function and within the function containing
+ the process entry point. If we always consider the frame for
+ main() as the outermost frame when debugging user code, and the
+ frame for the process entry point function as the outermost frame
+ when debugging startup code, then all we have to do is have
+ DEPRECATED_FRAME_CHAIN_VALID return false whenever a frame's
+ current PC is within the range specified by these variables. In
+ essence, we set "ceilings" in the frame chain beyond which we will
not proceed when following the frame chain back up the stack.
A nice side effect is that we can still debug startup code without
information but we do have usable information for main(), backtraces
from user code don't go wandering off into the startup code.
- To use this method, define your FRAME_CHAIN_VALID macro like:
+ To use this method, define your DEPRECATED_FRAME_CHAIN_VALID macro
+ like:
- #define FRAME_CHAIN_VALID(chain, thisframe) \
+ #define DEPRECATED_FRAME_CHAIN_VALID(chain, thisframe) \
(chain != 0 \
&& !(inside_main_func ((thisframe)->pc)) \
&& !(inside_entry_func ((thisframe)->pc)))
*_push_arguments(). The same remarks hold for the methods below. */
set_gdbarch_frameless_function_invocation (gdbarch,
ppc_linux_frameless_function_invocation);
- set_gdbarch_frame_chain (gdbarch, ppc_linux_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, ppc_linux_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, ppc_linux_frame_saved_pc);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch,
return lr;
}
else
- return read_memory_addr (FRAME_CHAIN (fi) + tdep->lr_frame_offset,
+ return read_memory_addr (DEPRECATED_FRAME_CHAIN (fi)
+ + tdep->lr_frame_offset,
wordsize);
}
if (fdata.lr_offset == 0)
return read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
- return read_memory_addr (FRAME_CHAIN (fi) + fdata.lr_offset, wordsize);
+ return read_memory_addr (DEPRECATED_FRAME_CHAIN (fi) + fdata.lr_offset,
+ wordsize);
}
/* If saved registers of frame FI are not known yet, read and cache them.
->frame pointed to the outer-most address of the frame. In the
mean time, the address of the prev frame is used as the base
address of this frame. */
- frame_addr = FRAME_CHAIN (fi);
+ frame_addr = DEPRECATED_FRAME_CHAIN (fi);
/* if != -1, fdatap->saved_fpr is the smallest number of saved_fpr.
All fpr's from saved_fpr to fp31 are saved. */
/* Describe the pointer in each stack frame to the previous stack frame
(its caller). */
-/* FRAME_CHAIN takes a frame's nominal address
- and produces the frame's chain-pointer. */
+/* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and produces
+ the frame's chain-pointer. */
/* In the case of the RS/6000, the frame's nominal address
is the address of a 4-byte word containing the calling frame's address. */
set_gdbarch_frameless_function_invocation (gdbarch,
rs6000_frameless_function_invocation);
- set_gdbarch_frame_chain (gdbarch, rs6000_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, rs6000_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, rs6000_frame_saved_pc);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, rs6000_frame_init_saved_regs);
set_gdbarch_frame_args_skip (gdbarch, 0);
set_gdbarch_frame_args_address (gdbarch, s390_frame_args_address);
- set_gdbarch_frame_chain (gdbarch, s390_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, s390_frame_chain);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, s390_frame_init_saved_regs);
set_gdbarch_frame_locals_address (gdbarch, s390_frame_args_address);
/* We can't do this */
s390_frameless_function_invocation);
/* Return saved PC from a frame */
set_gdbarch_deprecated_frame_saved_pc (gdbarch, s390_frame_saved_pc);
- /* FRAME_CHAIN takes a frame's nominal address
- and produces the frame's chain-pointer. */
- set_gdbarch_frame_chain (gdbarch, s390_frame_chain);
+ /* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and
+ produces the frame's chain-pointer. */
+ set_gdbarch_deprecated_frame_chain (gdbarch, s390_frame_chain);
set_gdbarch_saved_pc_after_call (gdbarch, s390_saved_pc_after_call);
set_gdbarch_register_byte (gdbarch, s390_register_byte);
set_gdbarch_pc_regnum (gdbarch, S390_PC_REGNUM);
set_gdbarch_register_bytes (gdbarch, SH_DEFAULT_NUM_REGS * 4);
set_gdbarch_deprecated_do_registers_info (gdbarch, sh_do_registers_info);
set_gdbarch_breakpoint_from_pc (gdbarch, sh_breakpoint_from_pc);
- set_gdbarch_frame_chain (gdbarch, sh_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, sh_frame_chain);
set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sh_init_extra_frame_info);
set_gdbarch_deprecated_extract_return_value (gdbarch, sh_extract_return_value);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh64_nofp_frame_init_saved_regs);
set_gdbarch_breakpoint_from_pc (gdbarch, sh_sh64_breakpoint_from_pc);
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sh64_init_extra_frame_info);
- set_gdbarch_frame_chain (gdbarch, sh64_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, sh64_frame_chain);
set_gdbarch_deprecated_get_saved_register (gdbarch, sh64_get_saved_register);
set_gdbarch_deprecated_extract_return_value (gdbarch, sh64_extract_return_value);
set_gdbarch_push_arguments (gdbarch, sh64_push_arguments);
CORE_ADDR
sparc_frame_chain (struct frame_info *frame)
{
- /* Value that will cause FRAME_CHAIN_VALID to not worry about the chain
- value. If it really is zero, we detect it later in
- sparc_init_prev_frame.
+ /* Value that will cause DEPRECATED_FRAME_CHAIN_VALID to not worry
+ about the chain value. If it really is zero, we detect it later
+ in sparc_init_prev_frame.
Note: kevinb/2003-02-18: The constant 1 used to be returned
here, but, after some recent changes to frame_chain_valid(),
set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_fp_regnum (gdbarch, SPARC_FP_REGNUM);
set_gdbarch_fp0_regnum (gdbarch, SPARC_FP0_REGNUM);
- set_gdbarch_frame_chain (gdbarch, sparc_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, sparc_frame_chain);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sparc_frame_init_saved_regs);
set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, sparc_frame_saved_pc);
*/
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, v850_frame_init_saved_regs);
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, v850_init_extra_frame_info);
- set_gdbarch_frame_chain (gdbarch, v850_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, v850_frame_chain);
set_gdbarch_saved_pc_after_call (gdbarch, v850_saved_pc_after_call);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, v850_frame_saved_pc);
set_gdbarch_skip_prologue (gdbarch, v850_skip_prologue);
be able to correctly perform back traces. If a target is
having trouble with backtraces, first thing to do is add
FRAME_ALIGN() to its architecture vector. After that, try
- adding SAVE_DUMMY_FRAME_TOS() and modifying FRAME_CHAIN so that
- when the next outer frame is a generic dummy, it returns the
- current frame's base. */
+ adding SAVE_DUMMY_FRAME_TOS() and modifying
+ DEPRECATED_FRAME_CHAIN so that when the next outer frame is a
+ generic dummy, it returns the current frame's base. */
sp = old_sp;
if (INNER_THAN (1, 2))
static gdbarch_skip_prologue_ftype vax_skip_prologue;
static gdbarch_saved_pc_after_call_ftype vax_saved_pc_after_call;
static gdbarch_frame_num_args_ftype vax_frame_num_args;
-static gdbarch_frame_chain_ftype vax_frame_chain;
+static gdbarch_deprecated_frame_chain_ftype vax_frame_chain;
static gdbarch_frame_args_address_ftype vax_frame_args_address;
static gdbarch_frame_locals_address_ftype vax_frame_locals_address;
set_gdbarch_frameless_function_invocation (gdbarch,
generic_frameless_function_invocation_not);
- set_gdbarch_frame_chain (gdbarch, vax_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, vax_frame_chain);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, vax_frame_saved_pc);
set_gdbarch_frame_args_address (gdbarch, vax_frame_args_address);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, x86_64_frame_init_saved_regs);
set_gdbarch_skip_prologue (gdbarch, x86_64_skip_prologue);
- set_gdbarch_frame_chain (gdbarch, x86_64_linux_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, x86_64_linux_frame_chain);
set_gdbarch_frameless_function_invocation (gdbarch,
x86_64_frameless_function_invocation);
/* FIXME: kettenis/20021026: These two are GNU/Linux-specific and
xstormy16_init_extra_frame_info);
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch,
xstormy16_frame_init_saved_regs);
- set_gdbarch_frame_chain (gdbarch, xstormy16_frame_chain);
+ set_gdbarch_deprecated_frame_chain (gdbarch, xstormy16_frame_chain);
set_gdbarch_deprecated_get_saved_register (gdbarch, xstormy16_get_saved_register);
set_gdbarch_saved_pc_after_call (gdbarch, xstormy16_saved_pc_after_call);
set_gdbarch_deprecated_frame_saved_pc (gdbarch, xstormy16_frame_saved_pc);
set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
- set_gdbarch_frame_chain_valid (gdbarch, xstormy16_frame_chain_valid);
+ set_gdbarch_deprecated_frame_chain_valid (gdbarch, xstormy16_frame_chain_valid);
set_gdbarch_in_function_epilogue_p (gdbarch,
xstormy16_in_function_epilogue_p);
projects / deliverable / binutils-gdb.git / commitdiff
