OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

2003-05-03 Andrew Cagney <cagney@redhat.com> 

* gdbarch.sh (DEPRECATED_REGISTER_SIZE): Rename REGISTER_SIZE.
	(DEPRECATED_SIZEOF_CALL_DUMMY_WORDS): Rename
	SIZEOF_CALL_DUMMY_WORDS.
	(DEPRECATED_CALL_DUMMY_WORDS): Rename CALL_DUMMY_WORDS.
	(DEPRECATED_FIX_CALL_DUMMY): Rename FIX_CALL_DUMMY.
	(DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET): Rename
	CALL_DUMMY_BREAKPOINT_OFFSET.
	(DEPRECATED_CALL_DUMMY_START_OFFSET): Rename
	CALL_DUMMY_START_OFFSET.
	(DEPRECATED_CALL_DUMMY_LENGTH): Rename CALL_DUMMY_LENGTH.
	* gdbarch.h, gdbarch.c: Re-generate.
	* alpha-tdep.c, alphafbsd-tdep.c, arm-linux-tdep.c: Update.
	* arm-tdep.c, avr-tdep.c, breakpoint.c, cris-tdep.c: Update.
	* dummy-frame.c, dummy-frame.h, frv-tdep.c, gdbarch.c: Update.
	* gdbarch.h, gdbarch.sh, h8300-tdep.c, hppa-tdep.c: Update.
	* i386-tdep.c, ia64-tdep.c, infcall.c, inferior.h: Update.
	* m68hc11-tdep.c, m68k-tdep.c, mcore-tdep.c: Update.
	* mips-tdep.c, mn10300-tdep.c, ns32k-tdep.c: Update.
	* rs6000-tdep.c, s390-tdep.c, sh-tdep.c, sol-thread.c: Update.
	* sparc-tdep.c, target.c, v850-tdep.c, valops.c: Update.
	* vax-tdep.c, x86-64-tdep.c, xstormy16-tdep.c: Update.
	* config/ia64/tm-ia64.h, config/m68k/tm-vx68.h: Update.
	* config/mips/tm-mips.h, config/pa/nm-hppah.h: Update.
	* config/pa/tm-hppa.h, config/pa/tm-hppa64.h: Update.
	* config/s390/tm-s390.h, config/sparc/tm-sp64.h: Update.
	* config/sparc/tm-sparc.h: Update.

Index: doc/ChangeLog
2003-05-03  Andrew Cagney  <cagney@redhat.com>

	* gdbint.texinfo (Target Architecture Definition): Make
	CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS, CALL_DUMMY_LENGTH,
	FIX_CALL_DUMMY, CALL_DUMMY_BREAKPOINT_OFFSET and
	CALL_DUMMY_BREAKPOINT_OFFSET deprecated.

Index: mi/ChangeLog
2003-05-03  Andrew Cagney  <cagney@redhat.com>

	* mi-main.c (mi_cmd_data_write_register_values): Replace
	REGISTER_SIZE with DEPRECATED_REGISTER_SIZE.

Index: testsuite/ChangeLog
2003-05-03  Andrew Cagney  <cagney@redhat.com>

	* gdb.base/watchpoint.exp: Rename CALL_DUMMY_BREAKPOINT_OFFSET to
	DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET in comments.
This commit is contained in:
Andrew Cagney 2003-05-05 17:56:57 +00:00
parent 4e795f50c1
commit b1e29e332a
52 changed files with 626 additions and 572 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
gdb/ChangeLog
View File

@ -1,3 +1,32 @@
2003-05-05 Andrew Cagney <cagney@redhat.com>
* gdbarch.sh (DEPRECATED_REGISTER_SIZE): Rename REGISTER_SIZE.
(DEPRECATED_SIZEOF_CALL_DUMMY_WORDS): Rename
SIZEOF_CALL_DUMMY_WORDS.
(DEPRECATED_CALL_DUMMY_WORDS): Rename CALL_DUMMY_WORDS.
(DEPRECATED_FIX_CALL_DUMMY): Rename FIX_CALL_DUMMY.
(DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET): Rename
CALL_DUMMY_BREAKPOINT_OFFSET.
(DEPRECATED_CALL_DUMMY_START_OFFSET): Rename
CALL_DUMMY_START_OFFSET.
(DEPRECATED_CALL_DUMMY_LENGTH): Rename CALL_DUMMY_LENGTH.
* gdbarch.h, gdbarch.c: Re-generate.
* alpha-tdep.c, alphafbsd-tdep.c, arm-linux-tdep.c: Update.
* arm-tdep.c, avr-tdep.c, breakpoint.c, cris-tdep.c: Update.
* dummy-frame.c, dummy-frame.h, frv-tdep.c, gdbarch.c: Update.
* gdbarch.h, gdbarch.sh, h8300-tdep.c, hppa-tdep.c: Update.
* i386-tdep.c, ia64-tdep.c, infcall.c, inferior.h: Update.
* m68hc11-tdep.c, m68k-tdep.c, mcore-tdep.c: Update.
* mips-tdep.c, mn10300-tdep.c, ns32k-tdep.c: Update.
* rs6000-tdep.c, s390-tdep.c, sh-tdep.c, sol-thread.c: Update.
* sparc-tdep.c, target.c, v850-tdep.c, valops.c: Update.
* vax-tdep.c, x86-64-tdep.c, xstormy16-tdep.c: Update.
* config/ia64/tm-ia64.h, config/m68k/tm-vx68.h: Update.
* config/mips/tm-mips.h, config/pa/nm-hppah.h: Update.
* config/pa/tm-hppa.h, config/pa/tm-hppa64.h: Update.
* config/s390/tm-s390.h, config/sparc/tm-sp64.h: Update.
* config/sparc/tm-sparc.h: Update.
2003-05-04 Andrew Cagney <cagney@redhat.com>
* gdbthread.h (save_infrun_state): Drop prev_func_name parameter.

10
gdb/alpha-tdep.c
View File

@ -66,8 +66,6 @@ static gdbarch_frame_locals_address_ftype alpha_frame_locals_address;
static gdbarch_skip_prologue_ftype alpha_skip_prologue;
static gdbarch_fix_call_dummy_ftype alpha_fix_call_dummy;
static gdbarch_get_longjmp_target_ftype alpha_get_longjmp_target;
struct frame_extra_info
@ -1811,7 +1809,7 @@ alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_fp0_regnum (gdbarch, ALPHA_FP0_REGNUM);
set_gdbarch_register_name (gdbarch, alpha_register_name);
set_gdbarch_register_size (gdbarch, ALPHA_REGISTER_SIZE);
set_gdbarch_deprecated_register_size (gdbarch, ALPHA_REGISTER_SIZE);
set_gdbarch_register_bytes (gdbarch, ALPHA_REGISTER_BYTES);
set_gdbarch_register_byte (gdbarch, alpha_register_byte);
set_gdbarch_register_raw_size (gdbarch, alpha_register_raw_size);
@ -1859,8 +1857,8 @@ alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
stopping the user call is achieved via a bp_call_dummy breakpoint.
But we need a fake CALL_DUMMY definition to enable the proper
call_function_by_hand and to avoid zero length array warnings. */
set_gdbarch_call_dummy_words (gdbarch, alpha_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_deprecated_call_dummy_words (gdbarch, alpha_call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_frame_args_address (gdbarch, alpha_frame_args_address);
set_gdbarch_frame_locals_address (gdbarch, alpha_frame_locals_address);
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, alpha_init_extra_frame_info);
@ -1873,7 +1871,7 @@ alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_push_dummy_frame (gdbarch, alpha_push_dummy_frame);
/* Should be using push_dummy_call. */
set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
set_gdbarch_fix_call_dummy (gdbarch, alpha_fix_call_dummy);
set_gdbarch_deprecated_fix_call_dummy (gdbarch, alpha_fix_call_dummy);
set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_noop);
set_gdbarch_deprecated_init_frame_pc_first (gdbarch, alpha_init_frame_pc_first);

2
gdb/alphafbsd-tdep.c
View File

@ -32,7 +32,7 @@ alphafbsd_use_struct_convention (int gcc_p, struct type *type)
/* All aggregate types that won't fit in a register must be returned
in memory. */
if (TYPE_LENGTH (type) > REGISTER_SIZE)
if (TYPE_LENGTH (type) > DEPRECATED_REGISTER_SIZE)
return 1;
/* The only aggregate types that can be returned in a register are

21
gdb/arm-linux-tdep.c
View File

@ -46,7 +46,7 @@
static const char arm_linux_arm_le_breakpoint[] = {0x01,0x00,0x9f,0xef};
/* CALL_DUMMY_WORDS:
/* DEPRECATED_CALL_DUMMY_WORDS:
This sequence of words is the instructions
mov lr, pc
@ -115,10 +115,10 @@ arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
/* Walk through the list of args and determine how large a temporary
stack is required. Need to take care here as structs may be
passed on the stack, and we have to to push them. */
nstack_size = -4 * REGISTER_SIZE; /* Some arguments go into A1-A4. */
nstack_size = -4 * DEPRECATED_REGISTER_SIZE; /* Some arguments go into A1-A4. */
if (struct_return) /* The struct address goes in A1. */
nstack_size += REGISTER_SIZE;
nstack_size += DEPRECATED_REGISTER_SIZE;
/* Walk through the arguments and add their size to nstack_size. */
for (argnum = 0; argnum < nargs; argnum++)
@ -131,7 +131,7 @@ arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
/* ANSI C code passes float arguments as integers, K&R code
passes float arguments as doubles. Correct for this here. */
if (TYPE_CODE_FLT == TYPE_CODE (arg_type) && REGISTER_SIZE == len)
if (TYPE_CODE_FLT == TYPE_CODE (arg_type) && DEPRECATED_REGISTER_SIZE == len)
nstack_size += FP_REGISTER_VIRTUAL_SIZE;
else
nstack_size += len;
@ -178,7 +178,7 @@ arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
.stabs records the type as FP_FLOAT. In this latter case
the compiler converts the float arguments to double before
calling the function. */
if (TYPE_CODE_FLT == typecode && REGISTER_SIZE == len)
if (TYPE_CODE_FLT == typecode && DEPRECATED_REGISTER_SIZE == len)
{
DOUBLEST dblval;
dblval = deprecated_extract_floating (val, len);
@ -203,7 +203,7 @@ arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
registers and stack. */
while (len > 0)
{
int partial_len = len < REGISTER_SIZE ? len : REGISTER_SIZE;
int partial_len = len < DEPRECATED_REGISTER_SIZE ? len : DEPRECATED_REGISTER_SIZE;
if (argreg <= ARM_LAST_ARG_REGNUM)
{
@ -214,8 +214,8 @@ arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
else
{
/* Push the arguments onto the stack. */
write_memory ((CORE_ADDR) fp, val, REGISTER_SIZE);
fp += REGISTER_SIZE;
write_memory ((CORE_ADDR) fp, val, DEPRECATED_REGISTER_SIZE);
fp += DEPRECATED_REGISTER_SIZE;
}
len -= partial_len;
@ -530,9 +530,8 @@ arm_linux_init_abi (struct gdbarch_info info,
tdep->jb_pc = ARM_LINUX_JB_PC;
tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
set_gdbarch_call_dummy_words (gdbarch, arm_linux_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch,
sizeof (arm_linux_call_dummy_words));
set_gdbarch_deprecated_call_dummy_words (gdbarch, arm_linux_call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (arm_linux_call_dummy_words));
/* The following two overrides shouldn't be needed. */
set_gdbarch_deprecated_extract_return_value (gdbarch, arm_linux_extract_return_value);

44
gdb/arm-tdep.c
View File

@ -1237,7 +1237,7 @@ arm_push_dummy_frame (void)
write_register (ARM_SP_REGNUM, sp);
}
/* CALL_DUMMY_WORDS:
/* DEPRECATED_CALL_DUMMY_WORDS:
This sequence of words is the instructions
mov lr,pc
@ -1265,9 +1265,9 @@ static void
arm_set_call_dummy_breakpoint_offset (void)
{
if (caller_is_thumb)
set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 4);
set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 4);
else
set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 8);
set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 8);
}
/* Fix up the call dummy, based on whether the processor is currently
@ -1430,7 +1430,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct regcache *regcache,
/* Some platforms require a double-word aligned stack. Make sure sp
is correctly aligned before we start. We always do this even if
it isn't really needed -- it can never hurt things. */
sp &= ~(CORE_ADDR)(2 * REGISTER_SIZE - 1);
sp &= ~(CORE_ADDR)(2 * DEPRECATED_REGISTER_SIZE - 1);
/* The struct_return pointer occupies the first parameter
passing register. */
@ -1477,7 +1477,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct regcache *regcache,
registers and stack. */
while (len > 0)
{
int partial_len = len < REGISTER_SIZE ? len : REGISTER_SIZE;
int partial_len = len < DEPRECATED_REGISTER_SIZE ? len : DEPRECATED_REGISTER_SIZE;
if (argreg <= ARM_LAST_ARG_REGNUM)
{
@ -1487,7 +1487,7 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct regcache *regcache,
if (arm_debug)
fprintf_unfiltered (gdb_stdlog, "arg %d in %s = 0x%s\n",
argnum, REGISTER_NAME (argreg),
phex (regval, REGISTER_SIZE));
phex (regval, DEPRECATED_REGISTER_SIZE));
regcache_cooked_write_unsigned (regcache, argreg, regval);
argreg++;
}
@ -1497,8 +1497,8 @@ arm_push_dummy_call (struct gdbarch *gdbarch, struct regcache *regcache,
if (arm_debug)
fprintf_unfiltered (gdb_stdlog, "arg %d @ sp + %d\n",
argnum, nstack);
si = push_stack_item (si, val, REGISTER_SIZE);
nstack += REGISTER_SIZE;
si = push_stack_item (si, val, DEPRECATED_REGISTER_SIZE);
nstack += DEPRECATED_REGISTER_SIZE;
}
len -= partial_len;
@ -1799,7 +1799,7 @@ thumb_get_next_pc (CORE_ADDR pc)
/* Fetch the saved PC from the stack. It's stored above
all of the other registers. */
offset = bitcount (bits (inst1, 0, 7)) * REGISTER_SIZE;
offset = bitcount (bits (inst1, 0, 7)) * DEPRECATED_REGISTER_SIZE;
sp = read_register (ARM_SP_REGNUM);
nextpc = (CORE_ADDR) read_memory_integer (sp + offset, 4);
nextpc = ADDR_BITS_REMOVE (nextpc);
@ -2309,10 +2309,10 @@ arm_use_struct_convention (int gcc_p, struct type *type)
/* In the ARM ABI, "integer" like aggregate types are returned in
registers. For an aggregate type to be integer like, its size
must be less than or equal to REGISTER_SIZE and the offset of
each addressable subfield must be zero. Note that bit fields are
not addressable, and all addressable subfields of unions always
start at offset zero.
must be less than or equal to DEPRECATED_REGISTER_SIZE and the
offset of each addressable subfield must be zero. Note that bit
fields are not addressable, and all addressable subfields of
unions always start at offset zero.
This function is based on the behaviour of GCC 2.95.1.
See: gcc/arm.c: arm_return_in_memory() for details.
@ -2326,7 +2326,7 @@ arm_use_struct_convention (int gcc_p, struct type *type)
/* All aggregate types that won't fit in a register must be returned
in memory. */
if (TYPE_LENGTH (type) > REGISTER_SIZE)
if (TYPE_LENGTH (type) > DEPRECATED_REGISTER_SIZE)
{
return 1;
}
@ -2348,11 +2348,11 @@ arm_use_struct_convention (int gcc_p, struct type *type)
int i;
/* Need to check if this struct/union is "integer" like. For
this to be true, its size must be less than or equal to
REGISTER_SIZE and the offset of each addressable subfield
must be zero. Note that bit fields are not addressable, and
unions always start at offset zero. If any of the subfields
is a floating point type, the struct/union cannot be an
integer type. */
DEPRECATED_REGISTER_SIZE and the offset of each addressable
subfield must be zero. Note that bit fields are not
addressable, and unions always start at offset zero. If any
of the subfields is a floating point type, the struct/union
cannot be an integer type. */
/* For each field in the object, check:
1) Is it FP? --> yes, nRc = 1;
@ -2930,8 +2930,8 @@ arm_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
tdep->lowest_pc = 0x20;
tdep->jb_pc = -1; /* Longjump support not enabled by default. */
set_gdbarch_call_dummy_words (gdbarch, arm_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_deprecated_call_dummy_words (gdbarch, arm_call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_push_dummy_call (gdbarch, arm_push_dummy_call);
@ -2991,7 +2991,7 @@ arm_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_register_sim_regno (gdbarch, arm_register_sim_regno);
/* Integer registers are 4 bytes. */
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_deprecated_register_size (gdbarch, 4);
set_gdbarch_register_name (gdbarch, arm_register_name);
/* Returning results. */

4
gdb/avr-tdep.c
View File

@ -1156,7 +1156,7 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_pc_regnum (gdbarch, AVR_PC_REGNUM);
set_gdbarch_register_name (gdbarch, avr_register_name);
set_gdbarch_register_size (gdbarch, 1);
set_gdbarch_deprecated_register_size (gdbarch, 1);
set_gdbarch_register_bytes (gdbarch, AVR_NUM_REG_BYTES);
set_gdbarch_register_byte (gdbarch, avr_register_byte);
set_gdbarch_register_raw_size (gdbarch, avr_register_raw_size);
@ -1168,7 +1168,7 @@ avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_print_insn (gdbarch, print_insn_avr);
set_gdbarch_call_dummy_address (gdbarch, avr_call_dummy_address);
set_gdbarch_call_dummy_words (gdbarch, avr_call_dummy_words);
set_gdbarch_deprecated_call_dummy_words (gdbarch, avr_call_dummy_words);
/* set_gdbarch_believe_pcc_promotion (gdbarch, 1); // TRoth: should this be set? */

4
gdb/breakpoint.c
View File

@ -1697,7 +1697,7 @@ deprecated_frame_in_dummy (struct frame_info *frame)
for signals.exp in the testsuite. */
&& (get_frame_pc (frame)
>= (b->address
- SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * REGISTER_SIZE))
- DEPRECATED_SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * DEPRECATED_REGISTER_SIZE))
&& get_frame_pc (frame) <= b->address)
return 1;
}
@ -5464,7 +5464,7 @@ watch_command_1 (char *arg, int accessflag, int from_tty)
#if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
#define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(BYTE_SIZE) \
((BYTE_SIZE) <= (REGISTER_SIZE))
((BYTE_SIZE) <= (DEPRECATED_REGISTER_SIZE))
#endif
#if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)

2
gdb/config/ia64/tm-ia64.h
View File

@ -31,7 +31,7 @@
used in push_word and a few other places; REGISTER_RAW_SIZE is the
real way to know how big a register is. */
#define REGISTER_SIZE 8
#define DEPRECATED_REGISTER_SIZE 8
#undef NUM_REGS
#define NUM_REGS 590

2
gdb/config/m68k/tm-vx68.h
View File

@ -79,4 +79,4 @@
/* Number of registers in a ptrace_getfpregs call. */
#define VX_SIZE_FPREGS (8 * REGISTER_RAW_SIZE (FP0_REGNUM) \
+ (3 * REGISTER_SIZE))
+ (3 * DEPRECATED_REGISTER_SIZE))

4
gdb/config/mips/tm-mips.h
View File

@ -49,10 +49,10 @@ extern int mips_step_skips_delay (CORE_ADDR);
used in push_word and a few other places; REGISTER_RAW_SIZE is the
real way to know how big a register is. */
#define REGISTER_SIZE 4
#define DEPRECATED_REGISTER_SIZE 4
/* The size of a register. This is predefined in tm-mips64.h. We
can't use REGISTER_SIZE because that is used for various other
can't use DEPRECATED_REGISTER_SIZE because that is used for various other
things. */
#ifndef MIPS_REGSIZE

7
gdb/config/pa/nm-hppah.h
View File

@ -121,9 +121,10 @@ extern int hppa_can_use_hw_watchpoint (int type, int cnt, int ot);
#define TARGET_CAN_USE_HARDWARE_WATCHPOINT(type, cnt, ot) \
hppa_can_use_hw_watchpoint(type, cnt, ot)
/* The PA can also watch memory regions of arbitrary size, since we're using
a page-protection scheme. (On some targets, apparently watch registers
are used, which can only accomodate regions of REGISTER_SIZE.) */
/* The PA can also watch memory regions of arbitrary size, since we're
using a page-protection scheme. (On some targets, apparently watch
registers are used, which can only accomodate regions of
DEPRECATED_REGISTER_SIZE.) */
#define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(byte_count) \
(1)

24
gdb/config/pa/tm-hppa.h
View File

@ -274,20 +274,20 @@ extern void hppa_frame_init_saved_regs (struct frame_info *);
(DEPRECATED_PC_IN_CALL_DUMMY((pc), (sp), (frame_address)) && \
(read_memory_integer((pc), 4) == BREAKPOINT32))
/*
* Insert the specified number of args and function address
* into a call sequence of the above form stored at DUMMYNAME.
*
* On the hppa we need to call the stack dummy through $$dyncall.
* Therefore our version of FIX_CALL_DUMMY takes an extra argument,
* real_pc, which is the location where gdb should start up the
* inferior to do the function call.
*/
/* Insert the specified number of args and function address into a
call sequence of the above form stored at DUMMYNAME.
On the hppa we need to call the stack dummy through $$dyncall.
Therefore our version of DEPRECATED_FIX_CALL_DUMMY takes an extra
argument, real_pc, which is the location where gdb should start up
the inferior to do the function call. */
/* FIXME: brobecker 2002-12-26. This macro is going to cause us some
problems before we can go to multiarch partial as it has been diverted
on HPUX to return the value of the PC! */
#define FIX_CALL_DUMMY hppa_fix_call_dummy
problems before we can go to multiarch partial as it has been
diverted on HPUX to return the value of the PC! */
/* NOTE: cagney/2003-05-03: This has been replaced by push_dummy_code.
Hopefully that has all the parameters HP/UX needs. */
#define DEPRECATED_FIX_CALL_DUMMY hppa_fix_call_dummy
extern CORE_ADDR hppa_fix_call_dummy (char *, CORE_ADDR, CORE_ADDR, int,
struct value **, struct type *, int);

32
gdb/config/pa/tm-hppa64.h
View File

@ -109,7 +109,7 @@ extern CORE_ADDR hppa_stack_align (CORE_ADDR sp);
real way to know how big a register is. */
#if !GDB_MULTI_ARCH
#define REGISTER_SIZE 4
#define DEPRECATED_REGISTER_SIZE 4
#endif
/* Number of machine registers */
@ -308,11 +308,11 @@ extern void hppa_pop_frame (void);
#endif
#if !GDB_MULTI_ARCH
#define CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 28)
#define DEPRECATED_CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 28)
#endif
#if !GDB_MULTI_ARCH
#define CALL_DUMMY_START_OFFSET 0
#define DEPRECATED_CALL_DUMMY_START_OFFSET 0
#endif
#if !GDB_MULTI_ARCH
@ -357,8 +357,8 @@ extern CORE_ADDR hppa_target_read_fp (void);
push_word and a few other places, but REGISTER_RAW_SIZE is
the real way to know how big a register is. */
#undef REGISTER_SIZE
#define REGISTER_SIZE 8
#undef DEPRECATED_REGISTER_SIZE
#define DEPRECATED_REGISTER_SIZE 8
/* Number of bytes of storage in the actual machine representation
for register N. On the PA-RISC 2.0, all regs are 8 bytes, including
@ -501,14 +501,14 @@ call_dummy
0xe820f0000fb110d3LL, 0x0001000400151820LL,\
0xe6c0000008000240LL}
#define CALL_DUMMY_BREAKPOINT_OFFSET 22 * 4
#define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET 22 * 4
/* CALL_DUMMY_LENGTH is computed based on the size of a word on the target
machine, not the size of an instruction. Since a word on this target
holds two instructions we have to divide the instruction size by two to
get the word size of the dummy. */
#undef CALL_DUMMY_LENGTH
#define CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 26 / 2)
/* DEPRECATED_CALL_DUMMY_LENGTH is computed based on the size of a
word on the target machine, not the size of an instruction. Since
a word on this target holds two instructions we have to divide the
instruction size by two to get the word size of the dummy. */
#undef DEPRECATED_CALL_DUMMY_LENGTH
#define DEPRECATED_CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 26 / 2)
/* The PA64 ABI mandates a 16 byte stack alignment. */
#undef STACK_ALIGN
@ -540,12 +540,12 @@ call_dummy
if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \
memcpy ((VALBUF), \
((char *)(REGBUF)) + REGISTER_BYTE (FP4_REGNUM) + \
(REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
(DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
TYPE_LENGTH (TYPE)); \
else if (is_integral_type(TYPE)) \
memcpy ((VALBUF), \
(char *)(REGBUF) + REGISTER_BYTE (28) + \
(REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
(DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
TYPE_LENGTH (TYPE)); \
else if (TYPE_LENGTH (TYPE) <= 8) \
memcpy ((VALBUF), \
@ -574,13 +574,13 @@ call_dummy
if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \
deprecated_write_register_bytes \
(REGISTER_BYTE (FP4_REGNUM) + \
(REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
(DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
(VALBUF), \
TYPE_LENGTH (TYPE)); \
else if (is_integral_type(TYPE)) \
deprecated_write_register_bytes \
(REGISTER_BYTE (28) + \
(REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
(DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
(VALBUF), \
TYPE_LENGTH (TYPE)); \
else if (TYPE_LENGTH (TYPE) <= 8) \

12
gdb/config/s390/tm-s390.h
View File

@ -24,15 +24,15 @@
#define TM_S390_H 1
#define S390_NUM_GPRS (16)
#define S390_GPR_SIZE REGISTER_SIZE
#define S390_PSW_MASK_SIZE REGISTER_SIZE
#define S390_PSW_ADDR_SIZE REGISTER_SIZE
#define S390_GPR_SIZE DEPRECATED_REGISTER_SIZE
#define S390_PSW_MASK_SIZE DEPRECATED_REGISTER_SIZE
#define S390_PSW_ADDR_SIZE DEPRECATED_REGISTER_SIZE
#define S390_NUM_FPRS (16)
#define S390_FPR_SIZE (8)
#define S390_FPC_SIZE (4)
#define S390_FPC_PAD_SIZE (4) /* gcc insists on aligning the fpregs */
#define S390_NUM_CRS (16)
#define S390_CR_SIZE REGISTER_SIZE
#define S390_CR_SIZE DEPRECATED_REGISTER_SIZE
#define S390_NUM_ACRS (16)
#define S390_ACR_SIZE (4)
@ -94,7 +94,7 @@ int s390_cannot_fetch_register (int regno);
int s390x_register_raw_size (int reg_nr);
#define REGISTER_RAW_SIZE(reg_nr) s390x_register_raw_size(reg_nr)
#define GDB_TARGET_IS_ESAME (1)
#define REGISTER_SIZE (8)
#define DEPRECATED_REGISTER_SIZE (8)
#define REGISTER_BYTES S390X_REGISTER_BYTES
#else /* CONFIG_ARCH_S390X */
@ -102,7 +102,7 @@ int s390x_register_raw_size (int reg_nr);
int s390_register_raw_size (int reg_nr);
#define REGISTER_RAW_SIZE(reg_nr) s390_register_raw_size(reg_nr)
#define GDB_TARGET_IS_ESAME (0)
#define REGISTER_SIZE (4)
#define DEPRECATED_REGISTER_SIZE (4)
#define REGISTER_BYTES S390_REGISTER_BYTES
#endif /* CONFIG_ARCH_S390X */

44
gdb/config/sparc/tm-sp64.h
View File

@ -90,26 +90,26 @@ struct type;
#undef CALL_DUMMY
#define CALL_DUMMY {0}
#undef CALL_DUMMY_LENGTH
#define CALL_DUMMY_LENGTH 0
#undef DEPRECATED_CALL_DUMMY_LENGTH
#define DEPRECATED_CALL_DUMMY_LENGTH 0
#undef CALL_DUMMY_CALL_OFFSET
#define CALL_DUMMY_CALL_OFFSET 0
#undef CALL_DUMMY_START_OFFSET
#define CALL_DUMMY_START_OFFSET 0
#undef CALL_DUMMY_BREAKPOINT_OFFSET
#define CALL_DUMMY_BREAKPOINT_OFFSET 0
#undef DEPRECATED_CALL_DUMMY_START_OFFSET
#define DEPRECATED_CALL_DUMMY_START_OFFSET 0
#undef DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
#define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET 0
#undef CALL_DUMMY_LOCATION
#define CALL_DUMMY_LOCATION AT_ENTRY_POINT
#undef DEPRECATED_PC_IN_CALL_DUMMY
#define DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address) deprecated_pc_in_call_dummy_at_entry_point (pc, sp, frame_address)
#undef DEPRECATED_CALL_DUMMY_STACK_ADJUST
#define DEPRECATED_CALL_DUMMY_STACK_ADJUST 128
#undef SIZEOF_CALL_DUMMY_WORDS
#define SIZEOF_CALL_DUMMY_WORDS 0
#undef DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
#define DEPRECATED_SIZEOF_CALL_DUMMY_WORDS 0
#undef CALL_DUMMY_ADDRESS
#define CALL_DUMMY_ADDRESS() entry_point_address()
#undef FIX_CALL_DUMMY
#define FIX_CALL_DUMMY(DUMMYNAME, PC, FUN, NARGS, ARGS, TYPE, GCC_P)
#undef DEPRECATED_FIX_CALL_DUMMY
#define DEPRECATED_FIX_CALL_DUMMY(DUMMYNAME, PC, FUN, NARGS, ARGS, TYPE, GCC_P)
#undef DEPRECATED_PUSH_RETURN_ADDRESS
#define DEPRECATED_PUSH_RETURN_ADDRESS(PC, SP) sparc_at_entry_push_return_address (PC, SP)
extern CORE_ADDR sparc_at_entry_push_return_address (CORE_ADDR pc,
@ -147,20 +147,20 @@ extern void sparc_at_entry_store_struct_return (CORE_ADDR addr, CORE_ADDR sp);
#define DEPRECATED_CALL_DUMMY_STACK_ADJUST 128
/* Size of the call dummy in bytes. */
#undef CALL_DUMMY_LENGTH
#define CALL_DUMMY_LENGTH 192
#undef DEPRECATED_CALL_DUMMY_LENGTH
#define DEPRECATED_CALL_DUMMY_LENGTH 192
/* Offset within CALL_DUMMY of the 'call' instruction. */
#undef CALL_DUMMY_START_OFFSET
#define CALL_DUMMY_START_OFFSET 148
#undef DEPRECATED_CALL_DUMMY_START_OFFSET
#define DEPRECATED_CALL_DUMMY_START_OFFSET 148
/* Offset within CALL_DUMMY of the 'call' instruction. */
#undef CALL_DUMMY_CALL_OFFSET
#define CALL_DUMMY_CALL_OFFSET (CALL_DUMMY_START_OFFSET + (5 * 4))
#define CALL_DUMMY_CALL_OFFSET (DEPRECATED_CALL_DUMMY_START_OFFSET + (5 * 4))
/* Offset within CALL_DUMMY of the 'ta 1' instruction. */
#undef CALL_DUMMY_BREAKPOINT_OFFSET
#define CALL_DUMMY_BREAKPOINT_OFFSET (CALL_DUMMY_START_OFFSET + (8 * 4))
#undef DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
#define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET (DEPRECATED_CALL_DUMMY_START_OFFSET + (8 * 4))
/* Call dummy will be located on the stack. */
#undef CALL_DUMMY_LOCATION
@ -169,15 +169,15 @@ extern void sparc_at_entry_store_struct_return (CORE_ADDR addr, CORE_ADDR sp);
#define DEPRECATED_PC_IN_CALL_DUMMY(pc, sp, frame_address) deprecated_pc_in_call_dummy_on_stack (pc, sp, frame_address)
/* Insert the function address into the call dummy. */
#undef FIX_CALL_DUMMY
#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
#undef DEPRECATED_FIX_CALL_DUMMY
#define DEPRECATED_FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
sparc_fix_call_dummy (dummyname, pc, fun, type, gcc_p)
void sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
struct type *value_type, int using_gcc);
/* The remainder of these will accept the default definition. */
#undef SIZEOF_CALL_DUMMY_WORDS
#undef DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
#undef DEPRECATED_PUSH_RETURN_ADDRESS
#undef CALL_DUMMY_ADDRESS
#undef STORE_STRUCT_RETURN
@ -376,8 +376,8 @@ extern void sp64_extract_return_value (struct type *, char[], char *, int);
used in push_word and a few other places; REGISTER_RAW_SIZE is the
real way to know how big a register is. */
#undef REGISTER_SIZE
#define REGISTER_SIZE 8
#undef DEPRECATED_REGISTER_SIZE
#define DEPRECATED_REGISTER_SIZE 8
/* Number of bytes of storage in the actual machine representation
for register N. */

12
gdb/config/sparc/tm-sparc.h
View File

@ -174,7 +174,7 @@ extern int sparc_intreg_size (void);
used in push_word and a few other places; REGISTER_RAW_SIZE is the
real way to know how big a register is. */
#define REGISTER_SIZE 4
#define DEPRECATED_REGISTER_SIZE 4
/* Number of machine registers */
@ -589,19 +589,19 @@ extern CORE_ADDR init_frame_pc_noop (int fromleaf, struct frame_info *prev);
/* Size of the call dummy in bytes. */
#define CALL_DUMMY_LENGTH 0x38
#define DEPRECATED_CALL_DUMMY_LENGTH 0x38
/* Offset within call dummy of first instruction to execute. */
#define CALL_DUMMY_START_OFFSET 0
#define DEPRECATED_CALL_DUMMY_START_OFFSET 0
/* Offset within CALL_DUMMY of the 'call' instruction. */
#define CALL_DUMMY_CALL_OFFSET (CALL_DUMMY_START_OFFSET + 0x24)
#define CALL_DUMMY_CALL_OFFSET (DEPRECATED_CALL_DUMMY_START_OFFSET + 0x24)
/* Offset within CALL_DUMMY of the 'ta 1' trap instruction. */
#define CALL_DUMMY_BREAKPOINT_OFFSET (CALL_DUMMY_START_OFFSET + 0x30)
#define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET (DEPRECATED_CALL_DUMMY_START_OFFSET + 0x30)
#define DEPRECATED_CALL_DUMMY_STACK_ADJUST 68
@ -626,7 +626,7 @@ extern CORE_ADDR init_frame_pc_noop (int fromleaf, struct frame_info *prev);
/* Insert the specified number of args and function address
into a call sequence of the above form stored at DUMMYNAME. */
#define FIX_CALL_DUMMY(DUMMYNAME, PC, FUN, NARGS, ARGS, TYPE, GCC_P) \
#define DEPRECATED_FIX_CALL_DUMMY(DUMMYNAME, PC, FUN, NARGS, ARGS, TYPE, GCC_P) \
sparc_fix_call_dummy (DUMMYNAME, PC, FUN, TYPE, GCC_P)
void sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
struct type *value_type, int using_gcc);

76
gdb/cris-tdep.c
View File

@ -971,7 +971,7 @@ cris_abi_original_store_return_value (struct type *type, char *valbuf)
{
int len = TYPE_LENGTH (type);
if (len <= REGISTER_SIZE)
if (len <= DEPRECATED_REGISTER_SIZE)
deprecated_write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, len);
else
internal_error (__FILE__, __LINE__, "cris_abi_original_store_return_value: type length too large.");
@ -984,7 +984,7 @@ cris_abi_v2_store_return_value (struct type *type, char *valbuf)
{
int len = TYPE_LENGTH (type);
if (len <= 2 * REGISTER_SIZE)
if (len <= 2 * DEPRECATED_REGISTER_SIZE)
{
/* Note that this works since R10 and R11 are consecutive registers. */
deprecated_write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf,
@ -1057,7 +1057,7 @@ cris_abi_original_extract_return_value (struct type *type, char *regbuf,
{
int len = TYPE_LENGTH (type);
if (len <= REGISTER_SIZE)
if (len <= DEPRECATED_REGISTER_SIZE)
memcpy (valbuf, regbuf + REGISTER_BYTE (RET_REGNUM), len);
else
internal_error (__FILE__, __LINE__, "cris_abi_original_extract_return_value: type length too large");
@ -1071,7 +1071,7 @@ cris_abi_v2_extract_return_value (struct type *type, char *regbuf,
{
int len = TYPE_LENGTH (type);
if (len <= 2 * REGISTER_SIZE)
if (len <= 2 * DEPRECATED_REGISTER_SIZE)
memcpy (valbuf, regbuf + REGISTER_BYTE (RET_REGNUM), len);
else
internal_error (__FILE__, __LINE__, "cris_abi_v2_extract_return_value: type length too large");
@ -1311,13 +1311,13 @@ cris_abi_original_push_arguments (int nargs, struct value **args,
/* Make sure there's space on the stack. Allocate space for data and a
parameter to refer to that data. */
for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
stack_alloc += (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + REGISTER_SIZE);
stack_alloc += (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + DEPRECATED_REGISTER_SIZE);
sp -= stack_alloc;
/* We may over-allocate a little here, but that won't hurt anything. */
/* Initialize stack frame pointers. */
fp_params = sp;
fp_data = sp + (nargs * REGISTER_SIZE);
fp_data = sp + (nargs * DEPRECATED_REGISTER_SIZE);
/* Now load as many as possible of the first arguments into
registers, and push the rest onto the stack. */
@ -1330,14 +1330,14 @@ cris_abi_original_push_arguments (int nargs, struct value **args,
len = TYPE_LENGTH (type);
val = (char *) VALUE_CONTENTS (args[argnum]);
if (len <= REGISTER_SIZE && argreg <= ARG4_REGNUM)
if (len <= DEPRECATED_REGISTER_SIZE && argreg <= ARG4_REGNUM)
{
/* Data fits in a register; put it in the first available
register. */
write_register (argreg, *(unsigned long *) val);
argreg++;
}
else if (len > REGISTER_SIZE && argreg <= ARG4_REGNUM)
else if (len > DEPRECATED_REGISTER_SIZE && argreg <= ARG4_REGNUM)
{
/* Data does not fit in register; pass it on the stack and
put its address in the first available register. */
@ -1346,21 +1346,21 @@ cris_abi_original_push_arguments (int nargs, struct value **args,
fp_data += len;
argreg++;
}
else if (len > REGISTER_SIZE)
else if (len > DEPRECATED_REGISTER_SIZE)
{
/* Data does not fit in register; put both data and
parameter on the stack. */
write_memory (fp_data, val, len);
write_memory (fp_params, (char *) (&fp_data), REGISTER_SIZE);
write_memory (fp_params, (char *) (&fp_data), DEPRECATED_REGISTER_SIZE);
fp_data += len;
fp_params += REGISTER_SIZE;
fp_params += DEPRECATED_REGISTER_SIZE;
}
else
{
/* Data fits in a register, but we are out of registers;
put the parameter on the stack. */
write_memory (fp_params, val, REGISTER_SIZE);
fp_params += REGISTER_SIZE;
write_memory (fp_params, val, DEPRECATED_REGISTER_SIZE);
fp_params += DEPRECATED_REGISTER_SIZE;
}
}
@ -1401,20 +1401,21 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
int reg_demand;
len = TYPE_LENGTH (VALUE_TYPE (args[argnum]));
reg_demand = (len / REGISTER_SIZE) + (len % REGISTER_SIZE != 0 ? 1 : 0);
reg_demand = (len / DEPRECATED_REGISTER_SIZE) + (len % DEPRECATED_REGISTER_SIZE != 0 ? 1 : 0);
/* reg_demand * REGISTER_SIZE is the amount of memory we might need to
allocate for this argument. 2 * REGISTER_SIZE is the amount of stack
space we might need to pass the argument itself (either by value or by
/* reg_demand * DEPRECATED_REGISTER_SIZE is the amount of memory
we might need to allocate for this argument. 2 *
DEPRECATED_REGISTER_SIZE is the amount of stack space we
might need to pass the argument itself (either by value or by
reference). */
stack_alloc += (reg_demand * REGISTER_SIZE + 2 * REGISTER_SIZE);
stack_alloc += (reg_demand * DEPRECATED_REGISTER_SIZE + 2 * DEPRECATED_REGISTER_SIZE);
}
sp -= stack_alloc;
/* We may over-allocate a little here, but that won't hurt anything. */
/* Initialize frame pointers. */
fp_arg = sp;
fp_mem = sp + (nargs * (2 * REGISTER_SIZE));
fp_mem = sp + (nargs * (2 * DEPRECATED_REGISTER_SIZE));
/* Now load as many as possible of the first arguments into registers,
and push the rest onto the stack. */
@ -1432,9 +1433,9 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
val = (char *) VALUE_CONTENTS (args[argnum]);
/* How may registers worth of storage do we need for this argument? */
reg_demand = (len / REGISTER_SIZE) + (len % REGISTER_SIZE != 0 ? 1 : 0);
reg_demand = (len / DEPRECATED_REGISTER_SIZE) + (len % DEPRECATED_REGISTER_SIZE != 0 ? 1 : 0);
if (len <= (2 * REGISTER_SIZE)
if (len <= (2 * DEPRECATED_REGISTER_SIZE)
&& (argreg + reg_demand - 1 <= ARG4_REGNUM))
{
/* Data passed by value. Fits in available register(s). */
@ -1442,10 +1443,10 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
{
write_register (argreg, *(unsigned long *) val);
argreg++;
val += REGISTER_SIZE;
val += DEPRECATED_REGISTER_SIZE;
}
}
else if (len <= (2 * REGISTER_SIZE) && argreg <= ARG4_REGNUM)
else if (len <= (2 * DEPRECATED_REGISTER_SIZE) && argreg <= ARG4_REGNUM)
{
/* Data passed by value. Does not fit in available register(s).
Use the register(s) first, then the stack. */
@ -1455,28 +1456,29 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
{
write_register (argreg, *(unsigned long *) val);
argreg++;
val += REGISTER_SIZE;
val += DEPRECATED_REGISTER_SIZE;
}
else
{
/* I guess this memory write could write the remaining data
all at once instead of in REGISTER_SIZE chunks. */
write_memory (fp_arg, val, REGISTER_SIZE);
fp_arg += REGISTER_SIZE;
val += REGISTER_SIZE;
/* I guess this memory write could write the
remaining data all at once instead of in
DEPRECATED_REGISTER_SIZE chunks. */
write_memory (fp_arg, val, DEPRECATED_REGISTER_SIZE);
fp_arg += DEPRECATED_REGISTER_SIZE;
val += DEPRECATED_REGISTER_SIZE;
}
}
}
else if (len > (2 * REGISTER_SIZE))
else if (len > (2 * DEPRECATED_REGISTER_SIZE))
{
/* Data passed by reference. Put it on the stack. */
write_memory (fp_mem, val, len);
write_memory (fp_arg, (char *) (&fp_mem), REGISTER_SIZE);
write_memory (fp_arg, (char *) (&fp_mem), DEPRECATED_REGISTER_SIZE);
/* fp_mem need not be word-aligned since it's just a chunk of
memory being pointed at. That is, += len would do. */
fp_mem += reg_demand * REGISTER_SIZE;
fp_arg += REGISTER_SIZE;
fp_mem += reg_demand * DEPRECATED_REGISTER_SIZE;
fp_arg += DEPRECATED_REGISTER_SIZE;
}
else
{
@ -1486,7 +1488,7 @@ cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
/* fp_arg must be word-aligned (i.e., don't += len) to match
the function prologue. */
fp_arg += reg_demand * REGISTER_SIZE;
fp_arg += reg_demand * DEPRECATED_REGISTER_SIZE;
}
}
@ -4189,7 +4191,7 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
/* Length of ordinary registers used in push_word and a few other places.
REGISTER_RAW_SIZE is the real way to know how big a register is. */
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_deprecated_register_size (gdbarch, 4);
/* NEW */
set_gdbarch_register_bytes_ok (gdbarch, cris_register_bytes_ok);
@ -4260,8 +4262,8 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
/* Defined to 1 to indicate that the target supports inferior function
calls. */
set_gdbarch_call_dummy_words (gdbarch, 0);
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_deprecated_call_dummy_words (gdbarch, 0);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register);

7
gdb/doc/ChangeLog
View File

@ -1,3 +1,10 @@
2003-05-05 Andrew Cagney <cagney@redhat.com>
* gdbint.texinfo (Target Architecture Definition): Make
CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS, CALL_DUMMY_LENGTH,
FIX_CALL_DUMMY, CALL_DUMMY_BREAKPOINT_OFFSET and
CALL_DUMMY_BREAKPOINT_OFFSET deprecated.
2003-05-04 Andrew Cagney <cagney@redhat.com>
* gdb.texinfo (GDB/MI Symbol Query): Use @{ and @}.

28
gdb/doc/gdbint.texinfo
View File

@ -3085,8 +3085,8 @@ custom breakpoint insertion and removal routines if
@code{BREAKPOINT_FROM_PC} needs to read the target's memory for some
reason.
@item CALL_DUMMY_WORDS
@findex CALL_DUMMY_WORDS
@item DEPRECATED_CALL_DUMMY_WORDS
@findex DEPRECATED_CALL_DUMMY_WORDS
Pointer to an array of @code{LONGEST} words of data containing
host-byte-ordered @code{REGISTER_BYTES} sized values that partially
specify the sequence of instructions needed for an inferior function
@ -3098,17 +3098,18 @@ data.
This method has been replaced by @code{push_dummy_code}
(@pxref{push_dummy_code}).
@item SIZEOF_CALL_DUMMY_WORDS
@findex SIZEOF_CALL_DUMMY_WORDS
The size of @code{CALL_DUMMY_WORDS}. This must return a positive value.
See also @code{CALL_DUMMY_LENGTH}.
@item DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
@findex DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
The size of @code{DEPRECATED_CALL_DUMMY_WORDS}. This must return a
positive value. See also @code{DEPRECATED_CALL_DUMMY_LENGTH}.
This method has been replaced by @code{push_dummy_code}
(@pxref{push_dummy_code}).
@item CALL_DUMMY
@findex CALL_DUMMY
A static initializer for @code{CALL_DUMMY_WORDS}. Deprecated.
A static initializer for @code{DEPRECATED_CALL_DUMMY_WORDS}.
Deprecated.
This method has been replaced by @code{push_dummy_code}
(@pxref{push_dummy_code}).
@ -3721,7 +3722,7 @@ This method replaces @code{DEPRECATED_PUSH_ARGUMENTS}.
@item CORE_ADDR push_dummy_code (@var{gdbarch}, @var{sp}, @var{funaddr}, @var{using_gcc}, @var{args}, @var{nargs}, @var{value_type}, @var{real_pc}, @var{bp_addr})
@findex push_dummy_code
@findex FIX_CALL_DUMMY
@findex DEPRECATED_FIX_CALL_DUMMY
@anchor{push_dummy_code} Given a stack based call dummy, push the
instruction sequence (including space for a breakpoint) to which the
called function should return.
@ -3734,11 +3735,12 @@ By default, the stack is grown sufficient to hold a frame-aligned
(@pxref{frame_align}) breakpoint, @var{bp_addr} is set to the address
reserved for that breakpoint, and @var{real_pc} set to @var{funaddr}.
This method replaces @code{CALL_DUMMY_WORDS},
@code{SIZEOF_CALL_DUMMY_WORDS}, @code{CALL_DUMMY},
@code{CALL_DUMMY_LOCATION}, @code{REGISTER_SIZE},
@code{GDB_TARGET_IS_HPPA}, @code{CALL_DUMMY_BREAKPOINT_OFFSET}, and
@code{FIX_CALL_DUMMY}.
This method replaces @code{DEPRECATED_CALL_DUMMY_WORDS},
@code{DEPRECATED_SIZEOF_CALL_DUMMY_WORDS}, @code{CALL_DUMMY},
@code{CALL_DUMMY_LOCATION}, @code{DEPRECATED_REGISTER_SIZE},
@code{GDB_TARGET_IS_HPPA},
@code{DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET}, and
@code{DEPRECATED_FIX_CALL_DUMMY}.
@item DEPRECATED_PUSH_DUMMY_FRAME
@findex DEPRECATED_PUSH_DUMMY_FRAME

5
gdb/dummy-frame.c
View File

@ -149,8 +149,9 @@ generic_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp)
figure out what the real PC (as in the resume address) is BEFORE
calling this function (Oh, and I'm not even sure that this function
is called with an decremented PC, the call to pc_in_call_dummy() in
that file is conditional on !CALL_DUMMY_BREAKPOINT_OFFSET_P yet
generic dummy targets set CALL_DUMMY_BREAKPOINT_OFFSET. True?). */
that file is conditional on
!DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET_P yet generic dummy
targets set DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET. True?). */
int
pc_in_dummy_frame (CORE_ADDR pc)

11
gdb/dummy-frame.h
View File

@ -37,12 +37,13 @@ struct frame_id;
generic enough to be used by many targets.
The cheapest and most generic way to do CALL_DUMMY on a new target
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 DEPRECATED_FRAME_CHAIN_VALID as
is probably to define CALL_DUMMY to be empty,
DEPRECATED_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 DEPRECATED_FRAME_CHAIN_VALID as
generic_{file,func}_frame_chain_valid and do not set
FIX_CALL_DUMMY. */
DEPRECATED_FIX_CALL_DUMMY. */
/* If the PC falls in a dummy frame, return a dummy frame
unwinder. */

6
gdb/frv-tdep.c
View File

@ -1057,7 +1057,7 @@ frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_pc_regnum (gdbarch, pc_regnum);
set_gdbarch_register_name (gdbarch, frv_register_name);
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_deprecated_register_size (gdbarch, 4);
set_gdbarch_register_bytes (gdbarch, frv_num_regs * 4);
set_gdbarch_register_byte (gdbarch, frv_register_byte);
set_gdbarch_register_raw_size (gdbarch, frv_register_raw_size);
@ -1092,8 +1092,8 @@ frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_push_return_address (gdbarch, frv_push_return_address);
set_gdbarch_deprecated_pop_frame (gdbarch, frv_pop_frame);
set_gdbarch_call_dummy_words (gdbarch, frv_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (frv_call_dummy_words));
set_gdbarch_deprecated_call_dummy_words (gdbarch, frv_call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (frv_call_dummy_words));
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, frv_init_extra_frame_info);
/* Settings that should be unnecessary. */

262
gdb/gdbarch.c
View File

@ -167,7 +167,7 @@ struct gdbarch
gdbarch_sdb_reg_to_regnum_ftype *sdb_reg_to_regnum;
gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum;
gdbarch_register_name_ftype *register_name;
int register_size;
int deprecated_register_size;
int register_bytes;
gdbarch_register_byte_ftype *register_byte;
gdbarch_register_raw_size_ftype *register_raw_size;
@ -188,14 +188,14 @@ struct gdbarch
int deprecated_use_generic_dummy_frames;
int call_dummy_location;
gdbarch_call_dummy_address_ftype *call_dummy_address;
CORE_ADDR call_dummy_start_offset;
CORE_ADDR call_dummy_breakpoint_offset;
int call_dummy_length;
CORE_ADDR deprecated_call_dummy_start_offset;
CORE_ADDR deprecated_call_dummy_breakpoint_offset;
int deprecated_call_dummy_length;
gdbarch_deprecated_pc_in_call_dummy_ftype *deprecated_pc_in_call_dummy;
LONGEST * call_dummy_words;
int sizeof_call_dummy_words;
LONGEST * deprecated_call_dummy_words;
int deprecated_sizeof_call_dummy_words;
int deprecated_call_dummy_stack_adjust;
gdbarch_fix_call_dummy_ftype *fix_call_dummy;
gdbarch_deprecated_fix_call_dummy_ftype *deprecated_fix_call_dummy;
gdbarch_push_dummy_code_ftype *push_dummy_code;
gdbarch_deprecated_init_frame_pc_first_ftype *deprecated_init_frame_pc_first;
gdbarch_deprecated_init_frame_pc_ftype *deprecated_init_frame_pc;
@ -527,8 +527,8 @@ gdbarch_alloc (const struct gdbarch_info *info,
current_gdbarch->call_dummy_location = AT_ENTRY_POINT;
current_gdbarch->call_dummy_address = entry_point_address;
current_gdbarch->deprecated_pc_in_call_dummy = generic_pc_in_call_dummy;
current_gdbarch->call_dummy_words = legacy_call_dummy_words;
current_gdbarch->sizeof_call_dummy_words = legacy_sizeof_call_dummy_words;
current_gdbarch->deprecated_call_dummy_words = legacy_call_dummy_words;
current_gdbarch->deprecated_sizeof_call_dummy_words = legacy_sizeof_call_dummy_words;
current_gdbarch->register_convertible = generic_register_convertible_not;
current_gdbarch->convert_register_p = legacy_convert_register_p;
current_gdbarch->register_to_value = legacy_register_to_value;
@ -663,10 +663,10 @@ verify_gdbarch (struct gdbarch *gdbarch)
/* Skip verify of call_dummy_location, invalid_p == 0 */
/* Skip verify of call_dummy_address, invalid_p == 0 */
/* Skip verify of deprecated_pc_in_call_dummy, has predicate */
/* Skip verify of call_dummy_words, invalid_p == 0 */
/* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
/* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */
/* Skip verify of deprecated_sizeof_call_dummy_words, invalid_p == 0 */
/* Skip verify of deprecated_call_dummy_stack_adjust, has predicate */
/* Skip verify of fix_call_dummy, has predicate */
/* Skip verify of deprecated_fix_call_dummy, has predicate */
/* Skip verify of push_dummy_code, has predicate */
/* Skip verify of deprecated_init_frame_pc_first, has predicate */
/* Skip verify of deprecated_init_frame_pc, has predicate */
@ -916,22 +916,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
(long) current_gdbarch->call_dummy_address
/*CALL_DUMMY_ADDRESS ()*/);
#endif
#ifdef CALL_DUMMY_BREAKPOINT_OFFSET
fprintf_unfiltered (file,
"gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
XSTRING (CALL_DUMMY_BREAKPOINT_OFFSET));
fprintf_unfiltered (file,
"gdbarch_dump: CALL_DUMMY_BREAKPOINT_OFFSET = %ld\n",
(long) CALL_DUMMY_BREAKPOINT_OFFSET);
#endif
#ifdef CALL_DUMMY_LENGTH
fprintf_unfiltered (file,
"gdbarch_dump: CALL_DUMMY_LENGTH # %s\n",
XSTRING (CALL_DUMMY_LENGTH));
fprintf_unfiltered (file,
"gdbarch_dump: CALL_DUMMY_LENGTH = %d\n",
CALL_DUMMY_LENGTH);
#endif
#ifdef CALL_DUMMY_LOCATION
fprintf_unfiltered (file,
"gdbarch_dump: CALL_DUMMY_LOCATION # %s\n",
@ -940,22 +924,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
"gdbarch_dump: CALL_DUMMY_LOCATION = %d\n",
CALL_DUMMY_LOCATION);
#endif
#ifdef CALL_DUMMY_START_OFFSET
fprintf_unfiltered (file,
"gdbarch_dump: CALL_DUMMY_START_OFFSET # %s\n",
XSTRING (CALL_DUMMY_START_OFFSET));
fprintf_unfiltered (file,
"gdbarch_dump: CALL_DUMMY_START_OFFSET = %ld\n",
(long) CALL_DUMMY_START_OFFSET);
#endif
#ifdef CALL_DUMMY_WORDS
fprintf_unfiltered (file,
"gdbarch_dump: CALL_DUMMY_WORDS # %s\n",
XSTRING (CALL_DUMMY_WORDS));
fprintf_unfiltered (file,
"gdbarch_dump: CALL_DUMMY_WORDS = 0x%08lx\n",
(long) CALL_DUMMY_WORDS);
#endif
#ifdef CANNOT_FETCH_REGISTER
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
@ -1034,6 +1002,22 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
"gdbarch_dump: DECR_PC_AFTER_BREAK = %ld\n",
(long) DECR_PC_AFTER_BREAK);
#endif
#ifdef DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET # %s\n",
XSTRING (DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET));
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET = %ld\n",
(long) DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET);
#endif
#ifdef DEPRECATED_CALL_DUMMY_LENGTH
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_CALL_DUMMY_LENGTH # %s\n",
XSTRING (DEPRECATED_CALL_DUMMY_LENGTH));
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_CALL_DUMMY_LENGTH = %d\n",
DEPRECATED_CALL_DUMMY_LENGTH);
#endif
#ifdef DEPRECATED_CALL_DUMMY_STACK_ADJUST_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
@ -1051,6 +1035,22 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
"gdbarch_dump: DEPRECATED_CALL_DUMMY_STACK_ADJUST = %d\n",
DEPRECATED_CALL_DUMMY_STACK_ADJUST);
#endif
#ifdef DEPRECATED_CALL_DUMMY_START_OFFSET
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_CALL_DUMMY_START_OFFSET # %s\n",
XSTRING (DEPRECATED_CALL_DUMMY_START_OFFSET));
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_CALL_DUMMY_START_OFFSET = %ld\n",
(long) DEPRECATED_CALL_DUMMY_START_OFFSET);
#endif
#ifdef DEPRECATED_CALL_DUMMY_WORDS
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_CALL_DUMMY_WORDS # %s\n",
XSTRING (DEPRECATED_CALL_DUMMY_WORDS));
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_CALL_DUMMY_WORDS = 0x%08lx\n",
(long) DEPRECATED_CALL_DUMMY_WORDS);
#endif
#ifdef DEPRECATED_DO_REGISTERS_INFO_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
@ -1139,6 +1139,29 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
"gdbarch_dump: DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED = %d\n",
DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED);
#endif
#ifdef DEPRECATED_FIX_CALL_DUMMY_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
"DEPRECATED_FIX_CALL_DUMMY_P()",
XSTRING (DEPRECATED_FIX_CALL_DUMMY_P ()));
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_FIX_CALL_DUMMY_P() = %d\n",
DEPRECATED_FIX_CALL_DUMMY_P ());
#endif
#ifdef DEPRECATED_FIX_CALL_DUMMY
#if GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
"DEPRECATED_FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
XSTRING (DEPRECATED_FIX_CALL_DUMMY (dummy, pc, fun, nargs, args, type, gcc_p)));
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_FIX_CALL_DUMMY = <0x%08lx>\n",
(long) current_gdbarch->deprecated_fix_call_dummy
/*DEPRECATED_FIX_CALL_DUMMY ()*/);
#endif
#ifdef DEPRECATED_FP_REGNUM
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_FP_REGNUM # %s\n",
@ -1456,6 +1479,14 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
(long) current_gdbarch->deprecated_push_return_address
/*DEPRECATED_PUSH_RETURN_ADDRESS ()*/);
#endif
#ifdef DEPRECATED_REGISTER_SIZE
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_REGISTER_SIZE # %s\n",
XSTRING (DEPRECATED_REGISTER_SIZE));
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_REGISTER_SIZE = %d\n",
DEPRECATED_REGISTER_SIZE);
#endif
#ifdef DEPRECATED_SAVED_PC_AFTER_CALL_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
@ -1476,6 +1507,14 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
(long) current_gdbarch->deprecated_saved_pc_after_call
/*DEPRECATED_SAVED_PC_AFTER_CALL ()*/);
#endif
#ifdef DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS # %s\n",
XSTRING (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS));
fprintf_unfiltered (file,
"gdbarch_dump: DEPRECATED_SIZEOF_CALL_DUMMY_WORDS = %d\n",
DEPRECATED_SIZEOF_CALL_DUMMY_WORDS);
#endif
#ifdef DEPRECATED_STORE_RETURN_VALUE
#if GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
@ -1645,29 +1684,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
(long) current_gdbarch->extract_struct_value_address
/*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
#endif
#ifdef FIX_CALL_DUMMY_P
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
"FIX_CALL_DUMMY_P()",
XSTRING (FIX_CALL_DUMMY_P ()));
fprintf_unfiltered (file,
"gdbarch_dump: FIX_CALL_DUMMY_P() = %d\n",
FIX_CALL_DUMMY_P ());
#endif
#ifdef FIX_CALL_DUMMY
#if GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
"FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)",
XSTRING (FIX_CALL_DUMMY (dummy, pc, fun, nargs, args, type, gcc_p)));
#endif
if (GDB_MULTI_ARCH)
fprintf_unfiltered (file,
"gdbarch_dump: FIX_CALL_DUMMY = <0x%08lx>\n",
(long) current_gdbarch->fix_call_dummy
/*FIX_CALL_DUMMY ()*/);
#endif
#ifdef FP0_REGNUM
fprintf_unfiltered (file,
"gdbarch_dump: FP0_REGNUM # %s\n",
@ -2095,14 +2111,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
(long) current_gdbarch->register_sim_regno
/*REGISTER_SIM_REGNO ()*/);
#endif
#ifdef REGISTER_SIZE
fprintf_unfiltered (file,
"gdbarch_dump: REGISTER_SIZE # %s\n",
XSTRING (REGISTER_SIZE));
fprintf_unfiltered (file,
"gdbarch_dump: REGISTER_SIZE = %d\n",
REGISTER_SIZE);
#endif
#ifdef REGISTER_TO_VALUE
#if GDB_MULTI_ARCH
/* Macro might contain `[{}]' when not multi-arch */
@ -2275,14 +2283,6 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file)
(long) current_gdbarch->sigtramp_start
/*SIGTRAMP_START ()*/);
#endif
#ifdef SIZEOF_CALL_DUMMY_WORDS
fprintf_unfiltered (file,
"gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS # %s\n",
XSTRING (SIZEOF_CALL_DUMMY_WORDS));
fprintf_unfiltered (file,
"gdbarch_dump: SIZEOF_CALL_DUMMY_WORDS = %d\n",
SIZEOF_CALL_DUMMY_WORDS);
#endif
#ifdef SKIP_PROLOGUE
fprintf_unfiltered (file,
"gdbarch_dump: %s # %s\n",
@ -3295,19 +3295,19 @@ set_gdbarch_register_name (struct gdbarch *gdbarch,
}
int
gdbarch_register_size (struct gdbarch *gdbarch)
gdbarch_deprecated_register_size (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_register_size called\n");
return gdbarch->register_size;
fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_register_size called\n");
return gdbarch->deprecated_register_size;
}
void
set_gdbarch_register_size (struct gdbarch *gdbarch,
int register_size)
set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch,
int deprecated_register_size)
{
gdbarch->register_size = register_size;
gdbarch->deprecated_register_size = deprecated_register_size;
}
int
@ -3749,51 +3749,51 @@ set_gdbarch_call_dummy_address (struct gdbarch *gdbarch,
}
CORE_ADDR
gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch)
gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_start_offset called\n");
return gdbarch->call_dummy_start_offset;
fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_start_offset called\n");
return gdbarch->deprecated_call_dummy_start_offset;
}
void
set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch,
CORE_ADDR call_dummy_start_offset)
set_gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch,
CORE_ADDR deprecated_call_dummy_start_offset)
{
gdbarch->call_dummy_start_offset = call_dummy_start_offset;
gdbarch->deprecated_call_dummy_start_offset = deprecated_call_dummy_start_offset;
}
CORE_ADDR
gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch)
gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_breakpoint_offset called\n");
return gdbarch->call_dummy_breakpoint_offset;
fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_breakpoint_offset called\n");
return gdbarch->deprecated_call_dummy_breakpoint_offset;
}
void
set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
CORE_ADDR call_dummy_breakpoint_offset)
set_gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch,
CORE_ADDR deprecated_call_dummy_breakpoint_offset)
{
gdbarch->call_dummy_breakpoint_offset = call_dummy_breakpoint_offset;
gdbarch->deprecated_call_dummy_breakpoint_offset = deprecated_call_dummy_breakpoint_offset;
}
int
gdbarch_call_dummy_length (struct gdbarch *gdbarch)
gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_length called\n");
return gdbarch->call_dummy_length;
fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_length called\n");
return gdbarch->deprecated_call_dummy_length;
}
void
set_gdbarch_call_dummy_length (struct gdbarch *gdbarch,
int call_dummy_length)
set_gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch,
int deprecated_call_dummy_length)
{
gdbarch->call_dummy_length = call_dummy_length;
gdbarch->deprecated_call_dummy_length = deprecated_call_dummy_length;
}
int
@ -3824,37 +3824,37 @@ set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch,
}
LONGEST *
gdbarch_call_dummy_words (struct gdbarch *gdbarch)
gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of call_dummy_words, invalid_p == 0 */
/* Skip verify of deprecated_call_dummy_words, invalid_p == 0 */
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_call_dummy_words called\n");
return gdbarch->call_dummy_words;
fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_call_dummy_words called\n");
return gdbarch->deprecated_call_dummy_words;
}
void
set_gdbarch_call_dummy_words (struct gdbarch *gdbarch,
LONGEST * call_dummy_words)
set_gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch,
LONGEST * deprecated_call_dummy_words)
{
gdbarch->call_dummy_words = call_dummy_words;
gdbarch->deprecated_call_dummy_words = deprecated_call_dummy_words;
}
int
gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch)
gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
/* Skip verify of sizeof_call_dummy_words, invalid_p == 0 */
/* Skip verify of deprecated_sizeof_call_dummy_words, invalid_p == 0 */
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_sizeof_call_dummy_words called\n");
return gdbarch->sizeof_call_dummy_words;
fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_sizeof_call_dummy_words called\n");
return gdbarch->deprecated_sizeof_call_dummy_words;
}
void
set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch,
int sizeof_call_dummy_words)
set_gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch,
int deprecated_sizeof_call_dummy_words)
{
gdbarch->sizeof_call_dummy_words = sizeof_call_dummy_words;
gdbarch->deprecated_sizeof_call_dummy_words = deprecated_sizeof_call_dummy_words;
}
int
@ -3881,29 +3881,29 @@ set_gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdbarch,
}
int
gdbarch_fix_call_dummy_p (struct gdbarch *gdbarch)
gdbarch_deprecated_fix_call_dummy_p (struct gdbarch *gdbarch)
{
gdb_assert (gdbarch != NULL);
return gdbarch->fix_call_dummy != 0;
return gdbarch->deprecated_fix_call_dummy != 0;
}
void
gdbarch_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p)
gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p)
{
gdb_assert (gdbarch != NULL);
if (gdbarch->fix_call_dummy == 0)
if (gdbarch->deprecated_fix_call_dummy == 0)
internal_error (__FILE__, __LINE__,
"gdbarch: gdbarch_fix_call_dummy invalid");
"gdbarch: gdbarch_deprecated_fix_call_dummy invalid");
if (gdbarch_debug >= 2)
fprintf_unfiltered (gdb_stdlog, "gdbarch_fix_call_dummy called\n");
gdbarch->fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p);
fprintf_unfiltered (gdb_stdlog, "gdbarch_deprecated_fix_call_dummy called\n");
gdbarch->deprecated_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p);
}
void
set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch,
gdbarch_fix_call_dummy_ftype fix_call_dummy)
set_gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch,
gdbarch_deprecated_fix_call_dummy_ftype deprecated_fix_call_dummy)
{
gdbarch->fix_call_dummy = fix_call_dummy;
gdbarch->deprecated_fix_call_dummy = deprecated_fix_call_dummy;
}
int

122
gdb/gdbarch.h
View File

@ -721,13 +721,13 @@ extern void set_gdbarch_register_name (struct gdbarch *gdbarch, gdbarch_register
#endif
#endif
extern int gdbarch_register_size (struct gdbarch *gdbarch);
extern void set_gdbarch_register_size (struct gdbarch *gdbarch, int register_size);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_SIZE)
#error "Non multi-arch definition of REGISTER_SIZE"
extern int gdbarch_deprecated_register_size (struct gdbarch *gdbarch);
extern void set_gdbarch_deprecated_register_size (struct gdbarch *gdbarch, int deprecated_register_size);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_REGISTER_SIZE)
#error "Non multi-arch definition of DEPRECATED_REGISTER_SIZE"
#endif
#if !defined (REGISTER_SIZE)
#define REGISTER_SIZE (gdbarch_register_size (current_gdbarch))
#if !defined (DEPRECATED_REGISTER_SIZE)
#define DEPRECATED_REGISTER_SIZE (gdbarch_deprecated_register_size (current_gdbarch))
#endif
extern int gdbarch_register_bytes (struct gdbarch *gdbarch);
@ -1198,35 +1198,35 @@ extern void set_gdbarch_call_dummy_address (struct gdbarch *gdbarch, gdbarch_cal
/* Replaced by push_dummy_code. */
extern CORE_ADDR gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch);
extern void set_gdbarch_call_dummy_start_offset (struct gdbarch *gdbarch, CORE_ADDR call_dummy_start_offset);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_START_OFFSET)
#error "Non multi-arch definition of CALL_DUMMY_START_OFFSET"
extern CORE_ADDR gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch);
extern void set_gdbarch_deprecated_call_dummy_start_offset (struct gdbarch *gdbarch, CORE_ADDR deprecated_call_dummy_start_offset);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_CALL_DUMMY_START_OFFSET)
#error "Non multi-arch definition of DEPRECATED_CALL_DUMMY_START_OFFSET"
#endif
#if !defined (CALL_DUMMY_START_OFFSET)
#define CALL_DUMMY_START_OFFSET (gdbarch_call_dummy_start_offset (current_gdbarch))
#if !defined (DEPRECATED_CALL_DUMMY_START_OFFSET)
#define DEPRECATED_CALL_DUMMY_START_OFFSET (gdbarch_deprecated_call_dummy_start_offset (current_gdbarch))
#endif
/* Replaced by push_dummy_code. */
extern CORE_ADDR gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch);
extern void set_gdbarch_call_dummy_breakpoint_offset (struct gdbarch *gdbarch, CORE_ADDR call_dummy_breakpoint_offset);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_BREAKPOINT_OFFSET)
#error "Non multi-arch definition of CALL_DUMMY_BREAKPOINT_OFFSET"
extern CORE_ADDR gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch);
extern void set_gdbarch_deprecated_call_dummy_breakpoint_offset (struct gdbarch *gdbarch, CORE_ADDR deprecated_call_dummy_breakpoint_offset);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET)
#error "Non multi-arch definition of DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET"
#endif
#if !defined (CALL_DUMMY_BREAKPOINT_OFFSET)
#define CALL_DUMMY_BREAKPOINT_OFFSET (gdbarch_call_dummy_breakpoint_offset (current_gdbarch))
#if !defined (DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET)
#define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET (gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch))
#endif
/* Replaced by push_dummy_code. */
extern int gdbarch_call_dummy_length (struct gdbarch *gdbarch);
extern void set_gdbarch_call_dummy_length (struct gdbarch *gdbarch, int call_dummy_length);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_LENGTH)
#error "Non multi-arch definition of CALL_DUMMY_LENGTH"
extern int gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch);
extern void set_gdbarch_deprecated_call_dummy_length (struct gdbarch *gdbarch, int deprecated_call_dummy_length);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_CALL_DUMMY_LENGTH)
#error "Non multi-arch definition of DEPRECATED_CALL_DUMMY_LENGTH"
#endif
#if !defined (CALL_DUMMY_LENGTH)
#define CALL_DUMMY_LENGTH (gdbarch_call_dummy_length (current_gdbarch))
#if !defined (DEPRECATED_CALL_DUMMY_LENGTH)
#define DEPRECATED_CALL_DUMMY_LENGTH (gdbarch_deprecated_call_dummy_length (current_gdbarch))
#endif
/* NOTE: cagney/2002-11-24: This function with predicate has a valid
@ -1275,33 +1275,33 @@ extern void set_gdbarch_deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, gd
/* Replaced by push_dummy_code. */
/* Default (value) for non- multi-arch platforms. */
#if (!GDB_MULTI_ARCH) && !defined (CALL_DUMMY_WORDS)
#define CALL_DUMMY_WORDS (legacy_call_dummy_words)
#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_CALL_DUMMY_WORDS)
#define DEPRECATED_CALL_DUMMY_WORDS (legacy_call_dummy_words)
#endif
extern LONGEST * gdbarch_call_dummy_words (struct gdbarch *gdbarch);
extern void set_gdbarch_call_dummy_words (struct gdbarch *gdbarch, LONGEST * call_dummy_words);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (CALL_DUMMY_WORDS)
#error "Non multi-arch definition of CALL_DUMMY_WORDS"
extern LONGEST * gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch);
extern void set_gdbarch_deprecated_call_dummy_words (struct gdbarch *gdbarch, LONGEST * deprecated_call_dummy_words);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_CALL_DUMMY_WORDS)
#error "Non multi-arch definition of DEPRECATED_CALL_DUMMY_WORDS"
#endif
#if !defined (CALL_DUMMY_WORDS)
#define CALL_DUMMY_WORDS (gdbarch_call_dummy_words (current_gdbarch))
#if !defined (DEPRECATED_CALL_DUMMY_WORDS)
#define DEPRECATED_CALL_DUMMY_WORDS (gdbarch_deprecated_call_dummy_words (current_gdbarch))
#endif
/* Replaced by push_dummy_code. */
/* Default (value) for non- multi-arch platforms. */
#if (!GDB_MULTI_ARCH) && !defined (SIZEOF_CALL_DUMMY_WORDS)
#define SIZEOF_CALL_DUMMY_WORDS (legacy_sizeof_call_dummy_words)
#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS)
#define DEPRECATED_SIZEOF_CALL_DUMMY_WORDS (legacy_sizeof_call_dummy_words)
#endif
extern int gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch);
extern void set_gdbarch_sizeof_call_dummy_words (struct gdbarch *gdbarch, int sizeof_call_dummy_words);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (SIZEOF_CALL_DUMMY_WORDS)
#error "Non multi-arch definition of SIZEOF_CALL_DUMMY_WORDS"
extern int gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch);
extern void set_gdbarch_deprecated_sizeof_call_dummy_words (struct gdbarch *gdbarch, int deprecated_sizeof_call_dummy_words);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS)
#error "Non multi-arch definition of DEPRECATED_SIZEOF_CALL_DUMMY_WORDS"
#endif
#if !defined (SIZEOF_CALL_DUMMY_WORDS)
#define SIZEOF_CALL_DUMMY_WORDS (gdbarch_sizeof_call_dummy_words (current_gdbarch))
#if !defined (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS)
#define DEPRECATED_SIZEOF_CALL_DUMMY_WORDS (gdbarch_deprecated_sizeof_call_dummy_words (current_gdbarch))
#endif
/* Replaced by push_dummy_code. */
@ -1344,44 +1344,44 @@ extern void set_gdbarch_deprecated_call_dummy_stack_adjust (struct gdbarch *gdba
/* Replaced by push_dummy_code. */
#if defined (FIX_CALL_DUMMY)
/* Legacy for systems yet to multi-arch FIX_CALL_DUMMY */
#if !defined (FIX_CALL_DUMMY_P)
#define FIX_CALL_DUMMY_P() (1)
#if defined (DEPRECATED_FIX_CALL_DUMMY)
/* Legacy for systems yet to multi-arch DEPRECATED_FIX_CALL_DUMMY */
#if !defined (DEPRECATED_FIX_CALL_DUMMY_P)
#define DEPRECATED_FIX_CALL_DUMMY_P() (1)
#endif
#endif
/* Default predicate for non- multi-arch targets. */
#if (!GDB_MULTI_ARCH) && !defined (FIX_CALL_DUMMY_P)
#define FIX_CALL_DUMMY_P() (0)
#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_FIX_CALL_DUMMY_P)
#define DEPRECATED_FIX_CALL_DUMMY_P() (0)
#endif
extern int gdbarch_fix_call_dummy_p (struct gdbarch *gdbarch);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FIX_CALL_DUMMY_P)
#error "Non multi-arch definition of FIX_CALL_DUMMY"
extern int gdbarch_deprecated_fix_call_dummy_p (struct gdbarch *gdbarch);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_FIX_CALL_DUMMY_P)
#error "Non multi-arch definition of DEPRECATED_FIX_CALL_DUMMY"
#endif
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FIX_CALL_DUMMY_P)
#define FIX_CALL_DUMMY_P() (gdbarch_fix_call_dummy_p (current_gdbarch))
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_FIX_CALL_DUMMY_P)
#define DEPRECATED_FIX_CALL_DUMMY_P() (gdbarch_deprecated_fix_call_dummy_p (current_gdbarch))
#endif
/* Default (function) for non- multi-arch platforms. */
#if (!GDB_MULTI_ARCH) && !defined (FIX_CALL_DUMMY)
#define FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p) (internal_error (__FILE__, __LINE__, "FIX_CALL_DUMMY"), 0)
#if (!GDB_MULTI_ARCH) && !defined (DEPRECATED_FIX_CALL_DUMMY)
#define DEPRECATED_FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p) (internal_error (__FILE__, __LINE__, "DEPRECATED_FIX_CALL_DUMMY"), 0)
#endif
typedef void (gdbarch_fix_call_dummy_ftype) (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p);
extern void gdbarch_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p);
extern void set_gdbarch_fix_call_dummy (struct gdbarch *gdbarch, gdbarch_fix_call_dummy_ftype *fix_call_dummy);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (FIX_CALL_DUMMY)
#error "Non multi-arch definition of FIX_CALL_DUMMY"
typedef void (gdbarch_deprecated_fix_call_dummy_ftype) (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p);
extern void gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p);
extern void set_gdbarch_deprecated_fix_call_dummy (struct gdbarch *gdbarch, gdbarch_deprecated_fix_call_dummy_ftype *deprecated_fix_call_dummy);
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (DEPRECATED_FIX_CALL_DUMMY)
#error "Non multi-arch definition of DEPRECATED_FIX_CALL_DUMMY"
#endif
#if GDB_MULTI_ARCH
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (FIX_CALL_DUMMY)
#define FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p) (gdbarch_fix_call_dummy (current_gdbarch, dummy, pc, fun, nargs, args, type, gcc_p))
#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (DEPRECATED_FIX_CALL_DUMMY)
#define DEPRECATED_FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p) (gdbarch_deprecated_fix_call_dummy (current_gdbarch, dummy, pc, fun, nargs, args, type, gcc_p))
#endif
#endif
/* This is a replacement for FIX_CALL_DUMMY et.al. */
/* This is a replacement for DEPRECATED_FIX_CALL_DUMMY et.al. */
extern int gdbarch_push_dummy_code_p (struct gdbarch *gdbarch);

16
gdb/gdbarch.sh
View File

@ -472,7 +472,7 @@ f:2:DWARF_REG_TO_REGNUM:int:dwarf_reg_to_regnum:int dwarf_regnr:dwarf_regnr:::no
f:2:SDB_REG_TO_REGNUM:int:sdb_reg_to_regnum:int sdb_regnr:sdb_regnr:::no_op_reg_to_regnum::0
f:2:DWARF2_REG_TO_REGNUM:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr:::no_op_reg_to_regnum::0
f:2:REGISTER_NAME:const char *:register_name:int regnr:regnr:::legacy_register_name::0
v::REGISTER_SIZE:int:register_size
v::DEPRECATED_REGISTER_SIZE:int:deprecated_register_size
v::REGISTER_BYTES:int:register_bytes
# NOTE: cagney/2002-05-02: This function with predicate has a valid
# (callable) initial value. As a consequence, even when the predicate
@ -533,11 +533,11 @@ v::CALL_DUMMY_LOCATION:int:call_dummy_location:::::AT_ENTRY_POINT::0
# Replaced by push_dummy_code.
f::CALL_DUMMY_ADDRESS:CORE_ADDR:call_dummy_address:void::::entry_point_address::0
# Replaced by push_dummy_code.
v::CALL_DUMMY_START_OFFSET:CORE_ADDR:call_dummy_start_offset
v::DEPRECATED_CALL_DUMMY_START_OFFSET:CORE_ADDR:deprecated_call_dummy_start_offset
# Replaced by push_dummy_code.
v::CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:call_dummy_breakpoint_offset
v::DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET:CORE_ADDR:deprecated_call_dummy_breakpoint_offset
# Replaced by push_dummy_code.
v::CALL_DUMMY_LENGTH:int:call_dummy_length
v::DEPRECATED_CALL_DUMMY_LENGTH:int:deprecated_call_dummy_length
# NOTE: cagney/2002-11-24: This function with predicate has a valid
# (callable) initial value. As a consequence, even when the predicate
# is false, the corresponding function works. This simplifies the
@ -545,14 +545,14 @@ v::CALL_DUMMY_LENGTH:int:call_dummy_length
# doesn't need to be modified.
F::DEPRECATED_PC_IN_CALL_DUMMY:int:deprecated_pc_in_call_dummy:CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address:pc, sp, frame_address::generic_pc_in_call_dummy:generic_pc_in_call_dummy
# Replaced by push_dummy_code.
v::CALL_DUMMY_WORDS:LONGEST *:call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
v::DEPRECATED_CALL_DUMMY_WORDS:LONGEST *:deprecated_call_dummy_words::::0:legacy_call_dummy_words::0:0x%08lx
# Replaced by push_dummy_code.
v::SIZEOF_CALL_DUMMY_WORDS:int:sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0
v::DEPRECATED_SIZEOF_CALL_DUMMY_WORDS:int:deprecated_sizeof_call_dummy_words::::0:legacy_sizeof_call_dummy_words::0
# Replaced by push_dummy_code.
V:2:DEPRECATED_CALL_DUMMY_STACK_ADJUST:int:deprecated_call_dummy_stack_adjust::::0
# Replaced by push_dummy_code.
F::FIX_CALL_DUMMY:void:fix_call_dummy:char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p:dummy, pc, fun, nargs, args, type, gcc_p
# This is a replacement for FIX_CALL_DUMMY et.al.
F::DEPRECATED_FIX_CALL_DUMMY:void:deprecated_fix_call_dummy:char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p:dummy, pc, fun, nargs, args, type, gcc_p
# This is a replacement for DEPRECATED_FIX_CALL_DUMMY et.al.
M::PUSH_DUMMY_CODE:CORE_ADDR:push_dummy_code:CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr:sp, funaddr, using_gcc, args, nargs, value_type, real_pc, bp_addr:
F:2:DEPRECATED_INIT_FRAME_PC_FIRST:CORE_ADDR:deprecated_init_frame_pc_first:int fromleaf, struct frame_info *prev:fromleaf, prev
F:2:DEPRECATED_INIT_FRAME_PC:CORE_ADDR:deprecated_init_frame_pc:int fromleaf, struct frame_info *prev:fromleaf, prev

6
gdb/h8300-tdep.c
View File

@ -1104,7 +1104,7 @@ h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
set_gdbarch_register_name (gdbarch, h8300_register_name);
set_gdbarch_register_size (gdbarch, BINWORD);
set_gdbarch_deprecated_register_size (gdbarch, BINWORD);
set_gdbarch_register_bytes (gdbarch, E_NUM_REGS * BINWORD);
set_gdbarch_register_byte (gdbarch, h8300_register_byte);
set_gdbarch_register_raw_size (gdbarch, h8300_register_raw_size);
@ -1156,8 +1156,8 @@ h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_store_return_value (gdbarch, h8300_store_return_value);
set_gdbarch_deprecated_extract_struct_value_address (gdbarch, h8300_extract_struct_value_address);
set_gdbarch_use_struct_convention (gdbarch, h8300_use_struct_convention);
set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_breakpoint_from_pc (gdbarch, h8300_breakpoint_from_pc);
set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);

102
gdb/hppa-tdep.c
View File

@ -200,7 +200,7 @@ extern int exception_catchpoints_are_fragile;
int
hppa_use_struct_convention (int gcc_p, struct type *type)
{
return (TYPE_LENGTH (type) > 2 * REGISTER_SIZE);
return (TYPE_LENGTH (type) > 2 * DEPRECATED_REGISTER_SIZE);
}
@ -904,16 +904,16 @@ hppa_frame_saved_pc (struct frame_info *frame)
/* A call dummy is sized in words, but it is actually a
series of instructions. Account for that scaling
factor. */
+ ((REGISTER_SIZE / INSTRUCTION_SIZE)
* CALL_DUMMY_LENGTH)
+ ((DEPRECATED_REGISTER_SIZE / INSTRUCTION_SIZE)
* DEPRECATED_CALL_DUMMY_LENGTH)
/* Similarly we have to account for 64bit wide register
saves. */
+ (32 * REGISTER_SIZE)
+ (32 * DEPRECATED_REGISTER_SIZE)
/* We always consider FP regs 8 bytes long. */
+ (NUM_REGS - FP0_REGNUM) * 8
/* Similarly we have to account for 64bit wide register
saves. */
+ (6 * REGISTER_SIZE)))))
+ (6 * DEPRECATED_REGISTER_SIZE)))))
{
return read_memory_integer ((get_frame_base (frame)
+ (TARGET_PTR_BIT == 64 ? -16 : -20)),
@ -1467,24 +1467,24 @@ hppa_push_dummy_frame (void)
/* The 32bit and 64bit ABIs save the return pointer into different
stack slots. */
if (REGISTER_SIZE == 8)
write_memory (sp - 16, (char *) &int_buffer, REGISTER_SIZE);
if (DEPRECATED_REGISTER_SIZE == 8)
write_memory (sp - 16, (char *) &int_buffer, DEPRECATED_REGISTER_SIZE);
else
write_memory (sp - 20, (char *) &int_buffer, REGISTER_SIZE);
write_memory (sp - 20, (char *) &int_buffer, DEPRECATED_REGISTER_SIZE);
int_buffer = deprecated_read_fp ();
write_memory (sp, (char *) &int_buffer, REGISTER_SIZE);
write_memory (sp, (char *) &int_buffer, DEPRECATED_REGISTER_SIZE);
write_register (DEPRECATED_FP_REGNUM, sp);
sp += 2 * REGISTER_SIZE;
sp += 2 * DEPRECATED_REGISTER_SIZE;
for (regnum = 1; regnum < 32; regnum++)
if (regnum != RP_REGNUM && regnum != DEPRECATED_FP_REGNUM)
sp = push_word (sp, read_register (regnum));
/* This is not necessary for the 64bit ABI. In fact it is dangerous. */
if (REGISTER_SIZE != 8)
if (DEPRECATED_REGISTER_SIZE != 8)
sp += 4;
for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
@ -1510,37 +1510,37 @@ find_dummy_frame_regs (struct frame_info *frame,
int i;
/* The 32bit and 64bit ABIs save RP into different locations. */
if (REGISTER_SIZE == 8)
if (DEPRECATED_REGISTER_SIZE == 8)
frame_saved_regs[RP_REGNUM] = (fp - 16) & ~0x3;
else
frame_saved_regs[RP_REGNUM] = (fp - 20) & ~0x3;
frame_saved_regs[DEPRECATED_FP_REGNUM] = fp;
frame_saved_regs[1] = fp + (2 * REGISTER_SIZE);
frame_saved_regs[1] = fp + (2 * DEPRECATED_REGISTER_SIZE);
for (fp += 3 * REGISTER_SIZE, i = 3; i < 32; i++)
for (fp += 3 * DEPRECATED_REGISTER_SIZE, i = 3; i < 32; i++)
{
if (i != DEPRECATED_FP_REGNUM)
{
frame_saved_regs[i] = fp;
fp += REGISTER_SIZE;
fp += DEPRECATED_REGISTER_SIZE;
}
}
/* This is not necessary or desirable for the 64bit ABI. */
if (REGISTER_SIZE != 8)
if (DEPRECATED_REGISTER_SIZE != 8)
fp += 4;
for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8)
frame_saved_regs[i] = fp;
frame_saved_regs[IPSW_REGNUM] = fp;
frame_saved_regs[SAR_REGNUM] = fp + REGISTER_SIZE;
frame_saved_regs[PCOQ_HEAD_REGNUM] = fp + 2 * REGISTER_SIZE;
frame_saved_regs[PCSQ_HEAD_REGNUM] = fp + 3 * REGISTER_SIZE;
frame_saved_regs[PCOQ_TAIL_REGNUM] = fp + 4 * REGISTER_SIZE;
frame_saved_regs[PCSQ_TAIL_REGNUM] = fp + 5 * REGISTER_SIZE;
frame_saved_regs[SAR_REGNUM] = fp + DEPRECATED_REGISTER_SIZE;
frame_saved_regs[PCOQ_HEAD_REGNUM] = fp + 2 * DEPRECATED_REGISTER_SIZE;
frame_saved_regs[PCSQ_HEAD_REGNUM] = fp + 3 * DEPRECATED_REGISTER_SIZE;
frame_saved_regs[PCOQ_TAIL_REGNUM] = fp + 4 * DEPRECATED_REGISTER_SIZE;
frame_saved_regs[PCSQ_TAIL_REGNUM] = fp + 5 * DEPRECATED_REGISTER_SIZE;
}
void
@ -1564,7 +1564,7 @@ hppa_pop_frame (void)
for (regnum = 31; regnum > 0; regnum--)
if (fsr[regnum])
write_register (regnum, read_memory_integer (fsr[regnum],
REGISTER_SIZE));
DEPRECATED_REGISTER_SIZE));
for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM; regnum--)
if (fsr[regnum])
@ -1577,18 +1577,18 @@ hppa_pop_frame (void)
if (fsr[IPSW_REGNUM])
write_register (IPSW_REGNUM,
read_memory_integer (fsr[IPSW_REGNUM],
REGISTER_SIZE));
DEPRECATED_REGISTER_SIZE));
if (fsr[SAR_REGNUM])
write_register (SAR_REGNUM,
read_memory_integer (fsr[SAR_REGNUM],
REGISTER_SIZE));
DEPRECATED_REGISTER_SIZE));
/* If the PC was explicitly saved, then just restore it. */
if (fsr[PCOQ_TAIL_REGNUM])
{
npc = read_memory_integer (fsr[PCOQ_TAIL_REGNUM],
REGISTER_SIZE);
DEPRECATED_REGISTER_SIZE);
write_register (PCOQ_TAIL_REGNUM, npc);
}
/* Else use the value in %rp to set the new PC. */
@ -1598,7 +1598,7 @@ hppa_pop_frame (void)
write_pc (npc);
}
write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, REGISTER_SIZE));
write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, DEPRECATED_REGISTER_SIZE));
if (fsr[IPSW_REGNUM]) /* call dummy */
write_register (SP_REGNUM, fp - 48);
@ -1667,7 +1667,7 @@ restore_pc_queue (CORE_ADDR *fsr)
right place. */
write_register (21, read_memory_integer (fsr[PCSQ_HEAD_REGNUM],
REGISTER_SIZE));
DEPRECATED_REGISTER_SIZE));
write_register (22, new_pc);
for (insn_count = 0; insn_count < 3; insn_count++)
@ -1747,7 +1747,7 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
the left. We do this by promoting them to full-width,
although the ABI says to pad them with garbage. */
if (is_integral_type (arg_type)
&& TYPE_LENGTH (arg_type) < REGISTER_SIZE)
&& TYPE_LENGTH (arg_type) < DEPRECATED_REGISTER_SIZE)
{
args[i] = value_cast ((TYPE_UNSIGNED (arg_type)
? builtin_type_unsigned_long
@ -1760,7 +1760,7 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
/* Align the size of the argument to the word size for this
target. */
bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
bytes_reserved = (lengths[i] + DEPRECATED_REGISTER_SIZE - 1) & -DEPRECATED_REGISTER_SIZE;
offset[i] = cum_bytes_reserved;
@ -1772,8 +1772,8 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
if (bytes_reserved > 8)
{
/* Round up the offset to a multiple of two slots. */
int new_offset = ((offset[i] + 2*REGISTER_SIZE-1)
& -(2*REGISTER_SIZE));
int new_offset = ((offset[i] + 2*DEPRECATED_REGISTER_SIZE-1)
& -(2*DEPRECATED_REGISTER_SIZE));
/* Note the space we've wasted, if any. */
bytes_reserved += new_offset - offset[i];
@ -1860,15 +1860,15 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
/* Align the size of the argument to the word size for this
target. */
bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
bytes_reserved = (lengths[i] + DEPRECATED_REGISTER_SIZE - 1) & -DEPRECATED_REGISTER_SIZE;
offset[i] = (cum_bytes_reserved
+ (lengths[i] > 4 ? bytes_reserved : lengths[i]));
/* If the argument is a double word argument, then it needs to be
double word aligned. */
if ((bytes_reserved == 2 * REGISTER_SIZE)
&& (offset[i] % 2 * REGISTER_SIZE))
if ((bytes_reserved == 2 * DEPRECATED_REGISTER_SIZE)
&& (offset[i] % 2 * DEPRECATED_REGISTER_SIZE))
{
int new_offset = 0;
/* BYTES_RESERVED is already aligned to the word, so we put
@ -1876,13 +1876,13 @@ hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
This will leave one empty word on the stack, and one unused
register as mandated by the ABI. */
new_offset = ((offset[i] + 2 * REGISTER_SIZE - 1)
& -(2 * REGISTER_SIZE));
new_offset = ((offset[i] + 2 * DEPRECATED_REGISTER_SIZE - 1)
& -(2 * DEPRECATED_REGISTER_SIZE));
if ((new_offset - offset[i]) >= 2 * REGISTER_SIZE)
if ((new_offset - offset[i]) >= 2 * DEPRECATED_REGISTER_SIZE)
{
bytes_reserved += REGISTER_SIZE;
offset[i] += REGISTER_SIZE;
bytes_reserved += DEPRECATED_REGISTER_SIZE;
offset[i] += DEPRECATED_REGISTER_SIZE;
}
}
@ -2037,9 +2037,9 @@ cover_find_stub_with_shl_get (void *args_untyped)
into a call sequence of the above form stored at DUMMYNAME.
On the hppa we need to call the stack dummy through $$dyncall.
Therefore our version of FIX_CALL_DUMMY takes an extra argument,
real_pc, which is the location where gdb should start up the
inferior to do the function call.
Therefore our version of DEPRECATED_FIX_CALL_DUMMY takes an extra
argument, real_pc, which is the location where gdb should start up
the inferior to do the function call.
This has to work across several versions of hpux, bsd, osf1. It has to
work regardless of what compiler was used to build the inferior program.
@ -2195,7 +2195,7 @@ hppa_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
at *(fun+4). Note the call dummy is *NOT* allowed to
trash %r19 before calling the target function. */
write_register (19, read_memory_integer ((fun & ~0x3) + 4,
REGISTER_SIZE));
DEPRECATED_REGISTER_SIZE));
/* Now get the real address for the function we are calling, it's
at *fun. */
@ -3882,16 +3882,16 @@ hppa_frame_find_saved_regs (struct frame_info *frame_info,
/* A call dummy is sized in words, but it is actually a
series of instructions. Account for that scaling
factor. */
+ ((REGISTER_SIZE / INSTRUCTION_SIZE)
* CALL_DUMMY_LENGTH)
+ ((DEPRECATED_REGISTER_SIZE / INSTRUCTION_SIZE)
* DEPRECATED_CALL_DUMMY_LENGTH)
/* Similarly we have to account for 64bit wide register
saves. */
+ (32 * REGISTER_SIZE)
+ (32 * DEPRECATED_REGISTER_SIZE)
/* We always consider FP regs 8 bytes long. */
+ (NUM_REGS - FP0_REGNUM) * 8
/* Similarly we have to account for 64bit wide register
saves. */
+ (6 * REGISTER_SIZE)))))
+ (6 * DEPRECATED_REGISTER_SIZE)))))
find_dummy_frame_regs (frame_info, frame_saved_regs);
/* Interrupt handlers are special too. They lay out the register
@ -4860,7 +4860,7 @@ int
hppa_register_raw_size (int reg_nr)
{
/* All registers have the same size. */
return REGISTER_SIZE;
return DEPRECATED_REGISTER_SIZE;
}
/* Index within the register vector of the first byte of the space i
@ -4989,7 +4989,7 @@ hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_inner_than (gdbarch, hppa_inner_than);
set_gdbarch_stack_align (gdbarch, hppa_stack_align);
set_gdbarch_decr_pc_after_break (gdbarch, 0);
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_deprecated_register_size (gdbarch, 4);
set_gdbarch_num_regs (gdbarch, hppa_num_regs);
set_gdbarch_deprecated_fp_regnum (gdbarch, 3);
set_gdbarch_sp_regnum (gdbarch, 30);
@ -5023,8 +5023,8 @@ hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_frame_args_skip (gdbarch, 0);
set_gdbarch_deprecated_push_dummy_frame (gdbarch, hppa_push_dummy_frame);
set_gdbarch_deprecated_pop_frame (gdbarch, hppa_pop_frame);
set_gdbarch_call_dummy_length (gdbarch, INSTRUCTION_SIZE * 28);
/* set_gdbarch_fix_call_dummy (gdbarch, hppa_fix_call_dummy); */
set_gdbarch_deprecated_call_dummy_length (gdbarch, INSTRUCTION_SIZE * 28);
/* set_gdbarch_deprecated_fix_call_dummy (gdbarch, hppa_fix_call_dummy); */
set_gdbarch_deprecated_push_arguments (gdbarch, hppa_push_arguments);
set_gdbarch_smash_text_address (gdbarch, hppa_smash_text_address);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);

6
gdb/i386-tdep.c
View File

@ -1486,7 +1486,7 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
be in use on any of the supported i386 targets. */
set_gdbarch_register_name (gdbarch, i386_register_name);
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_deprecated_register_size (gdbarch, 4);
set_gdbarch_register_bytes (gdbarch, I386_SIZEOF_GREGS + I386_SIZEOF_FREGS);
set_gdbarch_register_type (gdbarch, i386_register_type);
@ -1495,8 +1495,8 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_get_longjmp_target (gdbarch, i386_get_longjmp_target);
/* Call dummy code. */
set_gdbarch_call_dummy_words (gdbarch, NULL);
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_deprecated_call_dummy_words (gdbarch, NULL);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_register_convertible (gdbarch, i386_register_convertible);
set_gdbarch_register_convert_to_virtual (gdbarch,

6
gdb/ia64-tdep.c
View File

@ -2173,7 +2173,7 @@ ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_fp0_regnum (gdbarch, IA64_FR0_REGNUM);
set_gdbarch_register_name (gdbarch, ia64_register_name);
set_gdbarch_register_size (gdbarch, 8);
set_gdbarch_deprecated_register_size (gdbarch, 8);
set_gdbarch_register_bytes (gdbarch, ia64_num_regs * 8 + 128*8);
set_gdbarch_register_byte (gdbarch, ia64_register_byte);
set_gdbarch_register_raw_size (gdbarch, ia64_register_raw_size);
@ -2217,8 +2217,8 @@ ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_push_return_address (gdbarch, ia64_push_return_address);
set_gdbarch_deprecated_pop_frame (gdbarch, ia64_pop_frame);
set_gdbarch_call_dummy_words (gdbarch, ia64_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (ia64_call_dummy_words));
set_gdbarch_deprecated_call_dummy_words (gdbarch, ia64_call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (ia64_call_dummy_words));
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, ia64_init_extra_frame_info);
set_gdbarch_frame_args_address (gdbarch, ia64_frame_args_address);
set_gdbarch_frame_locals_address (gdbarch, ia64_frame_locals_address);

54
gdb/infcall.c
View File

@ -222,22 +222,26 @@ legacy_push_dummy_code (struct gdbarch *gdbarch,
struct type *value_type,
CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
{
/* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word is
in host byte order. Before calling FIX_CALL_DUMMY, we byteswap
it and remove any extra bytes which might exist because ULONGEST
is bigger than REGISTER_SIZE. */
/* CALL_DUMMY is an array of words (DEPRECATED_REGISTER_SIZE), but
each word is in host byte order. Before calling
DEPRECATED_FIX_CALL_DUMMY, we byteswap it and remove any extra
bytes which might exist because ULONGEST is bigger than
DEPRECATED_REGISTER_SIZE. */
/* NOTE: This is pretty wierd, as the call dummy is actually a
sequence of instructions. But CISC machines will have to pack
the instructions into REGISTER_SIZE units (and so will RISC
machines for which INSTRUCTION_SIZE is not REGISTER_SIZE). */
the instructions into DEPRECATED_REGISTER_SIZE units (and so will
RISC machines for which INSTRUCTION_SIZE is not
DEPRECATED_REGISTER_SIZE). */
/* NOTE: This is pretty stupid. CALL_DUMMY should be in strict
target byte order. */
CORE_ADDR start_sp;
ULONGEST *dummy = alloca (SIZEOF_CALL_DUMMY_WORDS);
int sizeof_dummy1 = (REGISTER_SIZE * SIZEOF_CALL_DUMMY_WORDS
ULONGEST *dummy = alloca (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS);
int sizeof_dummy1 = (DEPRECATED_REGISTER_SIZE
* DEPRECATED_SIZEOF_CALL_DUMMY_WORDS
/ sizeof (ULONGEST));
char *dummy1 = alloca (sizeof_dummy1);
memcpy (dummy, CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS);
memcpy (dummy, DEPRECATED_CALL_DUMMY_WORDS,
DEPRECATED_SIZEOF_CALL_DUMMY_WORDS);
if (INNER_THAN (1, 2))
{
/* Stack grows down */
@ -252,40 +256,40 @@ legacy_push_dummy_code (struct gdbarch *gdbarch,
}
/* NOTE: cagney/2002-09-10: Don't bother re-adjusting the stack
after allocating space for the call dummy. A target can specify
a SIZEOF_DUMMY1 (via SIZEOF_CALL_DUMMY_WORDS) such that all local
alignment requirements are met. */
a SIZEOF_DUMMY1 (via DEPRECATED_SIZEOF_CALL_DUMMY_WORDS) such
that all local alignment requirements are met. */
/* Create a call sequence customized for this function and the
number of arguments for it. */
{
int i;
for (i = 0; i < (int) (SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0]));
for (i = 0; i < (int) (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0]));
i++)
store_unsigned_integer (&dummy1[i * REGISTER_SIZE],
REGISTER_SIZE,
store_unsigned_integer (&dummy1[i * DEPRECATED_REGISTER_SIZE],
DEPRECATED_REGISTER_SIZE,
(ULONGEST) dummy[i]);
}
/* NOTE: cagney/2003-04-22: This computation of REAL_PC, BP_ADDR and
DUMMY_ADDR is pretty messed up. It comes from constant tinkering
with the values. Instead a FIX_CALL_DUMMY replacement
with the values. Instead a DEPRECATED_FIX_CALL_DUMMY replacement
(PUSH_DUMMY_BREAKPOINT?) should just do everything. */
#ifdef GDB_TARGET_IS_HPPA
real_pc = FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
value_type, using_gcc);
real_pc = DEPRECATED_FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
value_type, using_gcc);
#else
if (FIX_CALL_DUMMY_P ())
if (DEPRECATED_FIX_CALL_DUMMY_P ())
{
/* gdb_assert (CALL_DUMMY_LOCATION == ON_STACK) true? */
FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args, value_type,
using_gcc);
DEPRECATED_FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
value_type, using_gcc);
}
(*real_pc) = start_sp;
#endif
/* Yes, the offset is applied to the real_pc and not the dummy addr.
Ulgh! Blame the HP/UX target. */
(*bp_addr) = (*real_pc) + CALL_DUMMY_BREAKPOINT_OFFSET;
(*bp_addr) = (*real_pc) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET;
/* Yes, the offset is applied to the real_pc and not the
dummy_addr. Ulgh! Blame the HP/UX target. */
(*real_pc) += CALL_DUMMY_START_OFFSET;
(*real_pc) += DEPRECATED_CALL_DUMMY_START_OFFSET;
write_memory (start_sp, (char *) dummy1, sizeof_dummy1);
if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES)
generic_save_call_dummy_addr (start_sp, start_sp + sizeof_dummy1);
@ -328,8 +332,8 @@ generic_push_dummy_code (struct gdbarch *gdbarch,
return sp;
}
/* Provide backward compatibility. Once FIX_CALL_DUMMY is eliminated,
this can be simplified. */
/* Provide backward compatibility. Once DEPRECATED_FIX_CALL_DUMMY is
eliminated, this can be simplified. */
static CORE_ADDR
push_dummy_code (struct gdbarch *gdbarch,
@ -341,7 +345,7 @@ push_dummy_code (struct gdbarch *gdbarch,
if (gdbarch_push_dummy_code_p (gdbarch))
return gdbarch_push_dummy_code (gdbarch, sp, funaddr, using_gcc,
args, nargs, value_type, real_pc, bp_addr);
else if (FIX_CALL_DUMMY_P ())
else if (DEPRECATED_FIX_CALL_DUMMY_P ())
return legacy_push_dummy_code (gdbarch, sp, funaddr, using_gcc,
args, nargs, value_type, real_pc, bp_addr);
else

13
gdb/inferior.h
View File

@ -485,13 +485,14 @@ extern int deprecated_pc_in_call_dummy_at_entry_point (CORE_ADDR pc,
Note that this macro is intended for targets (like HP-UX) which
require more than a single breakpoint in their call dummies, and
therefore cannot use the CALL_DUMMY_BREAKPOINT_OFFSET mechanism.
therefore cannot use the DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET
mechanism.
If a target does define CALL_DUMMY_BREAKPOINT_OFFSET, then this
default implementation of CALL_DUMMY_HAS_COMPLETED is sufficient.
Else, a target may wish to supply an implementation that works in
the presense of multiple breakpoints in its call dummy.
*/
If a target does define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET,
then this default implementation of CALL_DUMMY_HAS_COMPLETED is
sufficient. Else, a target may wish to supply an implementation
that works in the presense of multiple breakpoints in its call
dummy. */
#if !defined(CALL_DUMMY_HAS_COMPLETED)
#define CALL_DUMMY_HAS_COMPLETED(pc, sp, frame_address) \
DEPRECATED_PC_IN_CALL_DUMMY((pc), (sp), (frame_address))

7
gdb/m68hc11-tdep.c
View File

@ -1373,16 +1373,15 @@ m68hc11_gdbarch_init (struct gdbarch_info info,
set_gdbarch_sp_regnum (gdbarch, HARD_SP_REGNUM);
set_gdbarch_deprecated_fp_regnum (gdbarch, SOFT_FP_REGNUM);
set_gdbarch_register_name (gdbarch, m68hc11_register_name);
set_gdbarch_register_size (gdbarch, 2);
set_gdbarch_deprecated_register_size (gdbarch, 2);
set_gdbarch_register_bytes (gdbarch, M68HC11_ALL_REGS * 2);
set_gdbarch_register_virtual_type (gdbarch, m68hc11_register_virtual_type);
set_gdbarch_pseudo_register_read (gdbarch, m68hc11_pseudo_register_read);
set_gdbarch_pseudo_register_write (gdbarch, m68hc11_pseudo_register_write);
set_gdbarch_call_dummy_address (gdbarch, m68hc11_call_dummy_address);
set_gdbarch_call_dummy_words (gdbarch, m68hc11_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch,
sizeof (m68hc11_call_dummy_words));
set_gdbarch_deprecated_call_dummy_words (gdbarch, m68hc11_call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (m68hc11_call_dummy_words));
set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
set_gdbarch_deprecated_extract_return_value (gdbarch, m68hc11_extract_return_value);
set_gdbarch_deprecated_push_arguments (gdbarch, m68hc11_push_arguments);

18
gdb/m68k-tdep.c
View File

@ -429,9 +429,9 @@ void
m68k_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
struct value **args, struct type *type, int gcc_p)
{
bfd_putb32 (fun, (unsigned char *) dummy + CALL_DUMMY_START_OFFSET + 2);
bfd_putb32 (fun, (unsigned char *) dummy + DEPRECATED_CALL_DUMMY_START_OFFSET + 2);
bfd_putb32 (nargs * 4,
(unsigned char *) dummy + CALL_DUMMY_START_OFFSET + 8);
(unsigned char *) dummy + DEPRECATED_CALL_DUMMY_START_OFFSET + 8);
}
@ -1025,7 +1025,7 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 12);
set_gdbarch_register_virtual_type (gdbarch, m68k_register_virtual_type);
set_gdbarch_register_name (gdbarch, m68k_register_name);
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_deprecated_register_size (gdbarch, 4);
set_gdbarch_register_byte (gdbarch, m68k_register_byte);
set_gdbarch_num_regs (gdbarch, 29);
set_gdbarch_register_bytes_ok (gdbarch, m68k_register_bytes_ok);
@ -1038,14 +1038,14 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 24);
set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 24);
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
set_gdbarch_call_dummy_length (gdbarch, 28);
set_gdbarch_call_dummy_start_offset (gdbarch, 12);
set_gdbarch_deprecated_call_dummy_length (gdbarch, 28);
set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 12);
set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_words));
set_gdbarch_fix_call_dummy (gdbarch, m68k_fix_call_dummy);
set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_words));
set_gdbarch_deprecated_fix_call_dummy (gdbarch, m68k_fix_call_dummy);
set_gdbarch_deprecated_push_dummy_frame (gdbarch, m68k_push_dummy_frame);
set_gdbarch_deprecated_pop_frame (gdbarch, m68k_pop_frame);

39
gdb/mcore-tdep.c
View File

@ -683,7 +683,8 @@ mcore_frame_chain (struct frame_info * fi)
{
/* The "FP" was saved on the stack. Don't forget to adjust
the "FP" with the framesize to get a real FP. */
callers_addr = read_memory_integer (get_frame_saved_regs (fi)[fp], REGISTER_SIZE)
callers_addr = read_memory_integer (get_frame_saved_regs (fi)[fp],
DEPRECATED_REGISTER_SIZE)
+ get_frame_extra_info (dummy)->framesize;
}
else
@ -767,7 +768,7 @@ mcore_find_callers_reg (struct frame_info *fi, int regnum)
get_frame_base (fi), regnum);
else if (get_frame_saved_regs (fi)[regnum] != 0)
return read_memory_integer (get_frame_saved_regs (fi)[regnum],
REGISTER_SIZE);
DEPRECATED_REGISTER_SIZE);
}
return read_register (regnum);
@ -814,7 +815,7 @@ mcore_pop_frame (void)
ULONGEST value;
value = read_memory_unsigned_integer (get_frame_saved_regs (fi)[rn],
REGISTER_SIZE);
DEPRECATED_REGISTER_SIZE);
write_register (rn, value);
}
}
@ -830,9 +831,9 @@ mcore_pop_frame (void)
/* Setup arguments and PR for a call to the target. First six arguments
go in FIRST_ARGREG -> LAST_ARGREG, subsequent args go on to the stack.
* Types with lengths greater than REGISTER_SIZE may not be split
between registers and the stack, and they must start in an even-numbered
register. Subsequent args will go onto the stack.
- Types with lengths greater than DEPRECATED_REGISTER_SIZE may not
be split between registers and the stack, and they must start in an
even-numbered register. Subsequent args will go onto the stack.
* Structs may be split between registers and stack, left-aligned.
@ -884,21 +885,21 @@ mcore_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
numbered register. */
olen = len;
if (TYPE_CODE (type) != TYPE_CODE_STRUCT && len > REGISTER_SIZE && argreg % 2)
if (TYPE_CODE (type) != TYPE_CODE_STRUCT && len > DEPRECATED_REGISTER_SIZE && argreg % 2)
{
mcore_insn_debug (("MCORE PUSH: %d > REGISTER_SIZE: and %s is not even\n",
mcore_insn_debug (("MCORE PUSH: %d > DEPRECATED_REGISTER_SIZE: and %s is not even\n",
len, mcore_register_names[argreg]));
argreg++;
}
if ((argreg <= LAST_ARGREG && len <= (LAST_ARGREG - argreg + 1) * REGISTER_SIZE)
if ((argreg <= LAST_ARGREG && len <= (LAST_ARGREG - argreg + 1) * DEPRECATED_REGISTER_SIZE)
|| (TYPE_CODE (type) == TYPE_CODE_STRUCT))
{
/* Something that will fit entirely into registers (or a struct
which may be split between registers and stack). */
mcore_insn_debug (("MCORE PUSH: arg %d going into regs\n", argnum));
if (TYPE_CODE (type) == TYPE_CODE_STRUCT && olen < REGISTER_SIZE)
if (TYPE_CODE (type) == TYPE_CODE_STRUCT && olen < DEPRECATED_REGISTER_SIZE)
{
/* Small structs must be right aligned within the register,
the most significant bits are undefined. */
@ -909,16 +910,16 @@ mcore_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
while (len > 0 && argreg <= LAST_ARGREG)
{
write_register (argreg, extract_unsigned_integer (val, REGISTER_SIZE));
write_register (argreg, extract_unsigned_integer (val, DEPRECATED_REGISTER_SIZE));
argreg++;
val += REGISTER_SIZE;
len -= REGISTER_SIZE;
val += DEPRECATED_REGISTER_SIZE;
len -= DEPRECATED_REGISTER_SIZE;
}
/* Any remainder for the stack is noted below... */
}
else if (TYPE_CODE (VALUE_TYPE (args[argnum])) != TYPE_CODE_STRUCT
&& len > REGISTER_SIZE)
&& len > DEPRECATED_REGISTER_SIZE)
{
/* All subsequent args go onto the stack. */
mcore_insn_debug (("MCORE PUSH: does not fit into regs, going onto stack\n"));
@ -991,7 +992,7 @@ mcore_use_struct_convention (int gcc_p, struct type *type)
CORE_ADDR
mcore_extract_struct_value_address (char *regbuf)
{
return extract_address (regbuf + REGISTER_BYTE (FIRST_ARGREG), REGISTER_SIZE);
return extract_address (regbuf + REGISTER_BYTE (FIRST_ARGREG), DEPRECATED_REGISTER_SIZE);
}
/* Given a function which returns a value of type TYPE, extract the
@ -1029,7 +1030,7 @@ mcore_store_return_value (struct type *type, char *valbuf)
value_size = TYPE_LENGTH (type);
/* Return value fits into registers. */
return_size = (value_size + REGISTER_SIZE - 1) & ~(REGISTER_SIZE - 1);
return_size = (value_size + DEPRECATED_REGISTER_SIZE - 1) & ~(DEPRECATED_REGISTER_SIZE - 1);
offset = REGISTER_BYTE (RETVAL_REGNUM) + (return_size - value_size);
zeros = alloca (return_size);
memset (zeros, 0, return_size);
@ -1101,7 +1102,7 @@ mcore_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
/* Registers: */
/* All registers are 32 bits */
set_gdbarch_register_size (gdbarch, MCORE_REG_SIZE);
set_gdbarch_deprecated_register_size (gdbarch, MCORE_REG_SIZE);
set_gdbarch_deprecated_max_register_raw_size (gdbarch, MCORE_REG_SIZE);
set_gdbarch_deprecated_max_register_virtual_size (gdbarch, MCORE_REG_SIZE);
set_gdbarch_register_name (gdbarch, mcore_register_name);
@ -1117,8 +1118,8 @@ mcore_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
/* Call Dummies: */
set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
set_gdbarch_deprecated_saved_pc_after_call (gdbarch, mcore_saved_pc_after_call);
set_gdbarch_function_start_offset (gdbarch, 0);

5
gdb/mi/ChangeLog
View File

@ -1,3 +1,8 @@
2003-05-05 Andrew Cagney <cagney@redhat.com>
* mi-main.c (mi_cmd_data_write_register_values): Replace
REGISTER_SIZE with DEPRECATED_REGISTER_SIZE.
2003-05-03 J. Brobecker <brobecker@gnat.com>
From Thierry Schneider <tpschneider1@yahoo.com>:

4
gdb/mi/mi-main.c
View File

@ -636,9 +636,9 @@ mi_cmd_data_write_register_values (char *command, char **argv, int argc)
/* Get the value as a number */
value = parse_and_eval_address (argv[i + 1]);
/* Get the value into an array */
buffer = xmalloc (REGISTER_SIZE);
buffer = xmalloc (DEPRECATED_REGISTER_SIZE);
old_chain = make_cleanup (xfree, buffer);
store_signed_integer (buffer, REGISTER_SIZE, value);
store_signed_integer (buffer, DEPRECATED_REGISTER_SIZE, value);
/* Write it down */
deprecated_write_register_bytes (REGISTER_BYTE (regnum), buffer, REGISTER_RAW_SIZE (regnum));
/* Free the buffer. */

6
gdb/mips-tdep.c
View File

@ -5908,9 +5908,9 @@ mips_gdbarch_init (struct gdbarch_info info,
set_gdbarch_call_dummy_address (gdbarch, mips_call_dummy_address);
set_gdbarch_deprecated_push_return_address (gdbarch, mips_push_return_address);
set_gdbarch_deprecated_pop_frame (gdbarch, mips_pop_frame);
set_gdbarch_fix_call_dummy (gdbarch, mips_fix_call_dummy);
set_gdbarch_call_dummy_words (gdbarch, mips_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (mips_call_dummy_words));
set_gdbarch_deprecated_fix_call_dummy (gdbarch, mips_fix_call_dummy);
set_gdbarch_deprecated_call_dummy_words (gdbarch, mips_call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (mips_call_dummy_words));
set_gdbarch_deprecated_push_return_address (gdbarch, mips_push_return_address);
set_gdbarch_frame_align (gdbarch, mips_frame_align);
set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);

16
gdb/mn10300-tdep.c
View File

@ -695,7 +695,8 @@ mn10300_frame_chain (struct frame_info *fi)
/* Our caller has a frame pointer. So find the frame in $a3 or
in the stack. */
if (get_frame_saved_regs (fi)[A3_REGNUM])
return (read_memory_integer (get_frame_saved_regs (fi)[A3_REGNUM], REGISTER_SIZE));
return (read_memory_integer (get_frame_saved_regs (fi)[A3_REGNUM],
DEPRECATED_REGISTER_SIZE));
else
return read_register (A3_REGNUM);
}
@ -879,7 +880,8 @@ mn10300_frame_saved_pc (struct frame_info *fi)
{
int adjust = saved_regs_size (fi);
return (read_memory_integer (get_frame_base (fi) + adjust, REGISTER_SIZE));
return (read_memory_integer (get_frame_base (fi) + adjust,
DEPRECATED_REGISTER_SIZE));
}
/* Function: mn10300_init_extra_frame_info
@ -1144,9 +1146,8 @@ mn10300_gdbarch_init (struct gdbarch_info info,
/* Registers. */
set_gdbarch_num_regs (gdbarch, num_regs);
set_gdbarch_register_name (gdbarch, register_name);
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_register_bytes (gdbarch,
num_regs * gdbarch_register_size (gdbarch));
set_gdbarch_deprecated_register_size (gdbarch, 4);
set_gdbarch_register_bytes (gdbarch, num_regs * gdbarch_deprecated_register_size (gdbarch));
set_gdbarch_deprecated_max_register_raw_size (gdbarch, 4);
set_gdbarch_register_raw_size (gdbarch, mn10300_register_raw_size);
set_gdbarch_register_byte (gdbarch, mn10300_register_byte);
@ -1186,9 +1187,8 @@ mn10300_gdbarch_init (struct gdbarch_info info,
set_gdbarch_deprecated_target_read_fp (gdbarch, generic_target_read_sp);
/* Calling functions in the inferior from GDB. */
set_gdbarch_call_dummy_words (gdbarch, mn10300_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch,
sizeof (mn10300_call_dummy_words));
set_gdbarch_deprecated_call_dummy_words (gdbarch, mn10300_call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (mn10300_call_dummy_words));
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
set_gdbarch_deprecated_push_arguments (gdbarch, mn10300_push_arguments);
set_gdbarch_reg_struct_has_addr (gdbarch, mn10300_reg_struct_has_addr);

12
gdb/ns32k-tdep.c
View File

@ -556,7 +556,7 @@ ns32k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_num_regs (gdbarch, NS32K_PC_REGNUM);
set_gdbarch_num_regs (gdbarch, NS32K_PS_REGNUM);
set_gdbarch_register_size (gdbarch, NS32K_REGISTER_SIZE);
set_gdbarch_deprecated_register_size (gdbarch, NS32K_REGISTER_SIZE);
set_gdbarch_register_raw_size (gdbarch, ns32k_register_raw_size);
set_gdbarch_deprecated_max_register_raw_size (gdbarch, NS32K_MAX_REGISTER_RAW_SIZE);
set_gdbarch_register_virtual_size (gdbarch, ns32k_register_virtual_size);
@ -595,11 +595,11 @@ ns32k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_push_dummy_frame (gdbarch, ns32k_push_dummy_frame);
set_gdbarch_deprecated_pop_frame (gdbarch, ns32k_pop_frame);
set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
set_gdbarch_call_dummy_words (gdbarch, ns32k_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_ns32k_call_dummy_words);
set_gdbarch_fix_call_dummy (gdbarch, ns32k_fix_call_dummy);
set_gdbarch_call_dummy_start_offset (gdbarch, 3);
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 15);
set_gdbarch_deprecated_call_dummy_words (gdbarch, ns32k_call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof_ns32k_call_dummy_words);
set_gdbarch_deprecated_fix_call_dummy (gdbarch, ns32k_fix_call_dummy);
set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 3);
set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 15);
set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);

4
gdb/rs6000-tdep.c
View File

@ -2878,7 +2878,7 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_num_regs (gdbarch, v->nregs);
set_gdbarch_num_pseudo_regs (gdbarch, v->npregs);
set_gdbarch_register_name (gdbarch, rs6000_register_name);
set_gdbarch_register_size (gdbarch, wordsize);
set_gdbarch_deprecated_register_size (gdbarch, wordsize);
set_gdbarch_register_bytes (gdbarch, off);
set_gdbarch_register_byte (gdbarch, rs6000_register_byte);
set_gdbarch_register_raw_size (gdbarch, rs6000_register_raw_size);
@ -2900,7 +2900,7 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
set_gdbarch_char_signed (gdbarch, 0);
set_gdbarch_fix_call_dummy (gdbarch, rs6000_fix_call_dummy);
set_gdbarch_deprecated_fix_call_dummy (gdbarch, rs6000_fix_call_dummy);
set_gdbarch_frame_align (gdbarch, rs6000_frame_align);
set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
set_gdbarch_deprecated_push_return_address (gdbarch, ppc_push_return_address);

11
gdb/s390-tdep.c
View File

@ -1150,7 +1150,7 @@ void
s390_store_return_value (struct type *valtype, char *valbuf)
{
int arglen;
char *reg_buff = alloca (max (S390_FPR_SIZE, REGISTER_SIZE)), *value;
char *reg_buff = alloca (max (S390_FPR_SIZE, DEPRECATED_REGISTER_SIZE)), *value;
if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
{
@ -1876,14 +1876,13 @@ s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
set_gdbarch_deprecated_push_return_address (gdbarch,
s390_push_return_address);
set_gdbarch_sizeof_call_dummy_words (gdbarch,
sizeof (s390_call_dummy_words));
set_gdbarch_call_dummy_words (gdbarch, s390_call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (s390_call_dummy_words));
set_gdbarch_deprecated_call_dummy_words (gdbarch, s390_call_dummy_words);
switch (info.bfd_arch_info->mach)
{
case bfd_mach_s390_31:
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_deprecated_register_size (gdbarch, 4);
set_gdbarch_register_raw_size (gdbarch, s390_register_raw_size);
set_gdbarch_register_virtual_size (gdbarch, s390_register_raw_size);
set_gdbarch_register_virtual_type (gdbarch, s390_register_virtual_type);
@ -1892,7 +1891,7 @@ s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_register_bytes (gdbarch, S390_REGISTER_BYTES);
break;
case bfd_mach_s390_64:
set_gdbarch_register_size (gdbarch, 8);
set_gdbarch_deprecated_register_size (gdbarch, 8);
set_gdbarch_register_raw_size (gdbarch, s390x_register_raw_size);
set_gdbarch_register_virtual_size (gdbarch, s390x_register_raw_size);
set_gdbarch_register_virtual_type (gdbarch,

12
gdb/sh-tdep.c
View File

@ -1770,7 +1770,7 @@ sh_init_extra_frame_info (int fromleaf, struct frame_info *fi)
get_frame_extra_info (fi)->return_pc = deprecated_read_register_dummy (get_frame_pc (fi),
get_frame_base (fi),
PC_REGNUM);
get_frame_extra_info (fi)->f_offset = -(CALL_DUMMY_LENGTH + 4);
get_frame_extra_info (fi)->f_offset = -(DEPRECATED_CALL_DUMMY_LENGTH + 4);
get_frame_extra_info (fi)->leaf_function = 0;
return;
}
@ -1801,7 +1801,7 @@ sh64_init_extra_frame_info (int fromleaf, struct frame_info *fi)
get_frame_extra_info (fi)->return_pc =
deprecated_read_register_dummy (get_frame_pc (fi),
get_frame_base (fi), PC_REGNUM);
get_frame_extra_info (fi)->f_offset = -(CALL_DUMMY_LENGTH + 4);
get_frame_extra_info (fi)->f_offset = -(DEPRECATED_CALL_DUMMY_LENGTH + 4);
get_frame_extra_info (fi)->leaf_function = 0;
return;
}
@ -4367,7 +4367,7 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_sp_regnum (gdbarch, 15);
set_gdbarch_deprecated_fp_regnum (gdbarch, 14);
set_gdbarch_pc_regnum (gdbarch, 16);
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_deprecated_register_size (gdbarch, 4);
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);
@ -4586,7 +4586,7 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
/* the number of real registers is the same whether we are in
ISA16(compact) or ISA32(media). */
set_gdbarch_num_regs (gdbarch, SIM_SH64_NR_REGS);
set_gdbarch_register_size (gdbarch, 8); /*????*/
set_gdbarch_deprecated_register_size (gdbarch, 8); /*????*/
set_gdbarch_register_bytes (gdbarch,
((SIM_SH64_NR_FP_REGS + 1) * 4)
+ (SIM_SH64_NR_REGS - SIM_SH64_NR_FP_REGS -1) * 8);
@ -4652,8 +4652,8 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
set_gdbarch_call_dummy_words (gdbarch, sh_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (sh_call_dummy_words));
set_gdbarch_deprecated_call_dummy_words (gdbarch, sh_call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (sh_call_dummy_words));
set_gdbarch_deprecated_push_return_address (gdbarch, sh_push_return_address);

6
gdb/sol-thread.c
View File

@ -647,9 +647,9 @@ sol_thread_store_registers (int regno)
if (regno != -1)
{ /* Not writing all the regs */
/* save new register value */
char* old_value = (char*) alloca (REGISTER_SIZE);
char* old_value = (char*) alloca (DEPRECATED_REGISTER_SIZE);
memcpy (old_value, &deprecated_registers[REGISTER_BYTE (regno)],
REGISTER_SIZE);
DEPRECATED_REGISTER_SIZE);
val = p_td_thr_getgregs (&thandle, gregset);
if (val != TD_OK)
@ -662,7 +662,7 @@ sol_thread_store_registers (int regno)
/* restore new register value */
memcpy (&deprecated_registers[REGISTER_BYTE (regno)], old_value,
REGISTER_SIZE);
DEPRECATED_REGISTER_SIZE);
#if 0
/* thread_db doesn't seem to handle this right */

45
gdb/sparc-tdep.c
View File

@ -2357,9 +2357,10 @@ sparc_store_return_value (struct type *type, char *valbuf)
For structs and unions, if the function was compiled with Sun cc,
it expects 'unimp' after the call. But gcc doesn't use that
(twisted) convention. So leave a nop there for gcc (FIX_CALL_DUMMY
can assume it is operating on a pristine CALL_DUMMY, not one that
has already been customized for a different function). */
(twisted) convention. So leave a nop there for gcc
(DEPRECATED_FIX_CALL_DUMMY can assume it is operating on a pristine
CALL_DUMMY, not one that has already been customized for a
different function). */
void
sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
@ -2392,10 +2393,10 @@ sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
{
store_unsigned_integer (dummy + CALL_DUMMY_CALL_OFFSET + 8, 4,
TYPE_LENGTH (value_type) & 0x1fff);
set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 0x30);
set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 0x30);
}
else
set_gdbarch_call_dummy_breakpoint_offset (current_gdbarch, 0x2c);
set_gdbarch_deprecated_call_dummy_breakpoint_offset (current_gdbarch, 0x2c);
if (!(GDB_TARGET_IS_SPARC64))
{
@ -3054,7 +3055,7 @@ sparc_gdbarch_fix_call_dummy (char *dummy,
static CORE_ADDR
sparc_call_dummy_address (void)
{
return (CALL_DUMMY_START_OFFSET) + CALL_DUMMY_BREAKPOINT_OFFSET;
return (DEPRECATED_CALL_DUMMY_START_OFFSET) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET;
}
/* Supply the Y register number to those that need it. */
@ -3163,7 +3164,7 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_decr_pc_after_break (gdbarch, 0);
set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sparc_extract_struct_value_address);
set_gdbarch_fix_call_dummy (gdbarch, sparc_gdbarch_fix_call_dummy);
set_gdbarch_deprecated_fix_call_dummy (gdbarch, sparc_gdbarch_fix_call_dummy);
set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_deprecated_fp_regnum (gdbarch, SPARC_FP_REGNUM);
set_gdbarch_fp0_regnum (gdbarch, SPARC_FP0_REGNUM);
@ -3221,8 +3222,8 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
#ifdef SPARC32_CALL_DUMMY_ON_STACK
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0x30);
set_gdbarch_call_dummy_length (gdbarch, 0x38);
set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 0x30);
set_gdbarch_deprecated_call_dummy_length (gdbarch, 0x38);
/* NOTE: cagney/2003-05-01: Using the just added push_dummy_code
architecture method, it is now possible to implement a
@ -3276,10 +3277,10 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
are explained in Appendix D.3. */
set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
set_gdbarch_call_dummy_words (gdbarch, call_dummy_32);
set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_32);
#else
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
#endif
set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 68);
set_gdbarch_frame_args_skip (gdbarch, 68);
@ -3293,14 +3294,14 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_register_byte (gdbarch, sparc32_register_byte);
set_gdbarch_register_raw_size (gdbarch, sparc32_register_size);
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_deprecated_register_size (gdbarch, 4);
set_gdbarch_register_virtual_size (gdbarch, sparc32_register_size);
set_gdbarch_register_virtual_type (gdbarch,
sparc32_register_virtual_type);
#ifdef SPARC32_CALL_DUMMY_ON_STACK
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_32));
#else
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
#endif
set_gdbarch_stack_align (gdbarch, sparc32_stack_align);
set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
@ -3323,14 +3324,14 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
#ifdef SPARC64_CALL_DUMMY_ON_STACK
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
set_gdbarch_call_dummy_address (gdbarch, sparc_call_dummy_address);
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
set_gdbarch_call_dummy_length (gdbarch, 192);
set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 8 * 4);
set_gdbarch_deprecated_call_dummy_length (gdbarch, 192);
set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
set_gdbarch_call_dummy_start_offset (gdbarch, 148);
set_gdbarch_call_dummy_words (gdbarch, call_dummy_64);
set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 148);
set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_64);
#else
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
#endif
set_gdbarch_deprecated_call_dummy_stack_adjust (gdbarch, 128);
set_gdbarch_frame_args_skip (gdbarch, 136);
@ -3347,14 +3348,14 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
to assume they all are (since most of them are). */
set_gdbarch_register_byte (gdbarch, sparc64_register_byte);
set_gdbarch_register_raw_size (gdbarch, sparc64_register_size);
set_gdbarch_register_size (gdbarch, 8);
set_gdbarch_deprecated_register_size (gdbarch, 8);
set_gdbarch_register_virtual_size (gdbarch, sparc64_register_size);
set_gdbarch_register_virtual_type (gdbarch,
sparc64_register_virtual_type);
#ifdef SPARC64_CALL_DUMMY_ON_STACK
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_64));
#else
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
#endif
set_gdbarch_stack_align (gdbarch, sparc64_stack_align);
set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);

2
gdb/target.c
View File

@ -1215,7 +1215,7 @@ find_default_create_inferior (char *exec_file, char *allargs, char **env)
static int
default_region_size_ok_for_hw_watchpoint (int byte_count)
{
return (byte_count <= REGISTER_SIZE);
return (byte_count <= DEPRECATED_REGISTER_SIZE);
}
static int

5
gdb/testsuite/ChangeLog
View File

@ -1,3 +1,8 @@
2003-05-05 Andrew Cagney <cagney@redhat.com>
* gdb.base/watchpoint.exp: Rename CALL_DUMMY_BREAKPOINT_OFFSET to
DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET in comments.
2003-05-02 Elena Zannoni <ezannoni@redhat.com>
* gdb.base/charset.exp: Update based on new behavior of set/show

4
gdb/testsuite/gdb.base/watchpoint.exp
View File

@ -377,7 +377,7 @@ proc test_stepping {} {
# The problem is that GDB confuses stepping through the call
# dummy with hitting the breakpoint at the end of the call dummy.
# Will be fixed once all architectures define
# CALL_DUMMY_BREAKPOINT_OFFSET.
# DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET.
setup_xfail "*-*-*"
# This doesn't occur if the call dummy starts with a call,
# because we are out of the dummy by the first time the inferior
@ -388,7 +388,7 @@ proc test_stepping {} {
clear_xfail "m68*-*-*"
clear_xfail "i*86*-*-*"
clear_xfail "vax-*-*"
# The following architectures define CALL_DUMMY_BREAKPOINT_OFFSET.
# The following architectures define DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET.
clear_xfail "alpha-*-*"
clear_xfail "mips*-*-*"
clear_xfail "sparc-*-*"

8
gdb/v850-tdep.c
View File

@ -1229,7 +1229,7 @@ v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
set_gdbarch_register_name (gdbarch, v850_register_name);
set_gdbarch_register_size (gdbarch, v850_reg_size);
set_gdbarch_deprecated_register_size (gdbarch, v850_reg_size);
set_gdbarch_register_bytes (gdbarch, E_ALL_REGS_SIZE);
set_gdbarch_register_byte (gdbarch, v850_register_byte);
set_gdbarch_register_raw_size (gdbarch, v850_register_raw_size);
@ -1277,9 +1277,9 @@ v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_store_return_value (gdbarch, v850_store_return_value);
set_gdbarch_deprecated_extract_struct_value_address (gdbarch, v850_extract_struct_value_address);
set_gdbarch_use_struct_convention (gdbarch, v850_use_struct_convention);
set_gdbarch_call_dummy_words (gdbarch, call_dummy_nil);
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_fix_call_dummy (gdbarch, v850_fix_call_dummy);
set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_deprecated_fix_call_dummy (gdbarch, v850_fix_call_dummy);
set_gdbarch_breakpoint_from_pc (gdbarch, v850_breakpoint_from_pc);
set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);

2
gdb/valops.c
View File

@ -962,7 +962,7 @@ value_ind (struct value *arg1)
CORE_ADDR
push_word (CORE_ADDR sp, ULONGEST word)
{
register int len = REGISTER_SIZE;
register int len = DEPRECATED_REGISTER_SIZE;
char *buffer = alloca (MAX_REGISTER_RAW_SIZE);
store_unsigned_integer (buffer, len, word);

11
gdb/vax-tdep.c
View File

@ -50,7 +50,6 @@ static gdbarch_deprecated_extract_struct_value_address_ftype
vax_extract_struct_value_address;
static gdbarch_deprecated_push_dummy_frame_ftype vax_push_dummy_frame;
static gdbarch_fix_call_dummy_ftype vax_fix_call_dummy;
/* Return 1 if P points to an invalid floating point value.
LEN is the length in bytes -- not relevant on the Vax. */
@ -627,7 +626,7 @@ vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
set_gdbarch_register_name (gdbarch, vax_register_name);
set_gdbarch_register_size (gdbarch, VAX_REGISTER_SIZE);
set_gdbarch_deprecated_register_size (gdbarch, VAX_REGISTER_SIZE);
set_gdbarch_register_bytes (gdbarch, VAX_REGISTER_BYTES);
set_gdbarch_register_byte (gdbarch, vax_register_byte);
set_gdbarch_register_raw_size (gdbarch, vax_register_raw_size);
@ -667,10 +666,10 @@ vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_push_dummy_frame (gdbarch, vax_push_dummy_frame);
set_gdbarch_deprecated_pop_frame (gdbarch, vax_pop_frame);
set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
set_gdbarch_call_dummy_words (gdbarch, vax_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
set_gdbarch_fix_call_dummy (gdbarch, vax_fix_call_dummy);
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 7);
set_gdbarch_deprecated_call_dummy_words (gdbarch, vax_call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
set_gdbarch_deprecated_fix_call_dummy (gdbarch, vax_fix_call_dummy);
set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 7);
set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);

2
gdb/x86-64-tdep.c
View File

@ -954,7 +954,7 @@ x86_64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
in use on any of the supported x86-64 targets. */
set_gdbarch_register_name (gdbarch, x86_64_register_name);
set_gdbarch_register_size (gdbarch, 8);
set_gdbarch_deprecated_register_size (gdbarch, 8);
/* Total amount of space needed to store our copies of the machine's
register (SIZEOF_GREGS + SIZEOF_FPU_REGS + SIZEOF_FPU_CTRL_REGS +

6
gdb/xstormy16-tdep.c
View File

@ -1038,7 +1038,7 @@ xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
set_gdbarch_register_name (gdbarch, xstormy16_register_name);
set_gdbarch_register_size (gdbarch, xstormy16_reg_size);
set_gdbarch_deprecated_register_size (gdbarch, xstormy16_reg_size);
set_gdbarch_register_bytes (gdbarch, E_ALL_REGS_SIZE);
set_gdbarch_register_byte (gdbarch, xstormy16_register_byte);
set_gdbarch_register_raw_size (gdbarch, xstormy16_register_raw_size);
@ -1092,8 +1092,8 @@ xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_extract_struct_value_address (gdbarch, xstormy16_extract_struct_value_address);
set_gdbarch_use_struct_convention (gdbarch,
xstormy16_use_struct_convention);
set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words);
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
set_gdbarch_char_signed (gdbarch, 0);