mirrors/binutils-gdb
1
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-23 18:14:13 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

2003-09-25 Andrew Cagney <cagney@redhat.com>

Browse Source 
* frame.h (deprecated_frame_saved_regs): Rename
	get_frame_saved_regs.
	* cris-tdep.c, frame.c, h8300-tdep.c, hppa-tdep.c: Update.
	* mcore-tdep.c, mips-tdep.c, mn10300-tdep.c: Update.
	* ns32k-tdep.c, ppc-linux-tdep.c, rs6000-tdep.c: Update.
	* s390-tdep.c, sh64-tdep.c, stack.c: Update.
	* v850-tdep.c, vax-tdep.c, xstormy16-tdep.c: Update.
This commit is contained in:
Andrew Cagney 2003-09-25 20:44:02 +00:00
parent ecc2063b6c
commit 1b1d37945b
18 changed files with 190 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gdb/ChangeLog
View File

@ -1,3 +1,13 @@
2003-09-25 Andrew Cagney <cagney@redhat.com>
* frame.h (deprecated_frame_saved_regs): Rename
get_frame_saved_regs.
* cris-tdep.c, frame.c, h8300-tdep.c, hppa-tdep.c: Update.
* mcore-tdep.c, mips-tdep.c, mn10300-tdep.c: Update.
* ns32k-tdep.c, ppc-linux-tdep.c, rs6000-tdep.c: Update.
* s390-tdep.c, sh64-tdep.c, stack.c: Update.
* v850-tdep.c, vax-tdep.c, xstormy16-tdep.c: Update.
2003-09-25 Andrew Cagney <cagney@redhat.com>
* NEWS: Mention the new backtrace mechanism, DWARF 2 CFI, hosted

36
gdb/cris-tdep.c
View File

@ -501,10 +501,10 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
/* We only want to know the end of the prologue when fi->saved_regs == 0.
When the saved registers are allocated full information is required. */
if (get_frame_saved_regs (fi))
if (deprecated_get_frame_saved_regs (fi))
{
for (regno = 0; regno < NUM_REGS; regno++)
get_frame_saved_regs (fi)[regno] = 0;
deprecated_get_frame_saved_regs (fi)[regno] = 0;
}
/* Find the prologue instructions. */
@ -676,34 +676,34 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
/* We only want to know the end of the prologue when
fi->saved_regs == 0. */
if (!get_frame_saved_regs (fi))
if (!deprecated_get_frame_saved_regs (fi))
return ip;
if (have_fp)
{
get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] = get_frame_base (fi);
deprecated_get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] = get_frame_base (fi);
/* Calculate the addresses. */
for (regno = regsave; regno >= 0; regno--)
{
get_frame_saved_regs (fi)[regno] = get_frame_base (fi) - val;
deprecated_get_frame_saved_regs (fi)[regno] = get_frame_base (fi) - val;
val -= 4;
}
if (get_frame_extra_info (fi)->leaf_function)
{
/* Set the register SP to contain the stack pointer of
the caller. */
get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 4;
deprecated_get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 4;
}
else
{
/* Set the register SP to contain the stack pointer of
the caller. */
get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 8;
deprecated_get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 8;
/* Set the register SRP to contain the return address of
the caller. */
get_frame_saved_regs (fi)[SRP_REGNUM] = get_frame_base (fi) + 4;
deprecated_get_frame_saved_regs (fi)[SRP_REGNUM] = get_frame_base (fi) + 4;
}
}
return ip;
@ -1151,7 +1151,7 @@ cris_frame_init_saved_regs (struct frame_info *fi)
int frameless_p = 0;
/* Has this frame's registers already been initialized? */
if (get_frame_saved_regs (fi))
if (deprecated_get_frame_saved_regs (fi))
return;
frame_saved_regs_zalloc (fi);
@ -1161,7 +1161,7 @@ cris_frame_init_saved_regs (struct frame_info *fi)
/* I don't see this ever happening, considering the context in which
cris_frame_init_saved_regs is called (always when we're not in
a dummy frame). */
memcpy (get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS);
memcpy (deprecated_get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS);
}
else
{
@ -1219,11 +1219,11 @@ cris_init_extra_frame_info (int fromleaf, struct frame_info *fi)
/* Check fromleaf/frameless_function_invocation. (FIXME) */
if (get_frame_saved_regs (fi)[SRP_REGNUM] != 0)
if (deprecated_get_frame_saved_regs (fi)[SRP_REGNUM] != 0)
{
/* SRP was saved on the stack; non-leaf function. */
get_frame_extra_info (fi)->return_pc =
read_memory_integer (get_frame_saved_regs (fi)[SRP_REGNUM],
read_memory_integer (deprecated_get_frame_saved_regs (fi)[SRP_REGNUM],
REGISTER_RAW_SIZE (SRP_REGNUM));
}
else
@ -1527,30 +1527,30 @@ cris_pop_frame (void)
after SP was saved. */
for (regno = 0; regno < DEPRECATED_FP_REGNUM; regno++)
{
if (get_frame_saved_regs (fi)[regno])
if (deprecated_get_frame_saved_regs (fi)[regno])
{
write_register (regno,
read_memory_integer (get_frame_saved_regs (fi)[regno], 4));
read_memory_integer (deprecated_get_frame_saved_regs (fi)[regno], 4));
}
}
if (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM])
if (deprecated_get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM])
{
/* Pop the frame pointer (R8). It was pushed before SP
was saved. */
write_register (DEPRECATED_FP_REGNUM,
read_memory_integer (get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4));
read_memory_integer (deprecated_get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4));
stack_offset += 4;
/* Not a leaf function. */
if (get_frame_saved_regs (fi)[SRP_REGNUM])
if (deprecated_get_frame_saved_regs (fi)[SRP_REGNUM])
{
/* SRP was pushed before SP was saved. */
stack_offset += 4;
}
/* Restore the SP and adjust for R8 and (possibly) SRP. */
write_register (SP_REGNUM, get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] + stack_offset);
write_register (SP_REGNUM, deprecated_get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] + stack_offset);
}
else
{

28
gdb/frame.c
View File

@ -844,7 +844,7 @@ frame_saved_regs_zalloc (struct frame_info *fi)
}
CORE_ADDR *
get_frame_saved_regs (struct frame_info *fi)
deprecated_get_frame_saved_regs (struct frame_info *fi)
{
return fi->saved_regs;
}
@ -986,16 +986,16 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame,
struct frame_info *frame = next_frame->prev;
gdb_assert (frame != NULL);
if (get_frame_saved_regs (frame) == NULL)
if (deprecated_get_frame_saved_regs (frame) == NULL)
{
/* If nothing's initialized the saved regs, do it now. */
gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
gdb_assert (get_frame_saved_regs (frame) != NULL);
gdb_assert (deprecated_get_frame_saved_regs (frame) != NULL);
}
if (get_frame_saved_regs (frame) != NULL
&& get_frame_saved_regs (frame)[regnum] != 0)
if (deprecated_get_frame_saved_regs (frame) != NULL
&& deprecated_get_frame_saved_regs (frame)[regnum] != 0)
{
if (regnum == SP_REGNUM)
{
@ -1008,7 +1008,7 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame,
/* NOTE: cagney/2003-05-09: In-lined store_address with
it's body - store_unsigned_integer. */
store_unsigned_integer (bufferp, REGISTER_RAW_SIZE (regnum),
get_frame_saved_regs (frame)[regnum]);
deprecated_get_frame_saved_regs (frame)[regnum]);
}
else
{
@ -1016,7 +1016,7 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame,
a local copy of its value. */
*optimizedp = 0;
*lvalp = lval_memory;
*addrp = get_frame_saved_regs (frame)[regnum];
*addrp = deprecated_get_frame_saved_regs (frame)[regnum];
*realnump = -1;
if (bufferp != NULL)
{
@ -1035,13 +1035,13 @@ legacy_saved_regs_prev_register (struct frame_info *next_frame,
{
regs[regnum]
= frame_obstack_zalloc (REGISTER_RAW_SIZE (regnum));
read_memory (get_frame_saved_regs (frame)[regnum], regs[regnum],
read_memory (deprecated_get_frame_saved_regs (frame)[regnum], regs[regnum],
REGISTER_RAW_SIZE (regnum));
}
memcpy (bufferp, regs[regnum], REGISTER_RAW_SIZE (regnum));
#else
/* Read the value in from memory. */
read_memory (get_frame_saved_regs (frame)[regnum], bufferp,
read_memory (deprecated_get_frame_saved_regs (frame)[regnum], bufferp,
REGISTER_RAW_SIZE (regnum));
#endif
}
@ -1139,8 +1139,8 @@ deprecated_generic_get_saved_register (char *raw_buffer, int *optimized,
}
DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
if (get_frame_saved_regs (frame) != NULL
&& get_frame_saved_regs (frame)[regnum] != 0)
if (deprecated_get_frame_saved_regs (frame) != NULL
&& deprecated_get_frame_saved_regs (frame)[regnum] != 0)
{
if (lval) /* found it saved on the stack */
*lval = lval_memory;
@ -1151,14 +1151,14 @@ deprecated_generic_get_saved_register (char *raw_buffer, int *optimized,
with it's body - store_unsigned_integer. */
store_unsigned_integer (raw_buffer,
REGISTER_RAW_SIZE (regnum),
get_frame_saved_regs (frame)[regnum]);
deprecated_get_frame_saved_regs (frame)[regnum]);
}
else
{
if (addrp) /* any other register */
*addrp = get_frame_saved_regs (frame)[regnum];
*addrp = deprecated_get_frame_saved_regs (frame)[regnum];
if (raw_buffer)
read_memory (get_frame_saved_regs (frame)[regnum], raw_buffer,
read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer,
REGISTER_RAW_SIZE (regnum));
}
return;

2
gdb/frame.h
View File

@ -671,7 +671,7 @@ extern struct frame_extra_info *get_frame_extra_info (struct frame_info *fi);
SP_REGNUM where the value of the register in the previous frame is
stored). */
extern CORE_ADDR *frame_saved_regs_zalloc (struct frame_info *);
extern CORE_ADDR *get_frame_saved_regs (struct frame_info *);
extern CORE_ADDR *deprecated_get_frame_saved_regs (struct frame_info *);
/* FIXME: cagney/2002-12-06: Has the PC in the current frame changed?
"infrun.c", Thanks to DECR_PC_AFTER_BREAK, can change the PC after

12
gdb/h8300-tdep.c
View File

@ -478,7 +478,7 @@ h8300_frame_init_saved_regs (struct frame_info *fi)
{
CORE_ADDR func_addr, func_end;
if (!get_frame_saved_regs (fi))
if (!deprecated_get_frame_saved_regs (fi))
{
frame_saved_regs_zalloc (fi);
@ -492,7 +492,7 @@ h8300_frame_init_saved_regs (struct frame_info *fi)
? sal.end : get_frame_pc (fi);
/* This will fill in fields in fi. */
h8300_examine_prologue (func_addr, limit, get_frame_base (fi),
get_frame_saved_regs (fi), fi);
deprecated_get_frame_saved_regs (fi), fi);
}
/* Else we're out of luck (can't debug completely stripped code).
FIXME. */
@ -521,7 +521,7 @@ h8300_frame_chain (struct frame_info *thisframe)
E_PC_REGNUM);
return get_frame_base (thisframe);
}
return get_frame_saved_regs (thisframe)[E_SP_REGNUM];
return deprecated_get_frame_saved_regs (thisframe)[E_SP_REGNUM];
}
/* Return the saved PC from this frame.
@ -743,11 +743,11 @@ h8300_pop_frame (void)
{
/* Don't forget E_SP_REGNUM is a frame_saved_regs struct is the
actual value we want, not the address of the value we want. */
if (get_frame_saved_regs (frame)[regno] && regno != E_SP_REGNUM)
if (deprecated_get_frame_saved_regs (frame)[regno] && regno != E_SP_REGNUM)
write_register (regno,
read_memory_integer
(get_frame_saved_regs (frame)[regno], BINWORD));
else if (get_frame_saved_regs (frame)[regno] && regno == E_SP_REGNUM)
(deprecated_get_frame_saved_regs (frame)[regno], BINWORD));
else if (deprecated_get_frame_saved_regs (frame)[regno] && regno == E_SP_REGNUM)
write_register (regno, get_frame_base (frame) + 2 * BINWORD);
}

16
gdb/hppa-tdep.c
View File

@ -1090,7 +1090,7 @@ hppa_frame_saved_pc (struct frame_info *frame)
{
CORE_ADDR *saved_regs;
hppa_frame_init_saved_regs (get_next_frame (frame));
saved_regs = get_frame_saved_regs (get_next_frame (frame));
saved_regs = deprecated_get_frame_saved_regs (get_next_frame (frame));
if (read_memory_integer (saved_regs[FLAGS_REGNUM],
TARGET_PTR_BIT / 8) & 0x2)
{
@ -1130,7 +1130,7 @@ hppa_frame_saved_pc (struct frame_info *frame)
{
CORE_ADDR *saved_regs;
hppa_frame_init_saved_regs (get_next_frame (frame));
saved_regs = get_frame_saved_regs (get_next_frame (frame));
saved_regs = deprecated_get_frame_saved_regs (get_next_frame (frame));
if (read_memory_integer (saved_regs[FLAGS_REGNUM],
TARGET_PTR_BIT / 8) & 0x2)
{
@ -1404,7 +1404,7 @@ hppa_frame_chain (struct frame_info *frame)
in optimized code, GCC often doesn't actually save r3.
We'll discover this if we look at the prologue. */
hppa_frame_init_saved_regs (tmp_frame);
saved_regs = get_frame_saved_regs (tmp_frame);
saved_regs = deprecated_get_frame_saved_regs (tmp_frame);
saved_regs_frame = tmp_frame;
/* If we have an address for r3, that's good. */
@ -1455,7 +1455,7 @@ hppa_frame_chain (struct frame_info *frame)
if (tmp_frame != saved_regs_frame)
{
hppa_frame_init_saved_regs (tmp_frame);
saved_regs = get_frame_saved_regs (tmp_frame);
saved_regs = deprecated_get_frame_saved_regs (tmp_frame);
}
/* Abominable hack. */
@ -1493,7 +1493,7 @@ hppa_frame_chain (struct frame_info *frame)
if (tmp_frame != saved_regs_frame)
{
hppa_frame_init_saved_regs (tmp_frame);
saved_regs = get_frame_saved_regs (tmp_frame);
saved_regs = deprecated_get_frame_saved_regs (tmp_frame);
}
/* Abominable hack. See above. */
@ -1698,7 +1698,7 @@ hppa_pop_frame (void)
fp = get_frame_base (frame);
hppa_frame_init_saved_regs (frame);
fsr = get_frame_saved_regs (frame);
fsr = deprecated_get_frame_saved_regs (frame);
#ifndef NO_PC_SPACE_QUEUE_RESTORE
if (fsr[IPSW_REGNUM]) /* Restoring a call dummy frame */
@ -4248,9 +4248,9 @@ hppa_frame_find_saved_regs (struct frame_info *frame_info,
void
hppa_frame_init_saved_regs (struct frame_info *frame)
{
if (get_frame_saved_regs (frame) == NULL)
if (deprecated_get_frame_saved_regs (frame) == NULL)
frame_saved_regs_zalloc (frame);
hppa_frame_find_saved_regs (frame, get_frame_saved_regs (frame));
hppa_frame_find_saved_regs (frame, deprecated_get_frame_saved_regs (frame));
}
/* Exception handling support for the HP-UX ANSI C++ compiler.

16
gdb/mcore-tdep.c
View File

@ -265,7 +265,7 @@ analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
deprecated_update_frame_base_hack (dummy, frame);
get_frame_extra_info (dummy)->status = 0;
get_frame_extra_info (dummy)->framesize = 0;
memset (get_frame_saved_regs (dummy), '\000', SIZEOF_FRAME_SAVED_REGS);
memset (deprecated_get_frame_saved_regs (dummy), '\000', SIZEOF_FRAME_SAVED_REGS);
mcore_analyze_prologue (dummy, 0, 0);
return dummy;
}
@ -590,7 +590,7 @@ mcore_analyze_prologue (struct frame_info *fi, CORE_ADDR pc, int skip_prologue)
{
if (register_offsets[rn] >= 0)
{
get_frame_saved_regs (fi)[rn] = get_frame_base (fi) - register_offsets[rn];
deprecated_get_frame_saved_regs (fi)[rn] = get_frame_base (fi) - register_offsets[rn];
mcore_insn_debug (("Saved register %s stored at 0x%08x, value=0x%08x\n",
mcore_register_names[rn], fi->saved_regs[rn],
read_memory_integer (fi->saved_regs[rn], 4)));
@ -639,11 +639,11 @@ mcore_frame_chain (struct frame_info * fi)
int fp = get_frame_extra_info (dummy)->fp_regnum;
/* Our caller has a frame pointer. */
if (get_frame_saved_regs (fi)[fp] != 0)
if (deprecated_get_frame_saved_regs (fi)[fp] != 0)
{
/* 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],
callers_addr = read_memory_integer (deprecated_get_frame_saved_regs (fi)[fp],
DEPRECATED_REGISTER_SIZE)
+ get_frame_extra_info (dummy)->framesize;
}
@ -726,8 +726,8 @@ mcore_find_callers_reg (struct frame_info *fi, int regnum)
get_frame_base (fi)))
return deprecated_read_register_dummy (get_frame_pc (fi),
get_frame_base (fi), regnum);
else if (get_frame_saved_regs (fi)[regnum] != 0)
return read_memory_integer (get_frame_saved_regs (fi)[regnum],
else if (deprecated_get_frame_saved_regs (fi)[regnum] != 0)
return read_memory_integer (deprecated_get_frame_saved_regs (fi)[regnum],
DEPRECATED_REGISTER_SIZE);
}
@ -770,11 +770,11 @@ mcore_pop_frame (void)
/* Restore any saved registers. */
for (rn = 0; rn < NUM_REGS; rn++)
{
if (get_frame_saved_regs (fi)[rn] != 0)
if (deprecated_get_frame_saved_regs (fi)[rn] != 0)
{
ULONGEST value;
value = read_memory_unsigned_integer (get_frame_saved_regs (fi)[rn],
value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[rn],
DEPRECATED_REGISTER_SIZE);
write_register (rn, value);
}

10
gdb/mips-tdep.c
View File

@ -1570,7 +1570,7 @@ mips_find_saved_regs (struct frame_info *fci)
t_inst inst;
CORE_ADDR *saved_regs;
if (get_frame_saved_regs (fci) != NULL)
if (deprecated_get_frame_saved_regs (fci) != NULL)
return;
saved_regs = frame_saved_regs_zalloc (fci);
@ -2733,7 +2733,7 @@ mips_init_extra_frame_info (int fromleaf, struct frame_info *fci)
get_frame_base (fci));
set_reg_offset (temp_saved_regs, PC_REGNUM,
temp_saved_regs[RA_REGNUM]);
memcpy (get_frame_saved_regs (fci), temp_saved_regs,
memcpy (deprecated_get_frame_saved_regs (fci), temp_saved_regs,
SIZEOF_FRAME_SAVED_REGS);
}
}
@ -3957,18 +3957,18 @@ mips_pop_frame (void)
mips_find_saved_regs (frame);
for (regnum = 0; regnum < NUM_REGS; regnum++)
if (regnum != SP_REGNUM && regnum != PC_REGNUM
&& get_frame_saved_regs (frame)[regnum])
&& deprecated_get_frame_saved_regs (frame)[regnum])
{
/* Floating point registers must not be sign extended,
in case MIPS_SAVED_REGSIZE = 4 but sizeof (FP0_REGNUM) == 8. */
if (FP0_REGNUM <= regnum && regnum < FP0_REGNUM + 32)
write_register (regnum,
read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
MIPS_SAVED_REGSIZE));
else
write_register (regnum,
read_memory_integer (get_frame_saved_regs (frame)[regnum],
read_memory_integer (deprecated_get_frame_saved_regs (frame)[regnum],
MIPS_SAVED_REGSIZE));
}

60
gdb/mn10300-tdep.c
View File

@ -169,7 +169,7 @@ analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
deprecated_update_frame_base_hack (dummy, frame);
get_frame_extra_info (dummy)->status = 0;
get_frame_extra_info (dummy)->stack_size = 0;
memset (get_frame_saved_regs (dummy), '\000', SIZEOF_FRAME_SAVED_REGS);
memset (deprecated_get_frame_saved_regs (dummy), '\000', SIZEOF_FRAME_SAVED_REGS);
mn10300_analyze_prologue (dummy, pc);
return dummy;
}
@ -237,59 +237,59 @@ set_movm_offsets (struct frame_info *fi, int movm_args)
/* The `other' bit leaves a blank area of four bytes at the
beginning of its block of saved registers, making it 32 bytes
long in total. */
get_frame_saved_regs (fi)[LAR_REGNUM] = get_frame_base (fi) + offset + 4;
get_frame_saved_regs (fi)[LIR_REGNUM] = get_frame_base (fi) + offset + 8;
get_frame_saved_regs (fi)[MDR_REGNUM] = get_frame_base (fi) + offset + 12;
get_frame_saved_regs (fi)[A0_REGNUM + 1] = get_frame_base (fi) + offset + 16;
get_frame_saved_regs (fi)[A0_REGNUM] = get_frame_base (fi) + offset + 20;
get_frame_saved_regs (fi)[D0_REGNUM + 1] = get_frame_base (fi) + offset + 24;
get_frame_saved_regs (fi)[D0_REGNUM] = get_frame_base (fi) + offset + 28;
deprecated_get_frame_saved_regs (fi)[LAR_REGNUM] = get_frame_base (fi) + offset + 4;
deprecated_get_frame_saved_regs (fi)[LIR_REGNUM] = get_frame_base (fi) + offset + 8;
deprecated_get_frame_saved_regs (fi)[MDR_REGNUM] = get_frame_base (fi) + offset + 12;
deprecated_get_frame_saved_regs (fi)[A0_REGNUM + 1] = get_frame_base (fi) + offset + 16;
deprecated_get_frame_saved_regs (fi)[A0_REGNUM] = get_frame_base (fi) + offset + 20;
deprecated_get_frame_saved_regs (fi)[D0_REGNUM + 1] = get_frame_base (fi) + offset + 24;
deprecated_get_frame_saved_regs (fi)[D0_REGNUM] = get_frame_base (fi) + offset + 28;
offset += 32;
}
if (movm_args & movm_a3_bit)
{
get_frame_saved_regs (fi)[A3_REGNUM] = get_frame_base (fi) + offset;
deprecated_get_frame_saved_regs (fi)[A3_REGNUM] = get_frame_base (fi) + offset;
offset += 4;
}
if (movm_args & movm_a2_bit)
{
get_frame_saved_regs (fi)[A2_REGNUM] = get_frame_base (fi) + offset;
deprecated_get_frame_saved_regs (fi)[A2_REGNUM] = get_frame_base (fi) + offset;
offset += 4;
}
if (movm_args & movm_d3_bit)
{
get_frame_saved_regs (fi)[D3_REGNUM] = get_frame_base (fi) + offset;
deprecated_get_frame_saved_regs (fi)[D3_REGNUM] = get_frame_base (fi) + offset;
offset += 4;
}
if (movm_args & movm_d2_bit)
{
get_frame_saved_regs (fi)[D2_REGNUM] = get_frame_base (fi) + offset;
deprecated_get_frame_saved_regs (fi)[D2_REGNUM] = get_frame_base (fi) + offset;
offset += 4;
}
if (AM33_MODE)
{
if (movm_args & movm_exother_bit)
{
get_frame_saved_regs (fi)[MCVF_REGNUM] = get_frame_base (fi) + offset;
get_frame_saved_regs (fi)[MCRL_REGNUM] = get_frame_base (fi) + offset + 4;
get_frame_saved_regs (fi)[MCRH_REGNUM] = get_frame_base (fi) + offset + 8;
get_frame_saved_regs (fi)[MDRQ_REGNUM] = get_frame_base (fi) + offset + 12;
get_frame_saved_regs (fi)[E0_REGNUM + 1] = get_frame_base (fi) + offset + 16;
get_frame_saved_regs (fi)[E0_REGNUM + 0] = get_frame_base (fi) + offset + 20;
deprecated_get_frame_saved_regs (fi)[MCVF_REGNUM] = get_frame_base (fi) + offset;
deprecated_get_frame_saved_regs (fi)[MCRL_REGNUM] = get_frame_base (fi) + offset + 4;
deprecated_get_frame_saved_regs (fi)[MCRH_REGNUM] = get_frame_base (fi) + offset + 8;
deprecated_get_frame_saved_regs (fi)[MDRQ_REGNUM] = get_frame_base (fi) + offset + 12;
deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 1] = get_frame_base (fi) + offset + 16;
deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 0] = get_frame_base (fi) + offset + 20;
offset += 24;
}
if (movm_args & movm_exreg1_bit)
{
get_frame_saved_regs (fi)[E0_REGNUM + 7] = get_frame_base (fi) + offset;
get_frame_saved_regs (fi)[E0_REGNUM + 6] = get_frame_base (fi) + offset + 4;
get_frame_saved_regs (fi)[E0_REGNUM + 5] = get_frame_base (fi) + offset + 8;
get_frame_saved_regs (fi)[E0_REGNUM + 4] = get_frame_base (fi) + offset + 12;
deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 7] = get_frame_base (fi) + offset;
deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 6] = get_frame_base (fi) + offset + 4;
deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 5] = get_frame_base (fi) + offset + 8;
deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 4] = get_frame_base (fi) + offset + 12;
offset += 16;
}
if (movm_args & movm_exreg0_bit)
{
get_frame_saved_regs (fi)[E0_REGNUM + 3] = get_frame_base (fi) + offset;
get_frame_saved_regs (fi)[E0_REGNUM + 2] = get_frame_base (fi) + offset + 4;
deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 3] = get_frame_base (fi) + offset;
deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 2] = get_frame_base (fi) + offset + 4;
offset += 8;
}
}
@ -648,14 +648,14 @@ saved_regs_size (struct frame_info *fi)
/* Reserve four bytes for every register saved. */
for (i = 0; i < NUM_REGS; i++)
if (get_frame_saved_regs (fi)[i])
if (deprecated_get_frame_saved_regs (fi)[i])
adjust += 4;
/* If we saved LIR, then it's most likely we used a `movm'
instruction with the `other' bit set, in which case the SP is
decremented by an extra four bytes, "to simplify calculation
of the transfer area", according to the processor manual. */
if (get_frame_saved_regs (fi)[LIR_REGNUM])
if (deprecated_get_frame_saved_regs (fi)[LIR_REGNUM])
adjust += 4;
return adjust;
@ -705,8 +705,8 @@ mn10300_frame_chain (struct frame_info *fi)
{
/* Our caller has a frame pointer. So find the frame in $a3 or
in the stack. */
if (get_frame_saved_regs (fi)[A3_REGNUM])
return (read_memory_integer (get_frame_saved_regs (fi)[A3_REGNUM],
if (deprecated_get_frame_saved_regs (fi)[A3_REGNUM])
return (read_memory_integer (deprecated_get_frame_saved_regs (fi)[A3_REGNUM],
DEPRECATED_REGISTER_SIZE));
else
return read_register (A3_REGNUM);
@ -744,11 +744,11 @@ mn10300_pop_frame_regular (struct frame_info *frame)
/* Restore any saved registers. */
for (regnum = 0; regnum < NUM_REGS; regnum++)
if (get_frame_saved_regs (frame)[regnum] != 0)
if (deprecated_get_frame_saved_regs (frame)[regnum] != 0)
{
ULONGEST value;
value = read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
REGISTER_RAW_SIZE (regnum));
write_register (regnum, value);
}

18
gdb/ns32k-tdep.c
View File

@ -370,7 +370,7 @@ ns32k_frame_init_saved_regs (struct frame_info *frame)
int localcount;
CORE_ADDR enter_addr, next_addr;
if (get_frame_saved_regs (frame))
if (deprecated_get_frame_saved_regs (frame))
return;
frame_saved_regs_zalloc (frame);
@ -385,18 +385,18 @@ ns32k_frame_init_saved_regs (struct frame_info *frame)
for (regnum = 0; regnum < 8; regnum++)
{
if (regmask & (1 << regnum))
get_frame_saved_regs (frame)[regnum] = next_addr -= 4;
deprecated_get_frame_saved_regs (frame)[regnum] = next_addr -= 4;
}
get_frame_saved_regs (frame)[SP_REGNUM] = get_frame_base (frame) + 4;
get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 4;
get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = read_memory_integer (get_frame_base (frame), 4);
deprecated_get_frame_saved_regs (frame)[SP_REGNUM] = get_frame_base (frame) + 4;
deprecated_get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 4;
deprecated_get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = read_memory_integer (get_frame_base (frame), 4);
}
else if (enter_addr == 1)
{
CORE_ADDR sp = read_register (SP_REGNUM);
get_frame_saved_regs (frame)[PC_REGNUM] = sp;
get_frame_saved_regs (frame)[SP_REGNUM] = sp + 4;
deprecated_get_frame_saved_regs (frame)[PC_REGNUM] = sp;
deprecated_get_frame_saved_regs (frame)[SP_REGNUM] = sp + 4;
}
}
@ -427,9 +427,9 @@ ns32k_pop_frame (void)
DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
for (regnum = 0; regnum < 8; regnum++)
if (get_frame_saved_regs (frame)[regnum])
if (deprecated_get_frame_saved_regs (frame)[regnum])
write_register (regnum,
read_memory_integer (get_frame_saved_regs (frame)[regnum], 4));
read_memory_integer (deprecated_get_frame_saved_regs (frame)[regnum], 4));
write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, 4));
write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));

20
gdb/ppc-linux-tdep.c
View File

@ -402,7 +402,7 @@ ppc_linux_frame_init_saved_regs (struct frame_info *fi)
{
CORE_ADDR regs_addr;
int i;
if (get_frame_saved_regs (fi))
if (deprecated_get_frame_saved_regs (fi))
return;
frame_saved_regs_zalloc (fi);
@ -410,24 +410,24 @@ ppc_linux_frame_init_saved_regs (struct frame_info *fi)
regs_addr =
read_memory_integer (get_frame_base (fi)
+ PPC_LINUX_REGS_PTR_OFFSET, 4);
get_frame_saved_regs (fi)[PC_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_NIP;
get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_ps_regnum] =
deprecated_get_frame_saved_regs (fi)[PC_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_NIP;
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_ps_regnum] =
regs_addr + 4 * PPC_LINUX_PT_MSR;
get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_cr_regnum] =
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_cr_regnum] =
regs_addr + 4 * PPC_LINUX_PT_CCR;
get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_lr_regnum] =
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_lr_regnum] =
regs_addr + 4 * PPC_LINUX_PT_LNK;
get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum] =
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_ctr_regnum] =
regs_addr + 4 * PPC_LINUX_PT_CTR;
get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_xer_regnum] =
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_xer_regnum] =
regs_addr + 4 * PPC_LINUX_PT_XER;
get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_mq_regnum] =
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_mq_regnum] =
regs_addr + 4 * PPC_LINUX_PT_MQ;
for (i = 0; i < 32; i++)
get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + i] =
deprecated_get_frame_saved_regs (fi)[gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + i] =
regs_addr + 4 * PPC_LINUX_PT_R0 + 4 * i;
for (i = 0; i < 32; i++)
get_frame_saved_regs (fi)[FP0_REGNUM + i] = regs_addr + 4 * PPC_LINUX_PT_FPR0 + 8 * i;
deprecated_get_frame_saved_regs (fi)[FP0_REGNUM + i] = regs_addr + 4 * PPC_LINUX_PT_FPR0 + 8 * i;
}
else
rs6000_frame_init_saved_regs (fi);

20
gdb/rs6000-tdep.c
View File

@ -1628,7 +1628,7 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
struct gdbarch_tdep * tdep = gdbarch_tdep (current_gdbarch);
int wordsize = tdep->wordsize;
if (get_frame_saved_regs (fi))
if (deprecated_get_frame_saved_regs (fi))
return;
if (fdatap == NULL)
@ -1670,7 +1670,7 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
CORE_ADDR fpr_addr = frame_addr + fdatap->fpr_offset;
for (i = fdatap->saved_fpr; i < 32; i++)
{
get_frame_saved_regs (fi)[FP0_REGNUM + i] = fpr_addr;
deprecated_get_frame_saved_regs (fi)[FP0_REGNUM + i] = fpr_addr;
fpr_addr += 8;
}
}
@ -1684,7 +1684,7 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
CORE_ADDR gpr_addr = frame_addr + fdatap->gpr_offset;
for (i = fdatap->saved_gpr; i < 32; i++)
{
get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = gpr_addr;
deprecated_get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = gpr_addr;
gpr_addr += wordsize;
}
}
@ -1699,7 +1699,7 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
CORE_ADDR vr_addr = frame_addr + fdatap->vr_offset;
for (i = fdatap->saved_vr; i < 32; i++)
{
get_frame_saved_regs (fi)[tdep->ppc_vr0_regnum + i] = vr_addr;
deprecated_get_frame_saved_regs (fi)[tdep->ppc_vr0_regnum + i] = vr_addr;
vr_addr += REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
}
}
@ -1715,8 +1715,8 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
CORE_ADDR ev_addr = frame_addr + fdatap->ev_offset;
for (i = fdatap->saved_ev; i < 32; i++)
{
get_frame_saved_regs (fi)[tdep->ppc_ev0_regnum + i] = ev_addr;
get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = ev_addr + 4;
deprecated_get_frame_saved_regs (fi)[tdep->ppc_ev0_regnum + i] = ev_addr;
deprecated_get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = ev_addr + 4;
ev_addr += REGISTER_RAW_SIZE (tdep->ppc_ev0_regnum);
}
}
@ -1725,17 +1725,17 @@ frame_get_saved_regs (struct frame_info *fi, struct rs6000_framedata *fdatap)
/* If != 0, fdatap->cr_offset is the offset from the frame that holds
the CR. */
if (fdatap->cr_offset != 0)
get_frame_saved_regs (fi)[tdep->ppc_cr_regnum] = frame_addr + fdatap->cr_offset;
deprecated_get_frame_saved_regs (fi)[tdep->ppc_cr_regnum] = frame_addr + fdatap->cr_offset;
/* If != 0, fdatap->lr_offset is the offset from the frame that holds
the LR. */
if (fdatap->lr_offset != 0)
get_frame_saved_regs (fi)[tdep->ppc_lr_regnum] = frame_addr + fdatap->lr_offset;
deprecated_get_frame_saved_regs (fi)[tdep->ppc_lr_regnum] = frame_addr + fdatap->lr_offset;
/* If != 0, fdatap->vrsave_offset is the offset from the frame that holds
the VRSAVE. */
if (fdatap->vrsave_offset != 0)
get_frame_saved_regs (fi)[tdep->ppc_vrsave_regnum] = frame_addr + fdatap->vrsave_offset;
deprecated_get_frame_saved_regs (fi)[tdep->ppc_vrsave_regnum] = frame_addr + fdatap->vrsave_offset;
}
/* Return the address of a frame. This is the inital %sp value when the frame
@ -1762,7 +1762,7 @@ frame_initial_stack_address (struct frame_info *fi)
/* If saved registers of this frame are not known yet, read and
cache them. */
if (!get_frame_saved_regs (fi))
if (!deprecated_get_frame_saved_regs (fi))
frame_get_saved_regs (fi, &fdata);
/* If no alloca register used, then fi->frame is the value of the %sp for

30
gdb/s390-tdep.c
View File

@ -901,7 +901,7 @@ s390_get_signal_frame_info (struct frame_info *fi)
&& get_frame_extra_info (next_frame)->sigcontext)
{
/* We're definitely backtracing from a signal handler. */
CORE_ADDR *saved_regs = get_frame_saved_regs (fi);
CORE_ADDR *saved_regs = deprecated_get_frame_saved_regs (fi);
CORE_ADDR save_reg_addr = (get_frame_extra_info (next_frame)->sigcontext
+ DEPRECATED_REGISTER_BYTE (S390_GP0_REGNUM));
int reg;
@ -1428,12 +1428,12 @@ s390_get_frame_info (CORE_ADDR start_pc,
- the analysis gave us enough information to actually figure it
out. */
if (fi
&& get_frame_saved_regs (fi)
&& deprecated_get_frame_saved_regs (fi)
&& original_sp != -1)
{
int slot_num;
CORE_ADDR slot_addr;
CORE_ADDR *saved_regs = get_frame_saved_regs (fi);
CORE_ADDR *saved_regs = deprecated_get_frame_saved_regs (fi);
/* Scan the spill array; if a spill slot says it holds the
original value of some register, then record that slot's
@ -1719,7 +1719,7 @@ s390_frame_init_saved_regs (struct frame_info *fi)
int quick;
if (get_frame_saved_regs (fi) == NULL)
if (deprecated_get_frame_saved_regs (fi) == NULL)
{
/* zalloc memsets the saved regs */
frame_saved_regs_zalloc (fi);
@ -1754,10 +1754,10 @@ s390_frame_saved_pc_nofix (struct frame_info *fi)
{
get_frame_extra_info (fi)->saved_pc_valid = 1;
if (get_frame_extra_info (fi)->good_prologue
&& get_frame_saved_regs (fi)[S390_RETADDR_REGNUM])
&& deprecated_get_frame_saved_regs (fi)[S390_RETADDR_REGNUM])
get_frame_extra_info (fi)->saved_pc
= ADDR_BITS_REMOVE (read_memory_integer
(get_frame_saved_regs (fi)[S390_RETADDR_REGNUM],
(deprecated_get_frame_saved_regs (fi)[S390_RETADDR_REGNUM],
S390_GPR_SIZE));
else
get_frame_extra_info (fi)->saved_pc
@ -1841,24 +1841,24 @@ s390_frame_chain (struct frame_info *thisframe)
}
else
{
if (get_frame_saved_regs (thisframe))
if (deprecated_get_frame_saved_regs (thisframe))
{
int regno;
if (prev_fextra_info.frame_pointer_saved_pc
&& get_frame_saved_regs (thisframe)[S390_FRAME_REGNUM])
&& deprecated_get_frame_saved_regs (thisframe)[S390_FRAME_REGNUM])
regno = S390_FRAME_REGNUM;
else
regno = S390_SP_REGNUM;
if (get_frame_saved_regs (thisframe)[regno])
if (deprecated_get_frame_saved_regs (thisframe)[regno])
{
/* The SP's entry of `saved_regs' is special. */
if (regno == S390_SP_REGNUM)
prev_fp = get_frame_saved_regs (thisframe)[regno];
prev_fp = deprecated_get_frame_saved_regs (thisframe)[regno];
else
prev_fp =
read_memory_integer (get_frame_saved_regs (thisframe)[regno],
read_memory_integer (deprecated_get_frame_saved_regs (thisframe)[regno],
S390_GPR_SIZE);
}
}
@ -1992,14 +1992,14 @@ s390_pop_frame_regular (struct frame_info *frame)
write_register (S390_PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
/* Restore any saved registers. */
if (get_frame_saved_regs (frame))
if (deprecated_get_frame_saved_regs (frame))
{
for (regnum = 0; regnum < NUM_REGS; regnum++)
if (get_frame_saved_regs (frame)[regnum] != 0)
if (deprecated_get_frame_saved_regs (frame)[regnum] != 0)
{
ULONGEST value;
value = read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
REGISTER_RAW_SIZE (regnum));
write_register (regnum, value);
}
@ -2007,7 +2007,7 @@ s390_pop_frame_regular (struct frame_info *frame)
/* Actually cut back the stack. Remember that the SP's element of
saved_regs is the old SP itself, not the address at which it is
saved. */
write_register (S390_SP_REGNUM, get_frame_saved_regs (frame)[S390_SP_REGNUM]);
write_register (S390_SP_REGNUM, deprecated_get_frame_saved_regs (frame)[S390_SP_REGNUM]);
}
/* Throw away any cached frame information. */

34
gdb/sh64-tdep.c
View File

@ -782,13 +782,13 @@ sh64_get_saved_pr (struct frame_info *fi, int pr_regnum)
media_mode = pc_is_isa32 (get_frame_pc (fi));
if (get_frame_saved_regs (fi)[pr_regnum] != 0)
if (deprecated_get_frame_saved_regs (fi)[pr_regnum] != 0)
{
int gdb_reg_num = translate_insn_rn (pr_regnum, media_mode);
int size = ((gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
? 4
: REGISTER_RAW_SIZE (gdb_reg_num));
return read_memory_integer (get_frame_saved_regs (fi)[pr_regnum], size);
return read_memory_integer (deprecated_get_frame_saved_regs (fi)[pr_regnum], size);
}
}
return read_register (pr_regnum);
@ -1027,17 +1027,17 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi)
char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi), get_frame_base (fi));
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (get_frame_saved_regs (fi) == NULL)
if (deprecated_get_frame_saved_regs (fi) == NULL)
frame_saved_regs_zalloc (fi);
else
memset (get_frame_saved_regs (fi), 0, SIZEOF_FRAME_SAVED_REGS);
memset (deprecated_get_frame_saved_regs (fi), 0, SIZEOF_FRAME_SAVED_REGS);
if (dummy_regs)
{
/* DANGER! This is ONLY going to work if the char buffer format of
the saved registers is byte-for-byte identical to the
CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */
memcpy (get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS);
memcpy (deprecated_get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS);
return;
}
@ -1185,11 +1185,11 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi)
/* Watch out! saved_regs is only for the real registers, and
doesn't include space for the pseudo registers. */
get_frame_saved_regs (fi)[register_number]= get_frame_base (fi) - where[rn] + depth;
deprecated_get_frame_saved_regs (fi)[register_number]= get_frame_base (fi) - where[rn] + depth;
}
else
get_frame_saved_regs (fi)[register_number] = 0;
deprecated_get_frame_saved_regs (fi)[register_number] = 0;
}
if (have_fp)
@ -1206,10 +1206,10 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi)
size = 4;
else
size = REGISTER_RAW_SIZE (fp_regnum);
get_frame_saved_regs (fi)[sp_regnum] = read_memory_integer (get_frame_saved_regs (fi)[fp_regnum], size);
deprecated_get_frame_saved_regs (fi)[sp_regnum] = read_memory_integer (deprecated_get_frame_saved_regs (fi)[fp_regnum], size);
}
else
get_frame_saved_regs (fi)[sp_regnum] = get_frame_base (fi);
deprecated_get_frame_saved_regs (fi)[sp_regnum] = get_frame_base (fi);
get_frame_extra_info (fi)->f_offset = depth - where[fp_regnum];
}
@ -1298,8 +1298,8 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
}
DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
if (get_frame_saved_regs (frame) != NULL
&& get_frame_saved_regs (frame)[regnum] != 0)
if (deprecated_get_frame_saved_regs (frame) != NULL
&& deprecated_get_frame_saved_regs (frame)[regnum] != 0)
{
if (lval) /* found it saved on the stack */
*lval = lval_memory;
@ -1307,13 +1307,13 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
{
if (raw_buffer) /* SP register treated specially */
store_unsigned_integer (raw_buffer, REGISTER_RAW_SIZE (regnum),
get_frame_saved_regs (frame)[regnum]);
deprecated_get_frame_saved_regs (frame)[regnum]);
}
else
{ /* any other register */
if (addrp)
*addrp = get_frame_saved_regs (frame)[regnum];
*addrp = deprecated_get_frame_saved_regs (frame)[regnum];
if (raw_buffer)
{
int size;
@ -1324,9 +1324,9 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
else
size = REGISTER_RAW_SIZE (live_regnum);
if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
read_memory (get_frame_saved_regs (frame)[regnum], raw_buffer, size);
read_memory (deprecated_get_frame_saved_regs (frame)[regnum], raw_buffer, size);
else
read_memory (get_frame_saved_regs (frame)[regnum],
read_memory (deprecated_get_frame_saved_regs (frame)[regnum],
raw_buffer
+ REGISTER_RAW_SIZE (live_regnum)
- size,
@ -1384,7 +1384,7 @@ sh64_pop_frame (void)
/* Copy regs from where they were saved in the frame */
for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
if (get_frame_saved_regs (frame)[regnum])
if (deprecated_get_frame_saved_regs (frame)[regnum])
{
int size;
if (tdep->sh_abi == SH_ABI_32
@ -1395,7 +1395,7 @@ sh64_pop_frame (void)
size = REGISTER_RAW_SIZE (translate_insn_rn (regnum,
media_mode));
write_register (regnum,
read_memory_integer (get_frame_saved_regs (frame)[regnum],
read_memory_integer (deprecated_get_frame_saved_regs (frame)[regnum],
size));
}

2
gdb/stack.c
View File

@ -1022,7 +1022,7 @@ frame_info (char *addr_exp, int from_tty)
}
if (DEPRECATED_FRAME_INIT_SAVED_REGS_P ()
&& get_frame_saved_regs (fi) == NULL)
&& deprecated_get_frame_saved_regs (fi) == NULL)
DEPRECATED_FRAME_INIT_SAVED_REGS (fi);
/* Print as much information as possible on the location of all the
registers. */

14
gdb/v850-tdep.c
View File

@ -810,8 +810,8 @@ v850_find_callers_reg (struct frame_info *fi, int regnum)
get_frame_base (fi)))
return deprecated_read_register_dummy (get_frame_pc (fi),
get_frame_base (fi), regnum);
else if (get_frame_saved_regs (fi)[regnum] != 0)
return read_memory_unsigned_integer (get_frame_saved_regs (fi)[regnum],
else if (deprecated_get_frame_saved_regs (fi)[regnum] != 0)
return read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[regnum],
v850_register_raw_size (regnum));
return read_register (regnum);
@ -900,9 +900,9 @@ v850_pop_frame (void)
write_register (E_PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
for (regnum = 0; regnum < E_NUM_REGS; regnum++)
if (get_frame_saved_regs (frame)[regnum] != 0)
if (deprecated_get_frame_saved_regs (frame)[regnum] != 0)
write_register (regnum,
read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
v850_register_raw_size (regnum)));
write_register (E_SP_REGNUM, get_frame_base (frame));
@ -1117,7 +1117,7 @@ v850_frame_init_saved_regs (struct frame_info *fi)
struct pifsr pifsrs[E_NUM_REGS + 1], *pifsr;
CORE_ADDR func_addr, func_end;
if (!get_frame_saved_regs (fi))
if (!deprecated_get_frame_saved_regs (fi))
{
frame_saved_regs_zalloc (fi);
@ -1140,10 +1140,10 @@ v850_frame_init_saved_regs (struct frame_info *fi)
for (pifsr = pifsrs; pifsr->framereg; pifsr++)
{
get_frame_saved_regs (fi)[pifsr->reg] = pifsr->offset + get_frame_base (fi);
deprecated_get_frame_saved_regs (fi)[pifsr->reg] = pifsr->offset + get_frame_base (fi);
if (pifsr->framereg == E_SP_REGNUM)
get_frame_saved_regs (fi)[pifsr->reg] += pi.frameoffset;
deprecated_get_frame_saved_regs (fi)[pifsr->reg] += pi.frameoffset;
}
}
/* Else we're out of luck (can't debug completely stripped code).

16
gdb/vax-tdep.c
View File

@ -93,7 +93,7 @@ vax_frame_init_saved_regs (struct frame_info *frame)
int regnum, regmask;
CORE_ADDR next_addr;
if (get_frame_saved_regs (frame))
if (deprecated_get_frame_saved_regs (frame))
return;
frame_saved_regs_zalloc (frame);
@ -107,18 +107,18 @@ vax_frame_init_saved_regs (struct frame_info *frame)
for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
{
if (regmask & (1 << regnum))
get_frame_saved_regs (frame)[regnum] = next_addr += 4;
deprecated_get_frame_saved_regs (frame)[regnum] = next_addr += 4;
}
get_frame_saved_regs (frame)[SP_REGNUM] = next_addr + 4;
deprecated_get_frame_saved_regs (frame)[SP_REGNUM] = next_addr + 4;
if (regmask & (1 << DEPRECATED_FP_REGNUM))
get_frame_saved_regs (frame)[SP_REGNUM] +=
deprecated_get_frame_saved_regs (frame)[SP_REGNUM] +=
4 + (4 * read_memory_integer (next_addr + 4, 4));
get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 16;
get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = get_frame_base (frame) + 12;
get_frame_saved_regs (frame)[VAX_AP_REGNUM] = get_frame_base (frame) + 8;
get_frame_saved_regs (frame)[PS_REGNUM] = get_frame_base (frame) + 4;
deprecated_get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 16;
deprecated_get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = get_frame_base (frame) + 12;
deprecated_get_frame_saved_regs (frame)[VAX_AP_REGNUM] = get_frame_base (frame) + 8;
deprecated_get_frame_saved_regs (frame)[PS_REGNUM] = get_frame_base (frame) + 4;
}
/* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp. */

26
gdb/xstormy16-tdep.c
View File

@ -343,15 +343,15 @@ xstormy16_pop_frame (void)
{
/* Restore the saved regs. */
for (i = 0; i < NUM_REGS; i++)
if (get_frame_saved_regs (fi)[i])
if (deprecated_get_frame_saved_regs (fi)[i])
{
if (i == SP_REGNUM)
write_register (i, get_frame_saved_regs (fi)[i]);
write_register (i, deprecated_get_frame_saved_regs (fi)[i]);
else if (i == E_PC_REGNUM)
write_register (i, read_memory_integer (get_frame_saved_regs (fi)[i],
write_register (i, read_memory_integer (deprecated_get_frame_saved_regs (fi)[i],
xstormy16_pc_size));
else
write_register (i, read_memory_integer (get_frame_saved_regs (fi)[i],
write_register (i, read_memory_integer (deprecated_get_frame_saved_regs (fi)[i],
xstormy16_reg_size));
}
/* Restore the PC */
@ -492,7 +492,7 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
if (fi)
{
regnum = inst & 0x000f;
get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize;
deprecated_get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize;
get_frame_extra_info (fi)->framesize += xstormy16_reg_size;
}
}
@ -548,7 +548,7 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
if (offset & 0x0800)
offset -= 0x1000;
get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize + offset;
deprecated_get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize + offset;
}
next_addr += xstormy16_inst_size;
}
@ -595,12 +595,12 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
previous value would have been pushed). */
if (get_frame_extra_info (fi)->frameless_p)
{
get_frame_saved_regs (fi)[E_SP_REGNUM] = sp - get_frame_extra_info (fi)->framesize;
deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM] = sp - get_frame_extra_info (fi)->framesize;
deprecated_update_frame_base_hack (fi, sp);
}
else
{
get_frame_saved_regs (fi)[E_SP_REGNUM] = fp - get_frame_extra_info (fi)->framesize;
deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM] = fp - get_frame_extra_info (fi)->framesize;
deprecated_update_frame_base_hack (fi, fp);
}
@ -609,11 +609,11 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
sp, fp and framesize. We know the beginning of the frame
so we can translate the register offsets to real addresses. */
for (regnum = 0; regnum < E_SP_REGNUM; ++regnum)
if (get_frame_saved_regs (fi)[regnum])
get_frame_saved_regs (fi)[regnum] += get_frame_saved_regs (fi)[E_SP_REGNUM];
if (deprecated_get_frame_saved_regs (fi)[regnum])
deprecated_get_frame_saved_regs (fi)[regnum] += deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM];
/* Save address of PC on stack. */
get_frame_saved_regs (fi)[E_PC_REGNUM] = get_frame_saved_regs (fi)[E_SP_REGNUM];
deprecated_get_frame_saved_regs (fi)[E_PC_REGNUM] = deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM];
}
return next_addr;
@ -733,7 +733,7 @@ xstormy16_frame_init_saved_regs (struct frame_info *fi)
{
CORE_ADDR func_addr, func_end;
if (!get_frame_saved_regs (fi))
if (!deprecated_get_frame_saved_regs (fi))
{
frame_saved_regs_zalloc (fi);
@ -765,7 +765,7 @@ xstormy16_frame_saved_pc (struct frame_info *fi)
}
else
{
saved_pc = read_memory_unsigned_integer (get_frame_saved_regs (fi)[E_PC_REGNUM],
saved_pc = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[E_PC_REGNUM],
xstormy16_pc_size);
}