+2002-11-28 Andrew Cagney <ac131313@redhat.com>
+
+ * gdbarch.sh (DEPRECATED_USE_GENERIC_DUMMY_FRAMES): Rename
+ USE_GENERIC_DUMMY_FRAMES.
+ * gdbarch.h, gdbarch.c: Regenerate.
+ * valops.c, frame.c: Update.
+ * config/z8k/tm-z8k.h, config/mn10200/tm-mn10200.h: Update.
+ * config/m32r/tm-m32r.h, config/h8500/tm-h8500.h: Update.
+ * config/pa/tm-hppa.h, blockframe.c: Update.
+ * vax-tdep.c, sparc-tdep.c, ns32k-tdep.c: Ditto.
+ * m68k-tdep.c, alpha-tdep.c: Ditto.
+
+ * arm-tdep.c: Eliminate USE_GENERIC_DUMMY_FRAMES as always 1.
+ * mips-tdep.c: Ditto.
+
2002-11-27 Andrew Cagney <ac131313@redhat.com>
* gdbarch.sh (CALL_DUMMY_LOCATION): Default to AT_ENTRY_POINT.
alpha_extract_struct_value_address);
/* Settings for calling functions in the inferior. */
- set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
+ set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
set_gdbarch_call_dummy_length (gdbarch, 0);
set_gdbarch_push_arguments (gdbarch, alpha_push_arguments);
set_gdbarch_pop_frame (gdbarch, alpha_pop_frame);
struct symtab_and_line sal;
/* If we're in a dummy frame, don't even try to skip the prologue. */
- if (USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (pc, 0, 0))
+ if (PC_IN_CALL_DUMMY (pc, 0, 0))
return pc;
/* See what the symbol table says. */
int i;
/* Don't try to scan dummy frames. */
- if (USE_GENERIC_DUMMY_FRAMES
- && fi != NULL
+ if (fi != NULL
&& PC_IN_CALL_DUMMY (fi->pc, 0, 0))
return;
function could be called directly. */
for (; fi; fi = fi->next)
{
- if (USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (fi->pc, 0, 0))
+ if (PC_IN_CALL_DUMMY (fi->pc, 0, 0))
{
return deprecated_read_register_dummy (fi->pc, fi->frame, regnum);
}
CORE_ADDR caller_pc;
int framereg = fi->extra_info->framereg;
- if (USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (fi->pc, 0, 0))
+ if (PC_IN_CALL_DUMMY (fi->pc, 0, 0))
/* A generic call dummy's frame is the same as caller's. */
return fi->frame;
the sigtramp and call dummy cases. */
if (!fi->next)
sp = read_sp();
- else if (USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (fi->next->pc, 0, 0))
+ else if (PC_IN_CALL_DUMMY (fi->next->pc, 0, 0))
/* For generic dummy frames, pull the value direct from the frame.
Having an unwind function to do this would be nice. */
sp = deprecated_read_register_dummy (fi->next->pc, fi->next->frame,
fi->extra_info->frameoffset = 0;
}
- else if (!USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (fi->pc, sp, fi->frame))
- {
- CORE_ADDR rp;
- CORE_ADDR callers_sp;
-
- /* Set rp point at the high end of the saved registers. */
- rp = fi->frame - REGISTER_SIZE;
-
- /* Fill in addresses of saved registers. */
- fi->saved_regs[ARM_PS_REGNUM] = rp;
- rp -= REGISTER_RAW_SIZE (ARM_PS_REGNUM);
- for (reg = ARM_PC_REGNUM; reg >= 0; reg--)
- {
- fi->saved_regs[reg] = rp;
- rp -= REGISTER_RAW_SIZE (reg);
- }
-
- callers_sp = read_memory_integer (fi->saved_regs[ARM_SP_REGNUM],
- REGISTER_RAW_SIZE (ARM_SP_REGNUM));
- if (arm_pc_is_thumb (fi->pc))
- fi->extra_info->framereg = THUMB_FP_REGNUM;
- else
- fi->extra_info->framereg = ARM_FP_REGNUM;
- fi->extra_info->framesize = callers_sp - sp;
- fi->extra_info->frameoffset = fi->frame - sp;
- }
else
{
arm_scan_prologue (fi);
if (!fi->next)
/* This is the innermost frame? */
fi->frame = read_register (fi->extra_info->framereg);
- else if (USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (fi->next->pc, 0, 0))
+ else if (PC_IN_CALL_DUMMY (fi->next->pc, 0, 0))
/* Next inner most frame is a dummy, just grab its frame.
Dummy frames always have the same FP as their caller. */
fi->frame = fi->next->frame;
arm_frame_saved_pc (struct frame_info *fi)
{
/* If a dummy frame, pull the PC out of the frame's register buffer. */
- if (USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (fi->pc, 0, 0))
+ if (PC_IN_CALL_DUMMY (fi->pc, 0, 0))
return deprecated_read_register_dummy (fi->pc, fi->frame, ARM_PC_REGNUM);
if (PC_IN_CALL_DUMMY (fi->pc, fi->frame - fi->extra_info->frameoffset,
CORE_ADDR old_SP = (frame->frame - frame->extra_info->frameoffset
+ frame->extra_info->framesize);
- if (USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
+ if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
{
generic_pop_dummy_frame ();
flush_cached_frames ();
int
generic_func_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
{
- if (USE_GENERIC_DUMMY_FRAMES
+ if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
&& PC_IN_CALL_DUMMY ((fi)->pc, 0, 0))
return 1; /* don't prune CALL_DUMMY frames */
else /* fall back to default algorithm (see frame.h) */
return 0;
/* This function is used by two files: get_frame_type(), after first
- checking that !USE_GENERIC_DUMMY_FRAMES; and sparc-tdep.c, which
- doesn't yet use generic dummy frames anyway. */
- gdb_assert (!USE_GENERIC_DUMMY_FRAMES);
+ checking that !DEPRECATED_USE_GENERIC_DUMMY_FRAMES; and
+ sparc-tdep.c, which doesn't yet use generic dummy frames anyway. */
+ gdb_assert (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES);
ALL_BREAKPOINTS (b)
{
#include "regcache.h"
/* NOTE: cagney/2002-11-24: This is a guess. */
-#define USE_GENERIC_DUMMY_FRAMES 0
+#define DEPRECATED_USE_GENERIC_DUMMY_FRAMES 0
#define CALL_DUMMY_LOCATION ON_STACK
#define PC_IN_CALL_DUMMY(pc, sp, frame_address) deprecated_pc_in_call_dummy_on_stack (pc, sp, frame_address)
deprecated_generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
-#define USE_GENERIC_DUMMY_FRAMES 1
+#define DEPRECATED_USE_GENERIC_DUMMY_FRAMES 1
#define CALL_DUMMY {0}
#define CALL_DUMMY_LENGTH (0)
#define CALL_DUMMY_START_OFFSET (0)
extern void mn10200_pop_frame (struct frame_info *);
#define POP_FRAME mn10200_pop_frame (get_current_frame ())
-#define USE_GENERIC_DUMMY_FRAMES 1
+#define DEPRECATED_USE_GENERIC_DUMMY_FRAMES 1
#define CALL_DUMMY {0}
#define CALL_DUMMY_START_OFFSET (0)
#define CALL_DUMMY_BREAKPOINT_OFFSET (0)
#define GDB_MULTI_ARCH 0
/* NOTE: cagney/2002-11-24: This is a guess. */
-#define USE_GENERIC_DUMMY_FRAMES 0
+#define DEPRECATED_USE_GENERIC_DUMMY_FRAMES 0
#define CALL_DUMMY_LOCATION ON_STACK
#define PC_IN_CALL_DUMMY(pc, sp, frame_address) deprecated_pc_in_call_dummy_on_stack (pc, sp, frame_address)
Boston, MA 02111-1307, USA. */
/* NOTE: cagney/2002-11-24: This is a guess. */
-#define USE_GENERIC_DUMMY_FRAMES 0
+#define DEPRECATED_USE_GENERIC_DUMMY_FRAMES 0
#define CALL_DUMMY_LOCATION ON_STACK
#define PC_IN_CALL_DUMMY(pc, sp, frame_address) deprecated_pc_in_call_dummy_on_stack (pc, sp, frame_address)
+2002-11-28 Andrew Cagney <ac131313@redhat.com>
+
+ * gdbint.texinfo (Host Definition): Delete documentation on
+ USE_GENERIC_DUMMY_FRAMES.
+
2002-11-26 Elena Zannoni <ezannoni@redhat.com>
Fix PR gdb/723 and PR gdb/245.
set correctly if compiling with GCC. This will almost never need to be
defined.
-@item USE_GENERIC_DUMMY_FRAMES
-@cindex generic dummy frames
-Define this to 1 if the target is using the generic inferior function
-call code. See @code{blockframe.c} for more information.
-
@item USE_MMALLOC
@findex mmalloc
@value{GDBN} will use the @code{mmalloc} library for memory allocation
/* If we're using generic dummy frames, we'd better not be in a call
dummy. (generic_call_dummy_register_unwind ought to have been called
instead.) */
- gdb_assert (!(USE_GENERIC_DUMMY_FRAMES
+ gdb_assert (!(DEPRECATED_USE_GENERIC_DUMMY_FRAMES
&& (get_frame_type (frame) == DUMMY_FRAME)));
/* Load the saved_regs register cache. */
frame_register_unwind_ftype **unwind_register,
frame_pc_unwind_ftype **unwind_pc)
{
- if (!USE_GENERIC_DUMMY_FRAMES)
+ if (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
{
/* Still need to set this to something. The ``info frame'' code
calls this function to find out where the saved registers are.
pc_in_dummy_frame() as some architectures don't set
PC_IN_CALL_DUMMY() to generic_pc_in_call_dummy() (remember the
latter is implemented by simply calling pc_in_dummy_frame). */
- if (USE_GENERIC_DUMMY_FRAMES && PC_IN_CALL_DUMMY (pc, 0, 0))
+ if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES && PC_IN_CALL_DUMMY (pc, 0, 0))
/* NOTE: cagney/2002-11-11: Does this even occure? */
type = DUMMY_FRAME;
else
pc_in_dummy_frame() as some architectures don't set
PC_IN_CALL_DUMMY() to generic_pc_in_call_dummy() (remember the
latter is implemented by simply calling pc_in_dummy_frame). */
- if (USE_GENERIC_DUMMY_FRAMES && PC_IN_CALL_DUMMY (prev->pc, 0, 0))
+ if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
+ && PC_IN_CALL_DUMMY (prev->pc, 0, 0))
prev->type = DUMMY_FRAME;
else
{
{
/* Some targets still don't use [generic] dummy frames. Catch them
here. */
- if (!USE_GENERIC_DUMMY_FRAMES
+ if (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES
&& deprecated_frame_in_dummy (frame))
return DUMMY_FRAME;
return frame->type;
gdbarch_cannot_fetch_register_ftype *cannot_fetch_register;
gdbarch_cannot_store_register_ftype *cannot_store_register;
gdbarch_get_longjmp_target_ftype *get_longjmp_target;
- int use_generic_dummy_frames;
+ int deprecated_use_generic_dummy_frames;
int call_dummy_location;
gdbarch_call_dummy_address_ftype *call_dummy_address;
CORE_ADDR call_dummy_start_offset;
current_gdbarch->register_sim_regno = legacy_register_sim_regno;
current_gdbarch->cannot_fetch_register = cannot_register_not;
current_gdbarch->cannot_store_register = cannot_register_not;
- current_gdbarch->use_generic_dummy_frames = 1;
+ current_gdbarch->deprecated_use_generic_dummy_frames = 1;
current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
current_gdbarch->call_dummy_start_offset = -1;
current_gdbarch->call_dummy_breakpoint_offset = -1;
/* Skip verify of cannot_fetch_register, invalid_p == 0 */
/* Skip verify of cannot_store_register, invalid_p == 0 */
/* Skip verify of get_longjmp_target, has predicate */
- /* Skip verify of use_generic_dummy_frames, invalid_p == 0 */
+ /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
/* Skip verify of call_dummy_location, invalid_p == 0 */
if ((GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
&& (gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0))
(long) current_gdbarch->deprecated_store_return_value
/*DEPRECATED_STORE_RETURN_VALUE ()*/);
#endif
+#ifdef DEPRECATED_USE_GENERIC_DUMMY_FRAMES
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES # %s\n",
+ XSTRING (DEPRECATED_USE_GENERIC_DUMMY_FRAMES));
+ fprintf_unfiltered (file,
+ "gdbarch_dump: DEPRECATED_USE_GENERIC_DUMMY_FRAMES = %d\n",
+ DEPRECATED_USE_GENERIC_DUMMY_FRAMES);
+#endif
#ifdef DWARF2_BUILD_FRAME_INFO
#if GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
(long) current_gdbarch->write_sp
/*TARGET_WRITE_SP ()*/);
#endif
-#ifdef USE_GENERIC_DUMMY_FRAMES
- fprintf_unfiltered (file,
- "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES # %s\n",
- XSTRING (USE_GENERIC_DUMMY_FRAMES));
- fprintf_unfiltered (file,
- "gdbarch_dump: USE_GENERIC_DUMMY_FRAMES = %d\n",
- USE_GENERIC_DUMMY_FRAMES);
-#endif
#ifdef USE_STRUCT_CONVENTION
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
}
int
-gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch)
+gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
- /* Skip verify of use_generic_dummy_frames, invalid_p == 0 */
+ /* Skip verify of deprecated_use_generic_dummy_frames, invalid_p == 0 */
if (gdbarch_debug >= 2)
- fprintf_unfiltered (gdb_stdlog, "gdbarch_use_generic_dummy_frames called\n");
- return gdbarch->use_generic_dummy_frames;
+ fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_use_generic_dummy_frames called\n");
+ return gdbarch->deprecated_use_generic_dummy_frames;
}
void
-set_gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch,
- int use_generic_dummy_frames)
+set_gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch,
+ int deprecated_use_generic_dummy_frames)
{
- gdbarch->use_generic_dummy_frames = use_generic_dummy_frames;
+ gdbarch->deprecated_use_generic_dummy_frames = deprecated_use_generic_dummy_frames;
}
int
avoids any potential problems with moving beyond multi-arch partial. */
/* Default (value) for non- multi-arch platforms. */
-#if (!GDB_MULTI_ARCH) && !defined (USE_GENERIC_DUMMY_FRAMES)
-#define USE_GENERIC_DUMMY_FRAMES (1)
+#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
+#define DEPRECATED_USE_GENERIC_DUMMY_FRAMES (1)
#endif
-extern int gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch);
-extern void set_gdbarch_use_generic_dummy_frames (struct gdbarch *gdbarch, int use_generic_dummy_frames);
-#if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) && defined (USE_GENERIC_DUMMY_FRAMES)
-#error "Non multi-arch definition of USE_GENERIC_DUMMY_FRAMES"
+extern int gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch);
+extern void set_gdbarch_deprecated_use_generic_dummy_frames (struct gdbarch *gdbarch, int deprecated_use_generic_dummy_frames);
+#if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
+#error "Non multi-arch definition of DEPRECATED_USE_GENERIC_DUMMY_FRAMES"
#endif
#if GDB_MULTI_ARCH
-#if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) || !defined (USE_GENERIC_DUMMY_FRAMES)
-#define USE_GENERIC_DUMMY_FRAMES (gdbarch_use_generic_dummy_frames (current_gdbarch))
+#if (GDB_MULTI_ARCH >= GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
+#define DEPRECATED_USE_GENERIC_DUMMY_FRAMES (gdbarch_deprecated_use_generic_dummy_frames (current_gdbarch))
#endif
#endif
# behaviour here (and hence entrench it further) gdbarch simply
# reqires that these methods be set up from the word go. This also
# avoids any potential problems with moving beyond multi-arch partial.
-v:1:USE_GENERIC_DUMMY_FRAMES:int:use_generic_dummy_frames:::::1::0
+v:1:DEPRECATED_USE_GENERIC_DUMMY_FRAMES:int:deprecated_use_generic_dummy_frames:::::1::0
v:1:CALL_DUMMY_LOCATION:int:call_dummy_location:::::AT_ENTRY_POINT::0
f:2:CALL_DUMMY_ADDRESS:CORE_ADDR:call_dummy_address:void:::0:0::gdbarch->call_dummy_location == AT_ENTRY_POINT && gdbarch->call_dummy_address == 0
v:2:CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset::::0:-1:::0x%08lx
set_gdbarch_ps_regnum (gdbarch, M68K_PS_REGNUM);
set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
- set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
+ set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 24);
int pcreg = (get_frame_type (frame) == SIGTRAMP_FRAME) ? PC_REGNUM
: (proc_desc ? PROC_PC_REG (proc_desc) : RA_REGNUM);
- if (USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (frame->pc, 0, 0))
+ if (PC_IN_CALL_DUMMY (frame->pc, 0, 0))
{
LONGEST tmp;
frame_unwind_signed_register (frame, PC_REGNUM, &tmp);
if ((tmp = SKIP_TRAMPOLINE_CODE (saved_pc)) != 0)
saved_pc = tmp;
- if (USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (saved_pc, 0, 0))
+ if (PC_IN_CALL_DUMMY (saved_pc, 0, 0))
{
/* A dummy frame, uses SP not FP. Get the old SP value. If all
is well, frame->frame the bottom of the current frame will
&& !(get_frame_type (frame) == SIGTRAMP_FRAME)
/* For a generic dummy frame, let get_frame_pointer() unwind a
register value saved as part of the dummy frame call. */
- && !(USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (frame->pc, 0, 0)))
+ && !(PC_IN_CALL_DUMMY (frame->pc, 0, 0)))
return 0;
else
return get_frame_pointer (frame, proc_desc);
if (fci->pc == PROC_LOW_ADDR (proc_desc)
&& !PROC_DESC_IS_DUMMY (proc_desc))
fci->frame = read_next_frame_reg (fci->next, SP_REGNUM);
- else if (USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (fci->pc, 0, 0))
+ else if (PC_IN_CALL_DUMMY (fci->pc, 0, 0))
/* Do not ``fix'' fci->frame. It will have the value of the
generic dummy frame's top-of-stack (since the draft
fci->frame is obtained by returning the unwound stack
CORE_ADDR new_sp = get_frame_base (frame);
mips_extra_func_info_t proc_desc = frame->extra_info->proc_desc;
- if (USE_GENERIC_DUMMY_FRAMES
- && PC_IN_CALL_DUMMY (frame->pc, 0, 0))
+ if (PC_IN_CALL_DUMMY (frame->pc, 0, 0))
{
generic_pop_dummy_frame ();
flush_cached_frames ();
set_gdbarch_fix_call_dummy (gdbarch, ns32k_fix_call_dummy);
set_gdbarch_call_dummy_start_offset (gdbarch, 3);
set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 0);
- set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
+ set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
set_gdbarch_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
set_gdbarch_skip_prologue (gdbarch, sparc_skip_prologue);
set_gdbarch_sp_regnum (gdbarch, SPARC_SP_REGNUM);
- set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
+ set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
/*
if (CALL_DUMMY_LOCATION == ON_STACK)
{
write_memory (start_sp, (char *) dummy1, sizeof_dummy1);
- if (USE_GENERIC_DUMMY_FRAMES)
+ if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
generic_save_call_dummy_addr (start_sp, start_sp + sizeof_dummy1);
}
sp = old_sp;
real_pc = text_end - sizeof_dummy1;
write_memory (real_pc, (char *) dummy1, sizeof_dummy1);
- if (USE_GENERIC_DUMMY_FRAMES)
+ if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
generic_save_call_dummy_addr (real_pc, real_pc + sizeof_dummy1);
}
errcode = target_write_memory (real_pc, (char *) dummy1, sizeof_dummy1);
if (errcode != 0)
error ("Cannot write text segment -- call_function failed");
- if (USE_GENERIC_DUMMY_FRAMES)
+ if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
generic_save_call_dummy_addr (real_pc, real_pc + sizeof_dummy1);
}
if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
{
real_pc = funaddr;
- if (USE_GENERIC_DUMMY_FRAMES)
+ if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
/* NOTE: cagney/2002-04-13: The entry point is going to be
modified with a single breakpoint. */
generic_save_call_dummy_addr (CALL_DUMMY_ADDRESS (),
set_gdbarch_call_dummy_start_offset (gdbarch, 0);
set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 7);
- set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
+ set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
set_gdbarch_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
projects / binutils-gdb.git / commitdiff