This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[patch rfc] Dummy deprecate deluge
- From: Andrew Cagney <ac131313 at redhat dot com>
- To: gdb-patches at sources dot redhat dot com
- Date: Sat, 03 May 2003 23:49:16 -0400
- Subject: [patch rfc] Dummy deprecate deluge
Hello,
This deprecates all but one of the now defunct dummy methods. I need to
investigate call_dummy_address to see if it two is no longer needed.
One, REGISTER_SIZE deserves a few comments.
In infcall.c, the dummy frame code uses REGISTER_SIZE to figure out how
to convert the dummy frame words from host to target byte order:
/* 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. */
/* 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). */
/* NOTE: This is pretty stupid. CALL_DUMMY should be in strict
target byte order. */
The whole dummy mess is replaced by push_dummy_code(). I also found
mi/mi-main.c:
/* Get the value into an array */
buffer = xmalloc (REGISTER_SIZE);
old_chain = make_cleanup (xfree, buffer);
store_signed_integer (buffer, REGISTER_SIZE, value);
/* Write it down */
deprecated_write_register_bytes (REGISTER_BYTE (regnum), buffer, REGIS
TER_RAW_SIZE (regnum));
I'm not sure what this one is smoking, it suspect that it should have
used REGISTER_RAW_SIZE().
I'll look to commit it in a few days (then fix the above bug),
Andrew
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.
Index: alpha-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/alpha-tdep.c,v
retrieving revision 1.81
diff -u -r1.81 alpha-tdep.c
--- alpha-tdep.c 29 Apr 2003 01:49:46 -0000 1.81
+++ alpha-tdep.c 4 May 2003 03:16:52 -0000
@@ -66,8 +66,6 @@
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 @@
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 @@
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 @@
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);
Index: alphafbsd-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/alphafbsd-tdep.c,v
retrieving revision 1.7
diff -u -r1.7 alphafbsd-tdep.c
--- alphafbsd-tdep.c 4 Jan 2003 23:38:44 -0000 1.7
+++ alphafbsd-tdep.c 4 May 2003 03:16:52 -0000
@@ -32,7 +32,7 @@
/* 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
Index: arm-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/arm-linux-tdep.c,v
retrieving revision 1.30
diff -u -r1.30 arm-linux-tdep.c
--- arm-linux-tdep.c 11 Apr 2003 18:15:38 -0000 1.30
+++ arm-linux-tdep.c 4 May 2003 03:16:53 -0000
@@ -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 @@
/* 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 @@
/* 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 @@
.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 @@
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 @@
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 @@
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);
Index: arm-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/arm-tdep.c,v
retrieving revision 1.131
diff -u -r1.131 arm-tdep.c
--- arm-tdep.c 29 Apr 2003 01:49:46 -0000 1.131
+++ arm-tdep.c 4 May 2003 03:16:57 -0000
@@ -1237,7 +1237,7 @@
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 @@
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 @@
/* 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 @@
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 @@
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 @@
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 @@
/* 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 @@
/* 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 @@
/* 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 @@
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 @@
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 @@
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. */
Index: avr-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/avr-tdep.c,v
retrieving revision 1.44
diff -u -r1.44 avr-tdep.c
--- avr-tdep.c 29 Apr 2003 01:49:46 -0000 1.44
+++ avr-tdep.c 4 May 2003 03:16:59 -0000
@@ -1156,7 +1156,7 @@
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 @@
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? */
Index: breakpoint.c
===================================================================
RCS file: /cvs/src/src/gdb/breakpoint.c,v
retrieving revision 1.119
diff -u -r1.119 breakpoint.c
--- breakpoint.c 27 Apr 2003 01:11:10 -0000 1.119
+++ breakpoint.c 4 May 2003 03:17:11 -0000
@@ -1697,7 +1697,7 @@
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 @@
#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)
Index: cris-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/cris-tdep.c,v
retrieving revision 1.70
diff -u -r1.70 cris-tdep.c
--- cris-tdep.c 29 Apr 2003 01:49:46 -0000 1.70
+++ cris-tdep.c 4 May 2003 03:17:14 -0000
@@ -971,7 +971,7 @@
{
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 @@
{
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 @@
{
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 @@
{
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 @@
/* 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 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
{
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 @@
/* 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 @@
/* 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 @@
/* 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);
Index: dummy-frame.c
===================================================================
RCS file: /cvs/src/src/gdb/dummy-frame.c,v
retrieving revision 1.19
diff -u -r1.19 dummy-frame.c
--- dummy-frame.c 29 Apr 2003 01:49:46 -0000 1.19
+++ dummy-frame.c 4 May 2003 03:17:17 -0000
@@ -149,8 +149,9 @@
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)
Index: dummy-frame.h
===================================================================
RCS file: /cvs/src/src/gdb/dummy-frame.h,v
retrieving revision 1.9
diff -u -r1.9 dummy-frame.h
--- dummy-frame.h 31 Mar 2003 23:52:37 -0000 1.9
+++ dummy-frame.h 4 May 2003 03:17:17 -0000
@@ -37,12 +37,13 @@
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. */
Index: frv-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/frv-tdep.c,v
retrieving revision 1.34
diff -u -r1.34 frv-tdep.c
--- frv-tdep.c 29 Apr 2003 01:49:46 -0000 1.34
+++ frv-tdep.c 4 May 2003 03:17:17 -0000
@@ -1057,7 +1057,7 @@
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 @@
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. */
Index: gdbarch.c
===================================================================
RCS file: /cvs/src/src/gdb/gdbarch.c,v
retrieving revision 1.211
diff -u -r1.211 gdbarch.c
--- gdbarch.c 3 May 2003 19:39:23 -0000 1.211
+++ gdbarch.c 4 May 2003 03:17:19 -0000
@@ -167,7 +167,7 @@
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 @@
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 @@
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 @@
/* 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 @@
(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: 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: 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: 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: 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 @@
(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 @@
(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 @@
(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",
@@ -2086,14 +2102,6 @@
(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 */
@@ -2266,14 +2274,6 @@
(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",
@@ -3286,19 +3286,19 @@
}
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
@@ -3732,51 +3732,51 @@
}
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
@@ -3807,37 +3807,37 @@
}
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
@@ -3864,29 +3864,29 @@
}
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
Index: gdbarch.h
===================================================================
RCS file: /cvs/src/src/gdb/gdbarch.h,v
retrieving revision 1.178
diff -u -r1.178 gdbarch.h
--- gdbarch.h 3 May 2003 19:39:23 -0000 1.178
+++ gdbarch.h 4 May 2003 03:17:20 -0000
@@ -721,13 +721,13 @@
#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);
@@ -1172,35 +1172,35 @@
/* 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
@@ -1249,33 +1249,33 @@
/* 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. */
@@ -1318,44 +1318,44 @@
/* 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);
Index: gdbarch.sh
===================================================================
RCS file: /cvs/src/src/gdb/gdbarch.sh,v
retrieving revision 1.230
diff -u -r1.230 gdbarch.sh
--- gdbarch.sh 3 May 2003 19:39:23 -0000 1.230
+++ gdbarch.sh 4 May 2003 03:17:22 -0000
@@ -472,7 +472,7 @@
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
f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::generic_register_byte:generic_register_byte::0
# The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE,
@@ -528,11 +528,11 @@
# 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
@@ -540,14 +540,14 @@
# 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
Index: h8300-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/h8300-tdep.c,v
retrieving revision 1.57
diff -u -r1.57 h8300-tdep.c
--- h8300-tdep.c 29 Apr 2003 01:49:47 -0000 1.57
+++ h8300-tdep.c 4 May 2003 03:17:24 -0000
@@ -1104,7 +1104,7 @@
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 @@
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);
Index: hppa-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/hppa-tdep.c,v
retrieving revision 1.73
diff -u -r1.73 hppa-tdep.c
--- hppa-tdep.c 29 Apr 2003 01:49:47 -0000 1.73
+++ hppa-tdep.c 4 May 2003 03:17:31 -0000
@@ -200,7 +200,7 @@
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 @@
/* 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 @@
/* 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
/* 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 @@
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 @@
/* 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 @@
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 @@
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 @@
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 @@
/* 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 @@
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 @@
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 @@
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);
Index: i386-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/i386-tdep.c,v
retrieving revision 1.140
diff -u -r1.140 i386-tdep.c
--- i386-tdep.c 29 Apr 2003 01:49:47 -0000 1.140
+++ i386-tdep.c 4 May 2003 03:17:35 -0000
@@ -1486,7 +1486,7 @@
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 @@
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,
Index: ia64-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ia64-tdep.c,v
retrieving revision 1.72
diff -u -r1.72 ia64-tdep.c
--- ia64-tdep.c 30 Apr 2003 22:01:37 -0000 1.72
+++ ia64-tdep.c 4 May 2003 03:17:36 -0000
@@ -2173,7 +2173,7 @@
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 @@
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);
Index: infcall.c
===================================================================
RCS file: /cvs/src/src/gdb/infcall.c,v
retrieving revision 1.10
diff -u -r1.10 infcall.c
--- infcall.c 3 May 2003 19:39:23 -0000 1.10
+++ infcall.c 4 May 2003 03:17:40 -0000
@@ -222,22 +222,26 @@
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 @@
}
/* 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 @@
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 @@
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
Index: inferior.h
===================================================================
RCS file: /cvs/src/src/gdb/inferior.h,v
retrieving revision 1.54
diff -u -r1.54 inferior.h
--- inferior.h 29 Apr 2003 01:49:47 -0000 1.54
+++ inferior.h 4 May 2003 03:17:41 -0000
@@ -485,13 +485,14 @@
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))
Index: m68hc11-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/m68hc11-tdep.c,v
retrieving revision 1.65
diff -u -r1.65 m68hc11-tdep.c
--- m68hc11-tdep.c 29 Apr 2003 01:49:47 -0000 1.65
+++ m68hc11-tdep.c 4 May 2003 03:17:42 -0000
@@ -1373,16 +1373,15 @@
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);
Index: m68k-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/m68k-tdep.c,v
retrieving revision 1.58
diff -u -r1.58 m68k-tdep.c
--- m68k-tdep.c 29 Apr 2003 01:49:47 -0000 1.58
+++ m68k-tdep.c 4 May 2003 03:17:43 -0000
@@ -429,9 +429,9 @@
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 @@
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 @@
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);
Index: mcore-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mcore-tdep.c,v
retrieving revision 1.61
diff -u -r1.61 mcore-tdep.c
--- mcore-tdep.c 3 May 2003 19:13:03 -0000 1.61
+++ mcore-tdep.c 4 May 2003 03:17:45 -0000
@@ -683,7 +683,8 @@
{
/* 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 @@
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 @@
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 @@
/* 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 @@
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 @@
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 @@
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 @@
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 @@
/* 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 @@
/* 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);
Index: mips-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mips-tdep.c,v
retrieving revision 1.194
diff -u -r1.194 mips-tdep.c
--- mips-tdep.c 30 Apr 2003 22:01:37 -0000 1.194
+++ mips-tdep.c 4 May 2003 03:17:58 -0000
@@ -5908,9 +5908,9 @@
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);
Index: mn10300-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mn10300-tdep.c,v
retrieving revision 1.74
diff -u -r1.74 mn10300-tdep.c
--- mn10300-tdep.c 29 Apr 2003 01:49:47 -0000 1.74
+++ mn10300-tdep.c 4 May 2003 03:17:58 -0000
@@ -695,7 +695,8 @@
/* 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 @@
{
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 @@
/* 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 @@
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);
Index: ns32k-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ns32k-tdep.c,v
retrieving revision 1.46
diff -u -r1.46 ns32k-tdep.c
--- ns32k-tdep.c 29 Apr 2003 01:49:47 -0000 1.46
+++ ns32k-tdep.c 4 May 2003 03:17:59 -0000
@@ -556,7 +556,7 @@
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 @@
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);
Index: rs6000-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/rs6000-tdep.c,v
retrieving revision 1.129
diff -u -r1.129 rs6000-tdep.c
--- rs6000-tdep.c 29 Apr 2003 01:49:47 -0000 1.129
+++ rs6000-tdep.c 4 May 2003 03:18:15 -0000
@@ -2878,7 +2878,7 @@
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 @@
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);
Index: s390-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/s390-tdep.c,v
retrieving revision 1.95
diff -u -r1.95 s390-tdep.c
--- s390-tdep.c 30 Apr 2003 22:01:37 -0000 1.95
+++ s390-tdep.c 4 May 2003 03:18:16 -0000
@@ -1150,7 +1150,7 @@
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 @@
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 @@
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,
Index: sh-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/sh-tdep.c,v
retrieving revision 1.119
diff -u -r1.119 sh-tdep.c
--- sh-tdep.c 29 Apr 2003 01:49:47 -0000 1.119
+++ sh-tdep.c 4 May 2003 03:18:23 -0000
@@ -1770,7 +1770,7 @@
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 @@
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 @@
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 @@
/* 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 @@
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);
Index: sol-thread.c
===================================================================
RCS file: /cvs/src/src/gdb/sol-thread.c,v
retrieving revision 1.34
diff -u -r1.34 sol-thread.c
--- sol-thread.c 25 Feb 2003 21:36:19 -0000 1.34
+++ sol-thread.c 4 May 2003 03:18:38 -0000
@@ -647,9 +647,9 @@
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 @@
/* 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 */
Index: sparc-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/sparc-tdep.c,v
retrieving revision 1.95
diff -u -r1.95 sparc-tdep.c
--- sparc-tdep.c 3 May 2003 19:39:23 -0000 1.95
+++ sparc-tdep.c 4 May 2003 03:18:44 -0000
@@ -2357,9 +2357,10 @@
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 @@
{
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 @@
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 @@
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 @@
#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 @@
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 @@
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 @@
#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 @@
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);
Index: target.c
===================================================================
RCS file: /cvs/src/src/gdb/target.c,v
retrieving revision 1.50
diff -u -r1.50 target.c
--- target.c 24 Feb 2003 21:56:50 -0000 1.50
+++ target.c 4 May 2003 03:18:45 -0000
@@ -1215,7 +1215,7 @@
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
Index: v850-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/v850-tdep.c,v
retrieving revision 1.60
diff -u -r1.60 v850-tdep.c
--- v850-tdep.c 3 May 2003 19:13:04 -0000 1.60
+++ v850-tdep.c 4 May 2003 03:18:45 -0000
@@ -1229,7 +1229,7 @@
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 @@
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);
Index: valops.c
===================================================================
RCS file: /cvs/src/src/gdb/valops.c,v
retrieving revision 1.105
diff -u -r1.105 valops.c
--- valops.c 21 Apr 2003 16:48:40 -0000 1.105
+++ valops.c 4 May 2003 03:18:51 -0000
@@ -962,7 +962,7 @@
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);
Index: vax-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/vax-tdep.c,v
retrieving revision 1.47
diff -u -r1.47 vax-tdep.c
--- vax-tdep.c 29 Apr 2003 01:49:48 -0000 1.47
+++ vax-tdep.c 4 May 2003 03:18:51 -0000
@@ -50,7 +50,6 @@
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 @@
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 @@
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);
Index: x86-64-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/x86-64-tdep.c,v
retrieving revision 1.68
diff -u -r1.68 x86-64-tdep.c
--- x86-64-tdep.c 29 Apr 2003 01:49:48 -0000 1.68
+++ x86-64-tdep.c 4 May 2003 03:18:51 -0000
@@ -954,7 +954,7 @@
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 +
Index: xstormy16-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/xstormy16-tdep.c,v
retrieving revision 1.48
diff -u -r1.48 xstormy16-tdep.c
--- xstormy16-tdep.c 29 Apr 2003 01:49:48 -0000 1.48
+++ xstormy16-tdep.c 4 May 2003 03:18:52 -0000
@@ -1038,7 +1038,7 @@
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 @@
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);
Index: config/ia64/tm-ia64.h
===================================================================
RCS file: /cvs/src/src/gdb/config/ia64/tm-ia64.h,v
retrieving revision 1.6
diff -u -r1.6 tm-ia64.h
--- config/ia64/tm-ia64.h 29 Apr 2003 01:49:48 -0000 1.6
+++ config/ia64/tm-ia64.h 4 May 2003 03:18:52 -0000
@@ -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
Index: config/m68k/tm-vx68.h
===================================================================
RCS file: /cvs/src/src/gdb/config/m68k/tm-vx68.h,v
retrieving revision 1.7
diff -u -r1.7 tm-vx68.h
--- config/m68k/tm-vx68.h 24 Mar 2003 03:54:50 -0000 1.7
+++ config/m68k/tm-vx68.h 4 May 2003 03:18:52 -0000
@@ -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))
Index: config/mips/tm-mips.h
===================================================================
RCS file: /cvs/src/src/gdb/config/mips/tm-mips.h,v
retrieving revision 1.47
diff -u -r1.47 tm-mips.h
--- config/mips/tm-mips.h 19 Mar 2003 06:21:14 -0000 1.47
+++ config/mips/tm-mips.h 4 May 2003 03:18:53 -0000
@@ -49,10 +49,10 @@
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
Index: config/pa/nm-hppah.h
===================================================================
RCS file: /cvs/src/src/gdb/config/pa/nm-hppah.h,v
retrieving revision 1.12
diff -u -r1.12 nm-hppah.h
--- config/pa/nm-hppah.h 29 Mar 2003 23:29:47 -0000 1.12
+++ config/pa/nm-hppah.h 4 May 2003 03:18:53 -0000
@@ -121,9 +121,10 @@
#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)
Index: config/pa/tm-hppa.h
===================================================================
RCS file: /cvs/src/src/gdb/config/pa/tm-hppa.h,v
retrieving revision 1.49
diff -u -r1.49 tm-hppa.h
--- config/pa/tm-hppa.h 22 Apr 2003 23:04:40 -0000 1.49
+++ config/pa/tm-hppa.h 4 May 2003 03:18:55 -0000
@@ -274,20 +274,20 @@
(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);
Index: config/pa/tm-hppa64.h
===================================================================
RCS file: /cvs/src/src/gdb/config/pa/tm-hppa64.h,v
retrieving revision 1.15
diff -u -r1.15 tm-hppa64.h
--- config/pa/tm-hppa64.h 29 Apr 2003 01:49:48 -0000 1.15
+++ config/pa/tm-hppa64.h 4 May 2003 03:18:57 -0000
@@ -109,7 +109,7 @@
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 @@
#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 @@
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 @@
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 @@
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 @@
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) \
Index: config/s390/tm-s390.h
===================================================================
RCS file: /cvs/src/src/gdb/config/s390/tm-s390.h,v
retrieving revision 1.4
diff -u -r1.4 tm-s390.h
--- config/s390/tm-s390.h 29 Apr 2003 01:49:48 -0000 1.4
+++ config/s390/tm-s390.h 4 May 2003 03:18:57 -0000
@@ -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 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 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 */
Index: config/sparc/tm-sp64.h
===================================================================
RCS file: /cvs/src/src/gdb/config/sparc/tm-sp64.h,v
retrieving revision 1.20
diff -u -r1.20 tm-sp64.h
--- config/sparc/tm-sp64.h 29 Apr 2003 01:49:48 -0000 1.20
+++ config/sparc/tm-sp64.h 4 May 2003 03:18:57 -0000
@@ -90,26 +90,26 @@
#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 @@
#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 @@
#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 @@
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. */
Index: config/sparc/tm-sparc.h
===================================================================
RCS file: /cvs/src/src/gdb/config/sparc/tm-sparc.h,v
retrieving revision 1.47
diff -u -r1.47 tm-sparc.h
--- config/sparc/tm-sparc.h 29 Apr 2003 01:49:48 -0000 1.47
+++ config/sparc/tm-sparc.h 4 May 2003 03:18:57 -0000
@@ -174,7 +174,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 4
+#define DEPRECATED_REGISTER_SIZE 4
/* Number of machine registers */
@@ -589,19 +589,19 @@
/* 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 @@
/* 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);
Index: doc/gdbint.texinfo
===================================================================
RCS file: /cvs/src/src/gdb/doc/gdbint.texinfo,v
retrieving revision 1.143
diff -u -r1.143 gdbint.texinfo
--- doc/gdbint.texinfo 3 May 2003 19:39:23 -0000 1.143
+++ doc/gdbint.texinfo 4 May 2003 03:19:06 -0000
@@ -3085,8 +3085,8 @@
@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 @@
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 @@
@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 @@
(@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
Index: mi/mi-main.c
===================================================================
RCS file: /cvs/src/src/gdb/mi/mi-main.c,v
retrieving revision 1.42
diff -u -r1.42 mi-main.c
--- mi/mi-main.c 14 Mar 2003 17:07:01 -0000 1.42
+++ mi/mi-main.c 4 May 2003 03:19:09 -0000
@@ -636,9 +636,9 @@
/* 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. */
Index: testsuite/gdb.base/watchpoint.exp
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.base/watchpoint.exp,v
retrieving revision 1.8
diff -u -r1.8 watchpoint.exp
--- testsuite/gdb.base/watchpoint.exp 17 Mar 2003 19:51:58 -0000 1.8
+++ testsuite/gdb.base/watchpoint.exp 4 May 2003 03:19:16 -0000
@@ -377,7 +377,7 @@
# 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 @@
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-*-*"