darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

2003-01-03 Andrew Cagney <ac131313@redhat.com>

Browse source 
* alpha-tdep.c: Use get_frame_saved_regs.
	* arm-tdep.c, avr-tdep.c, cris-tdep.c, d10v-tdep.c: Ditto.
	* h8300-tdep.c, i386-tdep.c, ia64-tdep.c, m68hc11-tdep.c: Ditto.
	* m68k-tdep.c, mcore-tdep.c, mips-tdep.c, mn10300-tdep.c: Ditto.
	* ns32k-tdep.c, s390-tdep.c, sh-tdep.c, v850-tdep.c: Ditto.
	* vax-tdep.c, xstormy16-tdep.c: Ditto.
This commit is contained in:
Andrew Cagney 2003-01-03 23:53:48 +00:00
parent 8dcde88743
commit b2fb46766e
20 changed files with 339 additions and 330 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
gdb/ChangeLog
View file

@ -1,3 +1,12 @@
2003-01-03 Andrew Cagney <ac131313@redhat.com>
* alpha-tdep.c: Use get_frame_saved_regs.
* arm-tdep.c, avr-tdep.c, cris-tdep.c, d10v-tdep.c: Ditto.
* h8300-tdep.c, i386-tdep.c, ia64-tdep.c, m68hc11-tdep.c: Ditto.
* m68k-tdep.c, mcore-tdep.c, mips-tdep.c, mn10300-tdep.c: Ditto.
* ns32k-tdep.c, s390-tdep.c, sh-tdep.c, v850-tdep.c: Ditto.
* vax-tdep.c, xstormy16-tdep.c: Ditto.
2003-01-03 Mark Kettenis <kettenis@gnu.org>
* configure.in: Remove all use of the SUBDIRS variable; add

43
gdb/alpha-tdep.c
View file

@ -389,14 +389,14 @@ alpha_find_saved_regs (struct frame_info *frame)
for (ireg = 0; ireg < 32; ireg++)
{
reg_position = sigcontext_addr + SIGFRAME_REGSAVE_OFF + ireg * 8;
frame->saved_regs[ireg] = reg_position;
get_frame_saved_regs (frame)[ireg] = reg_position;
}
for (ireg = 0; ireg < 32; ireg++)
{
reg_position = sigcontext_addr + SIGFRAME_FPREGSAVE_OFF + ireg * 8;
frame->saved_regs[FP0_REGNUM + ireg] = reg_position;
get_frame_saved_regs (frame)[FP0_REGNUM + ireg] = reg_position;
}
frame->saved_regs[PC_REGNUM] = sigcontext_addr + SIGFRAME_PC_OFF;
get_frame_saved_regs (frame)[PC_REGNUM] = sigcontext_addr + SIGFRAME_PC_OFF;
return;
}
@ -419,7 +419,7 @@ alpha_find_saved_regs (struct frame_info *frame)
register number. */
if (mask & (1 << returnreg))
{
frame->saved_regs[returnreg] = reg_position;
get_frame_saved_regs (frame)[returnreg] = reg_position;
reg_position += 8;
mask &= ~(1 << returnreg); /* Clear bit for RA so we
don't save again later. */
@ -428,7 +428,7 @@ alpha_find_saved_regs (struct frame_info *frame)
for (ireg = 0; ireg <= 31; ++ireg)
if (mask & (1 << ireg))
{
frame->saved_regs[ireg] = reg_position;
get_frame_saved_regs (frame)[ireg] = reg_position;
reg_position += 8;
}
@ -441,19 +441,19 @@ alpha_find_saved_regs (struct frame_info *frame)
for (ireg = 0; ireg <= 31; ++ireg)
if (mask & (1 << ireg))
{
frame->saved_regs[FP0_REGNUM + ireg] = reg_position;
get_frame_saved_regs (frame)[FP0_REGNUM + ireg] = reg_position;
reg_position += 8;
}
frame->saved_regs[PC_REGNUM] = frame->saved_regs[returnreg];
get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_saved_regs (frame)[returnreg];
}
static void
alpha_frame_init_saved_regs (struct frame_info *fi)
{
if (fi->saved_regs == NULL)
if (get_frame_saved_regs (fi) == NULL)
alpha_find_saved_regs (fi);
fi->saved_regs[SP_REGNUM] = fi->frame;
get_frame_saved_regs (fi)[SP_REGNUM] = fi->frame;
}
static CORE_ADDR
@ -475,10 +475,10 @@ read_next_frame_reg (struct frame_info *fi, int regno)
return fi->frame;
else
{
if (fi->saved_regs == NULL)
if (get_frame_saved_regs (fi) == NULL)
alpha_find_saved_regs (fi);
if (fi->saved_regs[regno])
return read_memory_integer (fi->saved_regs[regno], 8);
if (get_frame_saved_regs (fi)[regno])
return read_memory_integer (get_frame_saved_regs (fi)[regno], 8);
}
}
return read_register (regno);
@ -984,7 +984,9 @@ alpha_init_extra_frame_info (int fromleaf, struct frame_info *frame)
frame->extra_info = (struct frame_extra_info *)
frame_obstack_alloc (sizeof (struct frame_extra_info));
frame->saved_regs = NULL;
/* NOTE: cagney/2003-01-03: No need to set saved_regs to NULL,
always NULL by default. */
/* frame->saved_regs = NULL; */
frame->extra_info->localoff = 0;
frame->extra_info->pc_reg = ALPHA_RA_REGNUM;
frame->extra_info->proc_desc = proc_desc == &temp_proc_desc ? 0 : proc_desc;
@ -1028,12 +1030,11 @@ alpha_init_extra_frame_info (int fromleaf, struct frame_info *frame)
(CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
if (!PC_IN_SIGTRAMP (get_frame_pc (frame), name))
{
frame->saved_regs = (CORE_ADDR *)
frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
memcpy (frame->saved_regs, temp_saved_regs,
frame_saved_regs_zalloc (frame);
memcpy (get_frame_saved_regs (frame), temp_saved_regs,
SIZEOF_FRAME_SAVED_REGS);
frame->saved_regs[PC_REGNUM]
= frame->saved_regs[ALPHA_RA_REGNUM];
get_frame_saved_regs (frame)[PC_REGNUM]
= get_frame_saved_regs (frame)[ALPHA_RA_REGNUM];
}
}
}
@ -1302,19 +1303,19 @@ alpha_pop_frame (void)
For now, we don't save a copy... */
write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
if (frame->saved_regs == NULL)
if (get_frame_saved_regs (frame) == NULL)
alpha_find_saved_regs (frame);
if (proc_desc)
{
for (regnum = 32; --regnum >= 0;)
if (PROC_REG_MASK (proc_desc) & (1 << regnum))
write_register (regnum,
read_memory_integer (frame->saved_regs[regnum],
read_memory_integer (get_frame_saved_regs (frame)[regnum],
8));
for (regnum = 32; --regnum >= 0;)
if (PROC_FREG_MASK (proc_desc) & (1 << regnum))
write_register (regnum + FP0_REGNUM,
read_memory_integer (frame->saved_regs[regnum + FP0_REGNUM], 8));
read_memory_integer (get_frame_saved_regs (frame)[regnum + FP0_REGNUM], 8));
}
write_register (SP_REGNUM, new_sp);
flush_cached_frames ();

47
gdb/arm-tdep.c
View file

@ -591,7 +591,7 @@ thumb_scan_prologue (struct frame_info *fi)
if (mask & (1 << regno))
{
fi->extra_info->framesize += 4;
fi->saved_regs[saved_reg[regno]] =
get_frame_saved_regs (fi)[saved_reg[regno]] =
-(fi->extra_info->framesize);
/* Reset saved register map. */
saved_reg[regno] = regno;
@ -670,7 +670,7 @@ check_prologue_cache (struct frame_info *fi)
fi->extra_info->framesize = prologue_cache.extra_info->framesize;
fi->extra_info->frameoffset = prologue_cache.extra_info->frameoffset;
for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
fi->saved_regs[i] = prologue_cache.saved_regs[i];
get_frame_saved_regs (fi)[i] = get_frame_saved_regs (&prologue_cache)[i];
return 1;
}
else
@ -691,7 +691,7 @@ save_prologue_cache (struct frame_info *fi)
prologue_cache.extra_info->frameoffset = fi->extra_info->frameoffset;
for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
prologue_cache.saved_regs[i] = fi->saved_regs[i];
get_frame_saved_regs (&prologue_cache)[i] = get_frame_saved_regs (fi)[i];
}
@ -890,7 +890,7 @@ arm_scan_prologue (struct frame_info *fi)
if (mask & (1 << regno))
{
sp_offset -= 4;
fi->saved_regs[regno] = sp_offset;
get_frame_saved_regs (fi)[regno] = sp_offset;
}
}
else if ((insn & 0xffffc000) == 0xe54b0000 || /* strb rx,[r11,#-n] */
@ -926,7 +926,7 @@ arm_scan_prologue (struct frame_info *fi)
{
sp_offset -= 12;
regno = ARM_F0_REGNUM + ((insn >> 12) & 0x07);
fi->saved_regs[regno] = sp_offset;
get_frame_saved_regs (fi)[regno] = sp_offset;
}
else if ((insn & 0xffbf0fff) == 0xec2d0200) /* sfmfd f0, 4, [sp!] */
{
@ -953,7 +953,7 @@ arm_scan_prologue (struct frame_info *fi)
for (; fp_start_reg < fp_bound_reg; fp_start_reg++)
{
sp_offset -= 12;
fi->saved_regs[fp_start_reg++] = sp_offset;
get_frame_saved_regs (fi)[fp_start_reg++] = sp_offset;
}
}
else if ((insn & 0xf0000000) != 0xe0000000)
@ -997,14 +997,14 @@ arm_find_callers_reg (struct frame_info *fi, int regnum)
{
return deprecated_read_register_dummy (get_frame_pc (fi), fi->frame, regnum);
}
else if (fi->saved_regs[regnum] != 0)
else if (get_frame_saved_regs (fi)[regnum] != 0)
{
/* NOTE: cagney/2002-05-03: This would normally need to
handle ARM_SP_REGNUM as a special case as, according to
the frame.h comments, saved_regs[SP_REGNUM] contains the
SP value not its address. It appears that the ARM isn't
doing this though. */
return read_memory_integer (fi->saved_regs[regnum],
return read_memory_integer (get_frame_saved_regs (fi)[regnum],
REGISTER_RAW_SIZE (regnum));
}
}
@ -1086,7 +1086,7 @@ arm_init_extra_frame_info (int fromleaf, struct frame_info *fi)
int reg;
CORE_ADDR sp;
if (fi->saved_regs == NULL)
if (get_frame_saved_regs (fi) == NULL)
frame_saved_regs_zalloc (fi);
fi->extra_info = (struct frame_extra_info *)
@ -1099,7 +1099,7 @@ arm_init_extra_frame_info (int fromleaf, struct frame_info *fi)
if (fi->next)
deprecated_update_frame_pc_hack (fi, FRAME_SAVED_PC (fi->next));
memset (fi->saved_regs, '\000', sizeof fi->saved_regs);
memset (get_frame_saved_regs (fi), '\000', sizeof get_frame_saved_regs (fi));
/* Compute stack pointer for this frame. We use this value for both
the sigtramp and call dummy cases. */
@ -1135,12 +1135,12 @@ arm_init_extra_frame_info (int fromleaf, struct frame_info *fi)
&& ((get_frame_type (fi) == SIGTRAMP_FRAME) || PC_IN_SIGTRAMP (get_frame_pc (fi), (char *)0)))
{
for (reg = 0; reg < NUM_REGS; reg++)
fi->saved_regs[reg] = SIGCONTEXT_REGISTER_ADDRESS (sp, get_frame_pc (fi), reg);
get_frame_saved_regs (fi)[reg] = SIGCONTEXT_REGISTER_ADDRESS (sp, get_frame_pc (fi), reg);
/* FIXME: What about thumb mode? */
fi->extra_info->framereg = ARM_SP_REGNUM;
fi->frame =
read_memory_integer (fi->saved_regs[fi->extra_info->framereg],
read_memory_integer (get_frame_saved_regs (fi)[fi->extra_info->framereg],
REGISTER_RAW_SIZE (fi->extra_info->framereg));
fi->extra_info->framesize = 0;
fi->extra_info->frameoffset = 0;
@ -1162,10 +1162,9 @@ arm_init_extra_frame_info (int fromleaf, struct frame_info *fi)
{
/* not the innermost frame */
/* If we have an FP, the callee saved it. */
if (fi->next->saved_regs[fi->extra_info->framereg] != 0)
if (get_frame_saved_regs (get_next_frame (fi))[fi->extra_info->framereg] != 0)
fi->frame =
read_memory_integer (fi->next
->saved_regs[fi->extra_info->framereg], 4);
read_memory_integer (get_frame_saved_regs (get_next_frame (fi))[fi->extra_info->framereg], 4);
else if (fromleaf)
/* If we were called by a frameless fn. then our frame is
still in the frame pointer register on the board... */
@ -1175,9 +1174,9 @@ arm_init_extra_frame_info (int fromleaf, struct frame_info *fi)
/* Calculate actual addresses of saved registers using offsets
determined by arm_scan_prologue. */
for (reg = 0; reg < NUM_REGS; reg++)
if (fi->saved_regs[reg] != 0)
fi->saved_regs[reg] += (fi->frame + fi->extra_info->framesize
- fi->extra_info->frameoffset);
if (get_frame_saved_regs (fi)[reg] != 0)
get_frame_saved_regs (fi)[reg] += (fi->frame + fi->extra_info->framesize
- fi->extra_info->frameoffset);
}
}
@ -1200,7 +1199,7 @@ arm_frame_saved_pc (struct frame_info *fi)
if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame - fi->extra_info->frameoffset,
fi->frame))
{
return read_memory_integer (fi->saved_regs[ARM_PC_REGNUM],
return read_memory_integer (get_frame_saved_regs (fi)[ARM_PC_REGNUM],
REGISTER_RAW_SIZE (ARM_PC_REGNUM));
}
else
@ -1232,7 +1231,7 @@ static void
arm_frame_init_saved_regs (struct frame_info *fip)
{
if (fip->saved_regs)
if (get_frame_saved_regs (fip))
return;
arm_init_extra_frame_info (0, fip);
@ -1531,9 +1530,9 @@ arm_pop_frame (void)
}
for (regnum = 0; regnum < NUM_REGS; regnum++)
if (frame->saved_regs[regnum] != 0)
if (get_frame_saved_regs (frame)[regnum] != 0)
write_register (regnum,
read_memory_integer (frame->saved_regs[regnum],
read_memory_integer (get_frame_saved_regs (frame)[regnum],
REGISTER_RAW_SIZE (regnum)));
write_register (ARM_PC_REGNUM, FRAME_SAVED_PC (frame));
@ -3039,8 +3038,8 @@ arm_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
/* We can't use SIZEOF_FRAME_SAVED_REGS here, since that still
references the old architecture vector, not the one we are
building here. */
if (prologue_cache.saved_regs != NULL)
xfree (prologue_cache.saved_regs);
if (get_frame_saved_regs (&prologue_cache) != NULL)
xfree (get_frame_saved_regs (&prologue_cache));
/* We can't use NUM_REGS nor NUM_PSEUDO_REGS here, since that still
references the old architecture vector, not the one we are

34
gdb/avr-tdep.c
View file

@ -593,13 +593,13 @@ avr_scan_prologue (struct frame_info *fi)
if (num_pushes)
{
int from;
fi->saved_regs[AVR_FP_REGNUM + 1] = num_pushes;
get_frame_saved_regs (fi)[AVR_FP_REGNUM + 1] = num_pushes;
if (num_pushes >= 2)
fi->saved_regs[AVR_FP_REGNUM] = num_pushes - 1;
get_frame_saved_regs (fi)[AVR_FP_REGNUM] = num_pushes - 1;
i = 0;
for (from = AVR_LAST_PUSHED_REGNUM + 1 - (num_pushes - 2);
from <= AVR_LAST_PUSHED_REGNUM; ++from)
fi->saved_regs[from] = ++i;
get_frame_saved_regs (fi)[from] = ++i;
}
fi->extra_info->locals_size = loc_size;
fi->extra_info->framesize = loc_size + num_pushes;
@ -622,15 +622,15 @@ avr_scan_prologue (struct frame_info *fi)
if (memcmp (prologue, img, sizeof (img)) == 0)
{
vpc += sizeof (img);
fi->saved_regs[0] = 2;
fi->saved_regs[1] = 1;
get_frame_saved_regs (fi)[0] = 2;
get_frame_saved_regs (fi)[1] = 1;
fi->extra_info->framesize += 3;
}
else if (memcmp (img + 1, prologue, sizeof (img) - 1) == 0)
{
vpc += sizeof (img) - 1;
fi->saved_regs[0] = 2;
fi->saved_regs[1] = 1;
get_frame_saved_regs (fi)[0] = 2;
get_frame_saved_regs (fi)[1] = 1;
fi->extra_info->framesize += 3;
}
}
@ -646,7 +646,7 @@ avr_scan_prologue (struct frame_info *fi)
/* Bits 4-9 contain a mask for registers R0-R32. */
regno = (insn & 0x1f0) >> 4;
++fi->extra_info->framesize;
fi->saved_regs[regno] = fi->extra_info->framesize;
get_frame_saved_regs (fi)[regno] = fi->extra_info->framesize;
scan_stage = 1;
}
else
@ -776,11 +776,11 @@ avr_init_extra_frame_info (int fromleaf, struct frame_info *fi)
for (; next_fi; next_fi = next_fi->next)
{
/* look for saved AVR_FP_REGNUM */
if (next_fi->saved_regs[AVR_FP_REGNUM] && !fp)
fp = next_fi->saved_regs[AVR_FP_REGNUM];
if (get_frame_saved_regs (next_fi)[AVR_FP_REGNUM] && !fp)
fp = get_frame_saved_regs (next_fi)[AVR_FP_REGNUM];
/* look for saved AVR_FP_REGNUM + 1 */
if (next_fi->saved_regs[AVR_FP_REGNUM + 1] && !fp1)
fp1 = next_fi->saved_regs[AVR_FP_REGNUM + 1];
if (get_frame_saved_regs (next_fi)[AVR_FP_REGNUM + 1] && !fp1)
fp1 = get_frame_saved_regs (next_fi)[AVR_FP_REGNUM + 1];
}
fp_low = (fp ? read_memory_unsigned_integer (avr_make_saddr (fp), 1)
: read_register (AVR_FP_REGNUM)) & 0xff;
@ -815,8 +815,8 @@ avr_init_extra_frame_info (int fromleaf, struct frame_info *fi)
/* Resolve a pushed registers addresses */
for (i = 0; i < NUM_REGS; i++)
{
if (fi->saved_regs[i])
fi->saved_regs[i] = addr - fi->saved_regs[i];
if (get_frame_saved_regs (fi)[i])
get_frame_saved_regs (fi)[i] = addr - get_frame_saved_regs (fi)[i];
}
}
}
@ -844,13 +844,13 @@ avr_pop_frame (void)
{
/* Don't forget AVR_SP_REGNUM in a frame_saved_regs struct is the
actual value we want, not the address of the value we want. */
if (frame->saved_regs[regnum] && regnum != AVR_SP_REGNUM)
if (get_frame_saved_regs (frame)[regnum] && regnum != AVR_SP_REGNUM)
{
saddr = avr_make_saddr (frame->saved_regs[regnum]);
saddr = avr_make_saddr (get_frame_saved_regs (frame)[regnum]);
write_register (regnum,
read_memory_unsigned_integer (saddr, 1));
}
else if (frame->saved_regs[regnum] && regnum == AVR_SP_REGNUM)
else if (get_frame_saved_regs (frame)[regnum] && regnum == AVR_SP_REGNUM)
write_register (regnum, frame->frame + 2);
}

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 (fi->saved_regs)
if (get_frame_saved_regs (fi))
{
for (regno = 0; regno < NUM_REGS; regno++)
fi->saved_regs[regno] = 0;
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 (!fi->saved_regs)
if (!get_frame_saved_regs (fi))
return ip;
if (have_fp)
{
fi->saved_regs[FP_REGNUM] = get_frame_base (fi);
get_frame_saved_regs (fi)[FP_REGNUM] = get_frame_base (fi);
/* Calculate the addresses. */
for (regno = regsave; regno >= 0; regno--)
{
fi->saved_regs[regno] = get_frame_base (fi) - val;
get_frame_saved_regs (fi)[regno] = get_frame_base (fi) - val;
val -= 4;
}
if (fi->extra_info->leaf_function)
{
/* Set the register SP to contain the stack pointer of
the caller. */
fi->saved_regs[SP_REGNUM] = get_frame_base (fi) + 4;
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. */
fi->saved_regs[SP_REGNUM] = get_frame_base (fi) + 8;
get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 8;
/* Set the register SRP to contain the return address of
the caller. */
fi->saved_regs[SRP_REGNUM] = get_frame_base (fi) + 4;
get_frame_saved_regs (fi)[SRP_REGNUM] = get_frame_base (fi) + 4;
}
}
return ip;
@ -743,7 +743,7 @@ cris_skip_prologue_main (CORE_ADDR pc, int frameless_p)
/* frame_info now contains dynamic memory. Since fi is a dummy here,
I use static memory for extra_info, and don't bother allocating
memory for saved_regs. */
fi.saved_regs = 0;
memset (&fi, 0, sizeof (fi));
fi.extra_info = &fei;
/* If there is no symbol information then sal.end == 0, and we end up
@ -1164,7 +1164,7 @@ cris_frame_init_saved_regs (struct frame_info *fi)
register int frameless_p = 0;
/* Has this frame's registers already been initialized? */
if (fi->saved_regs)
if (get_frame_saved_regs (fi))
return;
frame_saved_regs_zalloc (fi);
@ -1231,11 +1231,11 @@ cris_init_extra_frame_info (int fromleaf, struct frame_info *fi)
/* Check fromleaf/frameless_function_invocation. (FIXME) */
if (fi->saved_regs[SRP_REGNUM] != 0)
if (get_frame_saved_regs (fi)[SRP_REGNUM] != 0)
{
/* SRP was saved on the stack; non-leaf function. */
fi->extra_info->return_pc =
read_memory_integer (fi->saved_regs[SRP_REGNUM],
read_memory_integer (get_frame_saved_regs (fi)[SRP_REGNUM],
REGISTER_RAW_SIZE (SRP_REGNUM));
}
else
@ -1533,30 +1533,30 @@ cris_pop_frame (void)
after SP was saved. */
for (regno = 0; regno < FP_REGNUM; regno++)
{
if (fi->saved_regs[regno])
if (get_frame_saved_regs (fi)[regno])
{
write_register (regno,
read_memory_integer (fi->saved_regs[regno], 4));
read_memory_integer (get_frame_saved_regs (fi)[regno], 4));
}
}
if (fi->saved_regs[FP_REGNUM])
if (get_frame_saved_regs (fi)[FP_REGNUM])
{
/* Pop the frame pointer (R8). It was pushed before SP
was saved. */
write_register (FP_REGNUM,
read_memory_integer (fi->saved_regs[FP_REGNUM], 4));
read_memory_integer (get_frame_saved_regs (fi)[FP_REGNUM], 4));
stack_offset += 4;
/* Not a leaf function. */
if (fi->saved_regs[SRP_REGNUM])
if (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, fi->saved_regs[FP_REGNUM] + stack_offset);
write_register (SP_REGNUM, get_frame_saved_regs (fi)[FP_REGNUM] + stack_offset);
}
else
{

58
gdb/d10v-tdep.c
View file

@ -555,23 +555,23 @@ do_d10v_pop_frame (struct frame_info *fi)
/* now update the current registers with the old values */
for (regnum = A0_REGNUM; regnum < A0_REGNUM + NR_A_REGS; regnum++)
{
if (fi->saved_regs[regnum])
if (get_frame_saved_regs (fi)[regnum])
{
read_memory (fi->saved_regs[regnum], raw_buffer, REGISTER_RAW_SIZE (regnum));
read_memory (get_frame_saved_regs (fi)[regnum], raw_buffer, REGISTER_RAW_SIZE (regnum));
deprecated_write_register_bytes (REGISTER_BYTE (regnum), raw_buffer,
REGISTER_RAW_SIZE (regnum));
}
}
for (regnum = 0; regnum < SP_REGNUM; regnum++)
{
if (fi->saved_regs[regnum])
if (get_frame_saved_regs (fi)[regnum])
{
write_register (regnum, read_memory_unsigned_integer (fi->saved_regs[regnum], REGISTER_RAW_SIZE (regnum)));
write_register (regnum, read_memory_unsigned_integer (get_frame_saved_regs (fi)[regnum], REGISTER_RAW_SIZE (regnum)));
}
}
if (fi->saved_regs[PSW_REGNUM])
if (get_frame_saved_regs (fi)[PSW_REGNUM])
{
write_register (PSW_REGNUM, read_memory_unsigned_integer (fi->saved_regs[PSW_REGNUM], REGISTER_RAW_SIZE (PSW_REGNUM)));
write_register (PSW_REGNUM, read_memory_unsigned_integer (get_frame_saved_regs (fi)[PSW_REGNUM], REGISTER_RAW_SIZE (PSW_REGNUM)));
}
write_register (PC_REGNUM, read_register (LR_REGNUM));
@ -703,16 +703,16 @@ d10v_frame_chain (struct frame_info *fi)
return (CORE_ADDR) 0;
}
if (!fi->saved_regs[FP_REGNUM])
if (!get_frame_saved_regs (fi)[FP_REGNUM])
{
if (!fi->saved_regs[SP_REGNUM]
|| fi->saved_regs[SP_REGNUM] == STACK_START)
if (!get_frame_saved_regs (fi)[SP_REGNUM]
|| get_frame_saved_regs (fi)[SP_REGNUM] == STACK_START)
return (CORE_ADDR) 0;
return fi->saved_regs[SP_REGNUM];
return get_frame_saved_regs (fi)[SP_REGNUM];
}
addr = read_memory_unsigned_integer (fi->saved_regs[FP_REGNUM],
addr = read_memory_unsigned_integer (get_frame_saved_regs (fi)[FP_REGNUM],
REGISTER_RAW_SIZE (FP_REGNUM));
if (addr == 0)
return (CORE_ADDR) 0;
@ -732,7 +732,7 @@ prologue_find_regs (unsigned short op, struct frame_info *fi, CORE_ADDR addr)
{
n = (op & 0x1E0) >> 5;
next_addr -= 2;
fi->saved_regs[n] = next_addr;
get_frame_saved_regs (fi)[n] = next_addr;
return 1;
}
@ -741,8 +741,8 @@ prologue_find_regs (unsigned short op, struct frame_info *fi, CORE_ADDR addr)
{
n = (op & 0x1E0) >> 5;
next_addr -= 4;
fi->saved_regs[n] = next_addr;
fi->saved_regs[n + 1] = next_addr + 2;
get_frame_saved_regs (fi)[n] = next_addr;
get_frame_saved_regs (fi)[n + 1] = next_addr + 2;
return 1;
}
@ -771,7 +771,7 @@ prologue_find_regs (unsigned short op, struct frame_info *fi, CORE_ADDR addr)
if ((op & 0x7E1F) == 0x681E)
{
n = (op & 0x1E0) >> 5;
fi->saved_regs[n] = next_addr;
get_frame_saved_regs (fi)[n] = next_addr;
return 1;
}
@ -779,8 +779,8 @@ prologue_find_regs (unsigned short op, struct frame_info *fi, CORE_ADDR addr)
if ((op & 0x7E3F) == 0x3A1E)
{
n = (op & 0x1E0) >> 5;
fi->saved_regs[n] = next_addr;
fi->saved_regs[n + 1] = next_addr + 2;
get_frame_saved_regs (fi)[n] = next_addr;
get_frame_saved_regs (fi)[n + 1] = next_addr + 2;
return 1;
}
@ -802,7 +802,7 @@ d10v_frame_init_saved_regs (struct frame_info *fi)
int i;
fp = fi->frame;
memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
memset (get_frame_saved_regs (fi), 0, SIZEOF_FRAME_SAVED_REGS);
next_addr = 0;
pc = get_pc_function_start (get_frame_pc (fi));
@ -825,15 +825,15 @@ d10v_frame_init_saved_regs (struct frame_info *fi)
/* st rn, @(offset,sp) */
short offset = op & 0xFFFF;
short n = (op >> 20) & 0xF;
fi->saved_regs[n] = next_addr + offset;
get_frame_saved_regs (fi)[n] = next_addr + offset;
}
else if ((op & 0x3F1F0000) == 0x350F0000)
{
/* st2w rn, @(offset,sp) */
short offset = op & 0xFFFF;
short n = (op >> 20) & 0xF;
fi->saved_regs[n] = next_addr + offset;
fi->saved_regs[n + 1] = next_addr + offset + 2;
get_frame_saved_regs (fi)[n] = next_addr + offset;
get_frame_saved_regs (fi)[n + 1] = next_addr + offset + 2;
}
else
break;
@ -864,15 +864,15 @@ d10v_frame_init_saved_regs (struct frame_info *fi)
fp = d10v_read_sp ();
for (i = 0; i < NUM_REGS - 1; i++)
if (fi->saved_regs[i])
if (get_frame_saved_regs (fi)[i])
{
fi->saved_regs[i] = fp - (next_addr - fi->saved_regs[i]);
get_frame_saved_regs (fi)[i] = fp - (next_addr - get_frame_saved_regs (fi)[i]);
}
if (fi->saved_regs[LR_REGNUM])
if (get_frame_saved_regs (fi)[LR_REGNUM])
{
CORE_ADDR return_pc
= read_memory_unsigned_integer (fi->saved_regs[LR_REGNUM],
= read_memory_unsigned_integer (get_frame_saved_regs (fi)[LR_REGNUM],
REGISTER_RAW_SIZE (LR_REGNUM));
fi->extra_info->return_pc = d10v_make_iaddr (return_pc);
}
@ -882,18 +882,18 @@ d10v_frame_init_saved_regs (struct frame_info *fi)
}
/* The SP is not normally (ever?) saved, but check anyway */
if (!fi->saved_regs[SP_REGNUM])
if (!get_frame_saved_regs (fi)[SP_REGNUM])
{
/* if the FP was saved, that means the current FP is valid, */
/* otherwise, it isn't being used, so we use the SP instead */
if (uses_frame)
fi->saved_regs[SP_REGNUM]
get_frame_saved_regs (fi)[SP_REGNUM]
= d10v_read_fp () + fi->extra_info->size;
else
{
fi->saved_regs[SP_REGNUM] = fp + fi->extra_info->size;
get_frame_saved_regs (fi)[SP_REGNUM] = fp + fi->extra_info->size;
fi->extra_info->frameless = 1;
fi->saved_regs[FP_REGNUM] = 0;
get_frame_saved_regs (fi)[FP_REGNUM] = 0;
}
}
}

12
gdb/h8300-tdep.c
View file

@ -464,7 +464,7 @@ h8300_frame_init_saved_regs (struct frame_info *fi)
{
CORE_ADDR func_addr, func_end;
if (!fi->saved_regs)
if (!get_frame_saved_regs (fi))
{
frame_saved_regs_zalloc (fi);
@ -475,7 +475,7 @@ h8300_frame_init_saved_regs (struct frame_info *fi)
struct symtab_and_line sal = find_pc_line (func_addr, 0);
CORE_ADDR limit = (sal.end && sal.end < get_frame_pc (fi)) ? sal.end : get_frame_pc (fi);
/* This will fill in fields in fi. */
h8300_examine_prologue (func_addr, limit, fi->frame, fi->saved_regs, fi);
h8300_examine_prologue (func_addr, limit, fi->frame, get_frame_saved_regs (fi), fi);
}
/* Else we're out of luck (can't debug completely stripped code).
FIXME. */
@ -500,7 +500,7 @@ h8300_frame_chain (struct frame_info *thisframe)
E_PC_REGNUM);
return thisframe->frame;
}
return thisframe->saved_regs[E_SP_REGNUM];
return get_frame_saved_regs (thisframe)[E_SP_REGNUM];
}
/* Return the saved PC from this frame.
@ -757,11 +757,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 (frame->saved_regs[regno] && regno != E_SP_REGNUM)
if (get_frame_saved_regs (frame)[regno] && regno != E_SP_REGNUM)
write_register (regno,
read_memory_integer (frame->saved_regs[regno],
read_memory_integer (get_frame_saved_regs (frame)[regno],
BINWORD));
else if (frame->saved_regs[regno] && regno == E_SP_REGNUM)
else if (get_frame_saved_regs (frame)[regno] && regno == E_SP_REGNUM)
write_register (regno, frame->frame + 2 * BINWORD);
}

12
gdb/i386-tdep.c
View file

@ -707,7 +707,7 @@ i386_frame_init_saved_regs (struct frame_info *fip)
CORE_ADDR pc;
int i;
if (fip->saved_regs)
if (get_frame_saved_regs (fip))
return;
frame_saved_regs_zalloc (fip);
@ -726,16 +726,16 @@ i386_frame_init_saved_regs (struct frame_info *fip)
break;
#ifdef I386_REGNO_TO_SYMMETRY
/* Dynix uses different internal numbering. Ick. */
fip->saved_regs[I386_REGNO_TO_SYMMETRY (op - 0x50)] = addr;
get_frame_saved_regs (fip)[I386_REGNO_TO_SYMMETRY (op - 0x50)] = addr;
#else
fip->saved_regs[op - 0x50] = addr;
get_frame_saved_regs (fip)[op - 0x50] = addr;
#endif
addr -= 4;
}
}
fip->saved_regs[PC_REGNUM] = fip->frame + 4;
fip->saved_regs[FP_REGNUM] = fip->frame;
get_frame_saved_regs (fip)[PC_REGNUM] = fip->frame + 4;
get_frame_saved_regs (fip)[FP_REGNUM] = fip->frame;
}
/* Return PC of first real instruction. */
@ -867,7 +867,7 @@ i386_do_pop_frame (struct frame_info *frame)
for (regnum = 0; regnum < NUM_REGS; regnum++)
{
CORE_ADDR addr;
addr = frame->saved_regs[regnum];
addr = get_frame_saved_regs (frame)[regnum];
if (addr)
{
read_memory (addr, regbuf, REGISTER_RAW_SIZE (regnum));

74
gdb/ia64-tdep.c
View file

@ -710,8 +710,8 @@ ia64_frame_chain (struct frame_info *frame)
else
{
FRAME_INIT_SAVED_REGS (frame);
if (frame->saved_regs[IA64_VFP_REGNUM])
return read_memory_integer (frame->saved_regs[IA64_VFP_REGNUM], 8);
if (get_frame_saved_regs (frame)[IA64_VFP_REGNUM])
return read_memory_integer (get_frame_saved_regs (frame)[IA64_VFP_REGNUM], 8);
else
return frame->frame + frame->extra_info->mem_stack_frame_size;
}
@ -728,8 +728,8 @@ ia64_frame_saved_pc (struct frame_info *frame)
{
FRAME_INIT_SAVED_REGS (frame);
if (frame->saved_regs[IA64_VRAP_REGNUM])
return read_memory_integer (frame->saved_regs[IA64_VRAP_REGNUM], 8);
if (get_frame_saved_regs (frame)[IA64_VRAP_REGNUM])
return read_memory_integer (get_frame_saved_regs (frame)[IA64_VRAP_REGNUM], 8);
else if (frame->next && (get_frame_type (frame->next) == SIGTRAMP_FRAME))
return read_sigcontext_register (frame->next, IA64_BR0_REGNUM);
else /* either frameless, or not far enough along in the prologue... */
@ -832,7 +832,7 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct frame_info *frame)
memset (instores, 0, sizeof instores);
memset (infpstores, 0, sizeof infpstores);
if (frame && !frame->saved_regs)
if (frame && !get_frame_saved_regs (frame))
{
frame_saved_regs_zalloc (frame);
do_fsr_stuff = 1;
@ -960,7 +960,7 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct frame_info *frame)
&& ((2 <= fM && fM <= 5) || (16 <= fM && fM <= 31)))
{
if (do_fsr_stuff)
frame->saved_regs[IA64_FR0_REGNUM + fM] = spill_addr;
get_frame_saved_regs (frame)[IA64_FR0_REGNUM + fM] = spill_addr;
if ((instr & 0x1efc0000000) == 0x0eec0000000)
spill_addr += imm;
@ -1019,14 +1019,14 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct frame_info *frame)
{
/* Track UNAT register */
if (do_fsr_stuff)
frame->saved_regs[IA64_UNAT_REGNUM] = spill_addr;
get_frame_saved_regs (frame)[IA64_UNAT_REGNUM] = spill_addr;
unat_save_reg = 0;
}
else
{
/* Track PR register */
if (do_fsr_stuff)
frame->saved_regs[IA64_PR_REGNUM] = spill_addr;
get_frame_saved_regs (frame)[IA64_PR_REGNUM] = spill_addr;
pr_save_reg = 0;
}
if ((instr & 0x1efc0000000LL) == 0x0acc0000000LL)
@ -1095,7 +1095,7 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct frame_info *frame)
regs. Record the spill address and advance the spill
register if appropriate. */
if (do_fsr_stuff)
frame->saved_regs[IA64_GR0_REGNUM + rM] = spill_addr;
get_frame_saved_regs (frame)[IA64_GR0_REGNUM + rM] = spill_addr;
if ((instr & 0x1efc0000000LL) == 0x0aec0000000LL)
/* st8.spill [rN] = rM, imm9 */
spill_addr += imm9(instr);
@ -1128,17 +1128,17 @@ examine_prologue (CORE_ADDR pc, CORE_ADDR lim_pc, struct frame_info *frame)
addr += 8;
}
if (i < sor)
frame->saved_regs[IA64_GR32_REGNUM + ((i + (sor - rrb_gr)) % sor)]
get_frame_saved_regs (frame)[IA64_GR32_REGNUM + ((i + (sor - rrb_gr)) % sor)]
= addr;
else
frame->saved_regs[IA64_GR32_REGNUM + i] = addr;
get_frame_saved_regs (frame)[IA64_GR32_REGNUM + i] = addr;
if (i+32 == cfm_reg)
frame->saved_regs[IA64_CFM_REGNUM] = addr;
get_frame_saved_regs (frame)[IA64_CFM_REGNUM] = addr;
if (i+32 == ret_reg)
frame->saved_regs[IA64_VRAP_REGNUM] = addr;
get_frame_saved_regs (frame)[IA64_VRAP_REGNUM] = addr;
if (i+32 == fp_reg)
frame->saved_regs[IA64_VFP_REGNUM] = addr;
get_frame_saved_regs (frame)[IA64_VFP_REGNUM] = addr;
}
}
@ -1160,7 +1160,7 @@ ia64_skip_prologue (CORE_ADDR pc)
void
ia64_frame_init_saved_regs (struct frame_info *frame)
{
if (frame->saved_regs)
if (get_frame_saved_regs (frame))
return;
if ((get_frame_type (frame) == SIGTRAMP_FRAME) && SIGCONTEXT_REGISTER_ADDRESS)
@ -1169,37 +1169,37 @@ ia64_frame_init_saved_regs (struct frame_info *frame)
frame_saved_regs_zalloc (frame);
frame->saved_regs[IA64_VRAP_REGNUM] =
get_frame_saved_regs (frame)[IA64_VRAP_REGNUM] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_IP_REGNUM);
frame->saved_regs[IA64_CFM_REGNUM] =
get_frame_saved_regs (frame)[IA64_CFM_REGNUM] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_CFM_REGNUM);
frame->saved_regs[IA64_PSR_REGNUM] =
get_frame_saved_regs (frame)[IA64_PSR_REGNUM] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_PSR_REGNUM);
#if 0
frame->saved_regs[IA64_BSP_REGNUM] =
get_frame_saved_regs (frame)[IA64_BSP_REGNUM] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_BSP_REGNUM);
#endif
frame->saved_regs[IA64_RNAT_REGNUM] =
get_frame_saved_regs (frame)[IA64_RNAT_REGNUM] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_RNAT_REGNUM);
frame->saved_regs[IA64_CCV_REGNUM] =
get_frame_saved_regs (frame)[IA64_CCV_REGNUM] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_CCV_REGNUM);
frame->saved_regs[IA64_UNAT_REGNUM] =
get_frame_saved_regs (frame)[IA64_UNAT_REGNUM] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_UNAT_REGNUM);
frame->saved_regs[IA64_FPSR_REGNUM] =
get_frame_saved_regs (frame)[IA64_FPSR_REGNUM] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_FPSR_REGNUM);
frame->saved_regs[IA64_PFS_REGNUM] =
get_frame_saved_regs (frame)[IA64_PFS_REGNUM] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_PFS_REGNUM);
frame->saved_regs[IA64_LC_REGNUM] =
get_frame_saved_regs (frame)[IA64_LC_REGNUM] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_LC_REGNUM);
for (regno = IA64_GR1_REGNUM; regno <= IA64_GR31_REGNUM; regno++)
if (regno != sp_regnum)
frame->saved_regs[regno] =
get_frame_saved_regs (frame)[regno] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
for (regno = IA64_BR0_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
frame->saved_regs[regno] =
get_frame_saved_regs (frame)[regno] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
for (regno = IA64_FR2_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
frame->saved_regs[regno] =
get_frame_saved_regs (frame)[regno] =
SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
}
else
@ -1301,8 +1301,8 @@ ia64_get_saved_register (char *raw_buffer,
if (!is_dummy_frame)
{
FRAME_INIT_SAVED_REGS (frame);
gr_addr = frame->saved_regs[ regnum - IA64_NAT0_REGNUM
+ IA64_GR0_REGNUM];
gr_addr = get_frame_saved_regs (frame)[ regnum - IA64_NAT0_REGNUM
+ IA64_GR0_REGNUM];
}
if (gr_addr)
{
@ -1343,7 +1343,7 @@ ia64_get_saved_register (char *raw_buffer,
if (!is_dummy_frame)
{
FRAME_INIT_SAVED_REGS (frame);
addr = frame->saved_regs[regnum];
addr = get_frame_saved_regs (frame)[regnum];
}
if (addr != 0)
@ -1513,8 +1513,8 @@ ia64_init_extra_frame_info (int fromleaf, struct frame_info *frame)
FRAME_INIT_SAVED_REGS (frn);
if (frn->saved_regs[IA64_CFM_REGNUM] != 0)
cfm = read_memory_integer (frn->saved_regs[IA64_CFM_REGNUM], 8);
if (get_frame_saved_regs (frn)[IA64_CFM_REGNUM] != 0)
cfm = read_memory_integer (get_frame_saved_regs (frn)[IA64_CFM_REGNUM], 8);
else if (frn->next && (get_frame_type (frn->next) == SIGTRAMP_FRAME))
cfm = read_sigcontext_register (frn->next, IA64_PFS_REGNUM);
else if (frn->next
@ -1978,7 +1978,7 @@ ia64_pop_frame_regular (struct frame_info *frame)
for (regno = 0; regno < ia64_num_regs; regno++)
{
if (frame->saved_regs[regno]
if (get_frame_saved_regs (frame)[regno]
&& (!(IA64_GR32_REGNUM <= regno && regno <= IA64_GR127_REGNUM))
&& regno != pc_regnum
&& regno != sp_regnum
@ -1988,7 +1988,7 @@ ia64_pop_frame_regular (struct frame_info *frame)
&& regno != IA64_BSPSTORE_REGNUM)
{
write_register (regno,
read_memory_integer (frame->saved_regs[regno],
read_memory_integer (get_frame_saved_regs (frame)[regno],
REGISTER_RAW_SIZE (regno)));
}
}
@ -1998,9 +1998,9 @@ ia64_pop_frame_regular (struct frame_info *frame)
cfm = read_register (IA64_CFM_REGNUM);
if (frame->saved_regs[IA64_PFS_REGNUM])
if (get_frame_saved_regs (frame)[IA64_PFS_REGNUM])
{
pfs = read_memory_integer (frame->saved_regs[IA64_PFS_REGNUM],
pfs = read_memory_integer (get_frame_saved_regs (frame)[IA64_PFS_REGNUM],
REGISTER_RAW_SIZE (IA64_PFS_REGNUM));
}
else

30
gdb/m68hc11-tdep.c
View file

@ -443,9 +443,9 @@ m68hc11_pop_frame (void)
/* Copy regs from where they were saved in the frame. */
for (regnum = 0; regnum < M68HC11_ALL_REGS; regnum++)
if (frame->saved_regs[regnum])
if (get_frame_saved_regs (frame)[regnum])
write_register (regnum,
read_memory_integer (frame->saved_regs[regnum], 2));
read_memory_integer (get_frame_saved_regs (frame)[regnum], 2));
write_register (HARD_PC_REGNUM, frame->extra_info->return_pc);
sp = (fp + frame->extra_info->size + 2) & 0x0ffff;
@ -840,36 +840,36 @@ m68hc11_frame_init_saved_regs (struct frame_info *fi)
CORE_ADDR pc;
CORE_ADDR addr;
if (fi->saved_regs == NULL)
if (get_frame_saved_regs (fi) == NULL)
frame_saved_regs_zalloc (fi);
else
memset (fi->saved_regs, 0, sizeof (fi->saved_regs));
memset (get_frame_saved_regs (fi), 0, SIZEOF_FRAME_SAVED_REGS);
pc = get_frame_pc (fi);
fi->extra_info->return_kind = m68hc11_get_return_insn (pc);
m68hc11_guess_from_prologue (pc, fi->frame, &pc, &fi->extra_info->size,
fi->saved_regs);
get_frame_saved_regs (fi));
addr = fi->frame + fi->extra_info->size + STACK_CORRECTION;
if (soft_regs[SOFT_FP_REGNUM].name)
fi->saved_regs[SOFT_FP_REGNUM] = addr - 2;
get_frame_saved_regs (fi)[SOFT_FP_REGNUM] = addr - 2;
/* Take into account how the function was called/returns. */
if (fi->extra_info->return_kind == RETURN_RTC)
{
fi->saved_regs[HARD_PAGE_REGNUM] = addr;
get_frame_saved_regs (fi)[HARD_PAGE_REGNUM] = addr;
addr++;
}
else if (fi->extra_info->return_kind == RETURN_RTI)
{
fi->saved_regs[HARD_CCR_REGNUM] = addr;
fi->saved_regs[HARD_D_REGNUM] = addr + 1;
fi->saved_regs[HARD_X_REGNUM] = addr + 3;
fi->saved_regs[HARD_Y_REGNUM] = addr + 5;
get_frame_saved_regs (fi)[HARD_CCR_REGNUM] = addr;
get_frame_saved_regs (fi)[HARD_D_REGNUM] = addr + 1;
get_frame_saved_regs (fi)[HARD_X_REGNUM] = addr + 3;
get_frame_saved_regs (fi)[HARD_Y_REGNUM] = addr + 5;
addr += 7;
}
fi->saved_regs[HARD_SP_REGNUM] = addr;
fi->saved_regs[HARD_PC_REGNUM] = fi->saved_regs[HARD_SP_REGNUM];
get_frame_saved_regs (fi)[HARD_SP_REGNUM] = addr;
get_frame_saved_regs (fi)[HARD_PC_REGNUM] = get_frame_saved_regs (fi)[HARD_SP_REGNUM];
}
static void
@ -892,7 +892,7 @@ m68hc11_init_extra_frame_info (int fromleaf, struct frame_info *fi)
}
else
{
addr = fi->saved_regs[HARD_PC_REGNUM];
addr = get_frame_saved_regs (fi)[HARD_PC_REGNUM];
addr = read_memory_unsigned_integer (addr, 2) & 0x0ffff;
/* Take into account the 68HC12 specific call (PC + page). */
@ -900,7 +900,7 @@ m68hc11_init_extra_frame_info (int fromleaf, struct frame_info *fi)
&& addr >= 0x08000 && addr < 0x0c000
&& USE_PAGE_REGISTER)
{
CORE_ADDR page_addr = fi->saved_regs[HARD_PAGE_REGNUM];
CORE_ADDR page_addr = get_frame_saved_regs (fi)[HARD_PAGE_REGNUM];
unsigned page = read_memory_unsigned_integer (page_addr, 1);
addr -= 0x08000;

38
gdb/m68k-tdep.c
View file

@ -478,25 +478,25 @@ m68k_pop_frame (void)
m68k_frame_init_saved_regs (frame);
for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)
{
if (frame->saved_regs[regnum])
if (get_frame_saved_regs (frame)[regnum])
{
read_memory (frame->saved_regs[regnum], raw_buffer, 12);
read_memory (get_frame_saved_regs (frame)[regnum], raw_buffer, 12);
deprecated_write_register_bytes (REGISTER_BYTE (regnum), raw_buffer,
12);
}
}
for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)
{
if (frame->saved_regs[regnum])
if (get_frame_saved_regs (frame)[regnum])
{
write_register (regnum,
read_memory_integer (frame->saved_regs[regnum], 4));
read_memory_integer (get_frame_saved_regs (frame)[regnum], 4));
}
}
if (frame->saved_regs[PS_REGNUM])
if (get_frame_saved_regs (frame)[PS_REGNUM])
{
write_register (PS_REGNUM,
read_memory_integer (frame->saved_regs[PS_REGNUM], 4));
read_memory_integer (get_frame_saved_regs (frame)[PS_REGNUM], 4));
}
write_register (FP_REGNUM, read_memory_integer (fp, 4));
write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
@ -592,12 +592,12 @@ m68k_frame_init_saved_regs (struct frame_info *frame_info)
int nextinsn;
if (frame_info->saved_regs)
if (get_frame_saved_regs (frame_info))
return;
frame_saved_regs_zalloc (frame_info);
memset (frame_info->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
memset (get_frame_saved_regs (frame_info), 0, SIZEOF_FRAME_SAVED_REGS);
if (get_frame_pc (frame_info) >= possible_call_dummy_start
&& get_frame_pc (frame_info) <= frame_info->frame)
@ -658,7 +658,7 @@ m68k_frame_init_saved_regs (struct frame_info *frame_info)
/* Regmask's low bit is for register fp7, the first pushed */
for (regnum = FP0_REGNUM + 8; --regnum >= FP0_REGNUM; regmask >>= 1)
if (regmask & 1)
frame_info->saved_regs[regnum] = (next_addr -= 12);
get_frame_saved_regs (frame_info)[regnum] = (next_addr -= 12);
pc += 4;
}
/* fmovemx to (fp + displacement) */
@ -671,7 +671,7 @@ m68k_frame_init_saved_regs (struct frame_info *frame_info)
for (regnum = FP0_REGNUM + 8; --regnum >= FP0_REGNUM; regmask >>= 1)
if (regmask & 1)
{
frame_info->saved_regs[regnum] = addr;
get_frame_saved_regs (frame_info)[regnum] = addr;
addr += 12;
}
pc += 6;
@ -683,7 +683,7 @@ m68k_frame_init_saved_regs (struct frame_info *frame_info)
for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)
if (regmask & 1)
{
frame_info->saved_regs[regnum] = next_addr;
get_frame_saved_regs (frame_info)[regnum] = next_addr;
next_addr += 4;
}
pc += 4;
@ -698,7 +698,7 @@ m68k_frame_init_saved_regs (struct frame_info *frame_info)
for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)
if (regmask & 1)
{
frame_info->saved_regs[regnum] = addr;
get_frame_saved_regs (frame_info)[regnum] = addr;
addr += 4;
}
pc += 6;
@ -709,14 +709,14 @@ m68k_frame_init_saved_regs (struct frame_info *frame_info)
/* Regmask's low bit is for register 15, the first pushed */
for (regnum = 16; --regnum >= 0; regmask >>= 1)
if (regmask & 1)
frame_info->saved_regs[regnum] = (next_addr -= 4);
get_frame_saved_regs (frame_info)[regnum] = (next_addr -= 4);
pc += 4;
}
/* movl r,-(sp) */
else if (0x2f00 == (0xfff0 & nextinsn))
{
regnum = 0xf & nextinsn;
frame_info->saved_regs[regnum] = (next_addr -= 4);
get_frame_saved_regs (frame_info)[regnum] = (next_addr -= 4);
pc += 2;
}
/* fmovemx to index of sp */
@ -726,7 +726,7 @@ m68k_frame_init_saved_regs (struct frame_info *frame_info)
for (regnum = FP0_REGNUM + 8; --regnum >= FP0_REGNUM; regmask >>= 1)
if (regmask & 1)
{
frame_info->saved_regs[regnum] = next_addr;
get_frame_saved_regs (frame_info)[regnum] = next_addr;
next_addr += 12;
}
pc += 10;
@ -734,16 +734,16 @@ m68k_frame_init_saved_regs (struct frame_info *frame_info)
/* clrw -(sp); movw ccr,-(sp) */
else if (0x4267 == nextinsn && 0x42e7 == regmask)
{
frame_info->saved_regs[PS_REGNUM] = (next_addr -= 4);
get_frame_saved_regs (frame_info)[PS_REGNUM] = (next_addr -= 4);
pc += 4;
}
else
break;
}
lose:;
frame_info->saved_regs[SP_REGNUM] = (frame_info)->frame + 8;
frame_info->saved_regs[FP_REGNUM] = (frame_info)->frame;
frame_info->saved_regs[PC_REGNUM] = (frame_info)->frame + 4;
get_frame_saved_regs (frame_info)[SP_REGNUM] = (frame_info)->frame + 8;
get_frame_saved_regs (frame_info)[FP_REGNUM] = (frame_info)->frame;
get_frame_saved_regs (frame_info)[PC_REGNUM] = (frame_info)->frame + 4;
#ifdef SIG_SP_FP_OFFSET
/* Adjust saved SP_REGNUM for fake _sigtramp frames. */
if ((get_frame_type (frame_info) == SIGTRAMP_FRAME) && frame_info->next)

16
gdb/mcore-tdep.c
View file

@ -301,7 +301,7 @@ analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
deprecated_update_frame_base_hack (dummy, frame);
dummy->extra_info->status = 0;
dummy->extra_info->framesize = 0;
memset (dummy->saved_regs, '\000', SIZEOF_FRAME_SAVED_REGS);
memset (get_frame_saved_regs (dummy), '\000', SIZEOF_FRAME_SAVED_REGS);
mcore_analyze_prologue (dummy, 0, 0);
return dummy;
}
@ -626,7 +626,7 @@ mcore_analyze_prologue (struct frame_info *fi, CORE_ADDR pc, int skip_prologue)
{
if (register_offsets[rn] >= 0)
{
fi->saved_regs[rn] = fi->frame - register_offsets[rn];
get_frame_saved_regs (fi)[rn] = fi->frame - 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)));
@ -675,11 +675,11 @@ mcore_frame_chain (struct frame_info * fi)
int fp = dummy->extra_info->fp_regnum;
/* Our caller has a frame pointer. */
if (fi->saved_regs[fp] != 0)
if (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 (fi->saved_regs[fp], REGISTER_SIZE)
callers_addr = read_memory_integer (get_frame_saved_regs (fi)[fp], REGISTER_SIZE)
+ dummy->extra_info->framesize;
}
else
@ -759,8 +759,8 @@ mcore_find_callers_reg (struct frame_info *fi, int regnum)
{
if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
return deprecated_read_register_dummy (get_frame_pc (fi), fi->frame, regnum);
else if (fi->saved_regs[regnum] != 0)
return read_memory_integer (fi->saved_regs[regnum],
else if (get_frame_saved_regs (fi)[regnum] != 0)
return read_memory_integer (get_frame_saved_regs (fi)[regnum],
REGISTER_SIZE);
}
@ -800,11 +800,11 @@ mcore_pop_frame (void)
/* Restore any saved registers. */
for (rn = 0; rn < NUM_REGS; rn++)
{
if (fi->saved_regs[rn] != 0)
if (get_frame_saved_regs (fi)[rn] != 0)
{
ULONGEST value;
value = read_memory_unsigned_integer (fi->saved_regs[rn],
value = read_memory_unsigned_integer (get_frame_saved_regs (fi)[rn],
REGISTER_SIZE);
write_register (rn, value);
}

34
gdb/mips-tdep.c
View file

@ -1424,15 +1424,15 @@ mips_find_saved_regs (struct frame_info *fci)
{
reg_position = fci->frame + SIGFRAME_REGSAVE_OFF
+ ireg * SIGFRAME_REG_SIZE;
fci->saved_regs[ireg] = reg_position;
get_frame_saved_regs (fci)[ireg] = reg_position;
}
for (ireg = 0; ireg < MIPS_NUMREGS; ireg++)
{
reg_position = fci->frame + SIGFRAME_FPREGSAVE_OFF
+ ireg * SIGFRAME_REG_SIZE;
fci->saved_regs[FP0_REGNUM + ireg] = reg_position;
get_frame_saved_regs (fci)[FP0_REGNUM + ireg] = reg_position;
}
fci->saved_regs[PC_REGNUM] = fci->frame + SIGFRAME_PC_OFF;
get_frame_saved_regs (fci)[PC_REGNUM] = fci->frame + SIGFRAME_PC_OFF;
return;
}
@ -1502,7 +1502,7 @@ mips_find_saved_regs (struct frame_info *fci)
for (ireg = MIPS_NUMREGS - 1; gen_mask; --ireg, gen_mask <<= 1)
if (gen_mask & 0x80000000)
{
fci->saved_regs[ireg] = reg_position;
get_frame_saved_regs (fci)[ireg] = reg_position;
reg_position -= MIPS_SAVED_REGSIZE;
}
@ -1526,7 +1526,7 @@ mips_find_saved_regs (struct frame_info *fci)
/* Check if the s0 and s1 registers were pushed on the stack. */
for (reg = 16; reg < sreg_count + 16; reg++)
{
fci->saved_regs[reg] = reg_position;
get_frame_saved_regs (fci)[reg] = reg_position;
reg_position -= MIPS_SAVED_REGSIZE;
}
}
@ -1557,11 +1557,11 @@ mips_find_saved_regs (struct frame_info *fci)
for (ireg = MIPS_NUMREGS - 1; float_mask; --ireg, float_mask <<= 1)
if (float_mask & 0x80000000)
{
fci->saved_regs[FP0_REGNUM + ireg] = reg_position;
get_frame_saved_regs (fci)[FP0_REGNUM + ireg] = reg_position;
reg_position -= MIPS_SAVED_REGSIZE;
}
fci->saved_regs[PC_REGNUM] = fci->saved_regs[RA_REGNUM];
get_frame_saved_regs (fci)[PC_REGNUM] = get_frame_saved_regs (fci)[RA_REGNUM];
}
/* Set up the 'saved_regs' array. This is a data structure containing
@ -1574,11 +1574,11 @@ mips_find_saved_regs (struct frame_info *fci)
static void
mips_frame_init_saved_regs (struct frame_info *frame)
{
if (frame->saved_regs == NULL)
if (get_frame_saved_regs (frame) == NULL)
{
mips_find_saved_regs (frame);
}
frame->saved_regs[SP_REGNUM] = frame->frame;
get_frame_saved_regs (frame)[SP_REGNUM] = frame->frame;
}
static CORE_ADDR
@ -2512,15 +2512,15 @@ mips_init_extra_frame_info (int fromleaf, struct frame_info *fci)
if (!PC_IN_SIGTRAMP (get_frame_pc (fci), name))
{
frame_saved_regs_zalloc (fci);
memcpy (fci->saved_regs, temp_saved_regs, SIZEOF_FRAME_SAVED_REGS);
fci->saved_regs[PC_REGNUM]
= fci->saved_regs[RA_REGNUM];
memcpy (get_frame_saved_regs (fci), temp_saved_regs, SIZEOF_FRAME_SAVED_REGS);
get_frame_saved_regs (fci)[PC_REGNUM]
= get_frame_saved_regs (fci)[RA_REGNUM];
/* Set value of previous frame's stack pointer. Remember that
saved_regs[SP_REGNUM] is special in that it contains the
value of the stack pointer register. The other saved_regs
values are addresses (in the inferior) at which a given
register's value may be found. */
fci->saved_regs[SP_REGNUM] = fci->frame;
get_frame_saved_regs (fci)[SP_REGNUM] = fci->frame;
}
}
@ -3823,22 +3823,22 @@ mips_pop_frame (void)
}
write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
if (frame->saved_regs == NULL)
if (get_frame_saved_regs (frame) == NULL)
FRAME_INIT_SAVED_REGS (frame);
for (regnum = 0; regnum < NUM_REGS; regnum++)
if (regnum != SP_REGNUM && regnum != PC_REGNUM
&& frame->saved_regs[regnum])
&& 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 (frame->saved_regs[regnum],
read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
MIPS_SAVED_REGSIZE));
else
write_register (regnum,
read_memory_integer (frame->saved_regs[regnum],
read_memory_integer (get_frame_saved_regs (frame)[regnum],
MIPS_SAVED_REGSIZE));
}

60
gdb/mn10300-tdep.c
View file

@ -163,7 +163,7 @@ analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
dummy->frame = frame;
dummy->extra_info->status = 0;
dummy->extra_info->stack_size = 0;
memset (dummy->saved_regs, '\000', SIZEOF_FRAME_SAVED_REGS);
memset (get_frame_saved_regs (dummy), '\000', SIZEOF_FRAME_SAVED_REGS);
mn10300_analyze_prologue (dummy, 0);
return dummy;
}
@ -231,59 +231,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. */
fi->saved_regs[LAR_REGNUM] = fi->frame + offset + 4;
fi->saved_regs[LIR_REGNUM] = fi->frame + offset + 8;
fi->saved_regs[MDR_REGNUM] = fi->frame + offset + 12;
fi->saved_regs[A0_REGNUM + 1] = fi->frame + offset + 16;
fi->saved_regs[A0_REGNUM] = fi->frame + offset + 20;
fi->saved_regs[D0_REGNUM + 1] = fi->frame + offset + 24;
fi->saved_regs[D0_REGNUM] = fi->frame + offset + 28;
get_frame_saved_regs (fi)[LAR_REGNUM] = fi->frame + offset + 4;
get_frame_saved_regs (fi)[LIR_REGNUM] = fi->frame + offset + 8;
get_frame_saved_regs (fi)[MDR_REGNUM] = fi->frame + offset + 12;
get_frame_saved_regs (fi)[A0_REGNUM + 1] = fi->frame + offset + 16;
get_frame_saved_regs (fi)[A0_REGNUM] = fi->frame + offset + 20;
get_frame_saved_regs (fi)[D0_REGNUM + 1] = fi->frame + offset + 24;
get_frame_saved_regs (fi)[D0_REGNUM] = fi->frame + offset + 28;
offset += 32;
}
if (movm_args & movm_a3_bit)
{
fi->saved_regs[A3_REGNUM] = fi->frame + offset;
get_frame_saved_regs (fi)[A3_REGNUM] = fi->frame + offset;
offset += 4;
}
if (movm_args & movm_a2_bit)
{
fi->saved_regs[A2_REGNUM] = fi->frame + offset;
get_frame_saved_regs (fi)[A2_REGNUM] = fi->frame + offset;
offset += 4;
}
if (movm_args & movm_d3_bit)
{
fi->saved_regs[D3_REGNUM] = fi->frame + offset;
get_frame_saved_regs (fi)[D3_REGNUM] = fi->frame + offset;
offset += 4;
}
if (movm_args & movm_d2_bit)
{
fi->saved_regs[D2_REGNUM] = fi->frame + offset;
get_frame_saved_regs (fi)[D2_REGNUM] = fi->frame + offset;
offset += 4;
}
if (AM33_MODE)
{
if (movm_args & movm_exother_bit)
{
fi->saved_regs[MCVF_REGNUM] = fi->frame + offset;
fi->saved_regs[MCRL_REGNUM] = fi->frame + offset + 4;
fi->saved_regs[MCRH_REGNUM] = fi->frame + offset + 8;
fi->saved_regs[MDRQ_REGNUM] = fi->frame + offset + 12;
fi->saved_regs[E0_REGNUM + 1] = fi->frame + offset + 16;
fi->saved_regs[E0_REGNUM + 0] = fi->frame + offset + 20;
get_frame_saved_regs (fi)[MCVF_REGNUM] = fi->frame + offset;
get_frame_saved_regs (fi)[MCRL_REGNUM] = fi->frame + offset + 4;
get_frame_saved_regs (fi)[MCRH_REGNUM] = fi->frame + offset + 8;
get_frame_saved_regs (fi)[MDRQ_REGNUM] = fi->frame + offset + 12;
get_frame_saved_regs (fi)[E0_REGNUM + 1] = fi->frame + offset + 16;
get_frame_saved_regs (fi)[E0_REGNUM + 0] = fi->frame + offset + 20;
offset += 24;
}
if (movm_args & movm_exreg1_bit)
{
fi->saved_regs[E0_REGNUM + 7] = fi->frame + offset;
fi->saved_regs[E0_REGNUM + 6] = fi->frame + offset + 4;
fi->saved_regs[E0_REGNUM + 5] = fi->frame + offset + 8;
fi->saved_regs[E0_REGNUM + 4] = fi->frame + offset + 12;
get_frame_saved_regs (fi)[E0_REGNUM + 7] = fi->frame + offset;
get_frame_saved_regs (fi)[E0_REGNUM + 6] = fi->frame + offset + 4;
get_frame_saved_regs (fi)[E0_REGNUM + 5] = fi->frame + offset + 8;
get_frame_saved_regs (fi)[E0_REGNUM + 4] = fi->frame + offset + 12;
offset += 16;
}
if (movm_args & movm_exreg0_bit)
{
fi->saved_regs[E0_REGNUM + 3] = fi->frame + offset;
fi->saved_regs[E0_REGNUM + 2] = fi->frame + offset + 4;
get_frame_saved_regs (fi)[E0_REGNUM + 3] = fi->frame + offset;
get_frame_saved_regs (fi)[E0_REGNUM + 2] = fi->frame + offset + 4;
offset += 8;
}
}
@ -633,14 +633,14 @@ saved_regs_size (struct frame_info *fi)
/* Reserve four bytes for every register saved. */
for (i = 0; i < NUM_REGS; i++)
if (fi->saved_regs[i])
if (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 (fi->saved_regs[LIR_REGNUM])
if (get_frame_saved_regs (fi)[LIR_REGNUM])
adjust += 4;
return adjust;
@ -690,8 +690,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 (fi->saved_regs[A3_REGNUM])
return (read_memory_integer (fi->saved_regs[A3_REGNUM], REGISTER_SIZE));
if (get_frame_saved_regs (fi)[A3_REGNUM])
return (read_memory_integer (get_frame_saved_regs (fi)[A3_REGNUM], REGISTER_SIZE));
else
return read_register (A3_REGNUM);
}
@ -728,11 +728,11 @@ mn10300_pop_frame_regular (struct frame_info *frame)
/* Restore any saved registers. */
for (regnum = 0; regnum < NUM_REGS; regnum++)
if (frame->saved_regs[regnum] != 0)
if (get_frame_saved_regs (frame)[regnum] != 0)
{
ULONGEST value;
value = read_memory_unsigned_integer (frame->saved_regs[regnum],
value = read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
REGISTER_RAW_SIZE (regnum));
write_register (regnum, value);
}

18
gdb/ns32k-tdep.c
View file

@ -375,7 +375,7 @@ ns32k_frame_init_saved_regs (struct frame_info *frame)
int localcount;
CORE_ADDR enter_addr, next_addr;
if (frame->saved_regs)
if (get_frame_saved_regs (frame))
return;
frame_saved_regs_zalloc (frame);
@ -390,18 +390,18 @@ ns32k_frame_init_saved_regs (struct frame_info *frame)
for (regnum = 0; regnum < 8; regnum++)
{
if (regmask & (1 << regnum))
frame->saved_regs[regnum] = next_addr -= 4;
get_frame_saved_regs (frame)[regnum] = next_addr -= 4;
}
frame->saved_regs[SP_REGNUM] = frame->frame + 4;
frame->saved_regs[PC_REGNUM] = frame->frame + 4;
frame->saved_regs[FP_REGNUM] = read_memory_integer (frame->frame, 4);
get_frame_saved_regs (frame)[SP_REGNUM] = frame->frame + 4;
get_frame_saved_regs (frame)[PC_REGNUM] = frame->frame + 4;
get_frame_saved_regs (frame)[FP_REGNUM] = read_memory_integer (frame->frame, 4);
}
else if (enter_addr == 1)
{
CORE_ADDR sp = read_register (SP_REGNUM);
frame->saved_regs[PC_REGNUM] = sp;
frame->saved_regs[SP_REGNUM] = sp + 4;
get_frame_saved_regs (frame)[PC_REGNUM] = sp;
get_frame_saved_regs (frame)[SP_REGNUM] = sp + 4;
}
}
@ -432,9 +432,9 @@ ns32k_pop_frame (void)
FRAME_INIT_SAVED_REGS (frame);
for (regnum = 0; regnum < 8; regnum++)
if (frame->saved_regs[regnum])
if (get_frame_saved_regs (frame)[regnum])
write_register (regnum,
read_memory_integer (frame->saved_regs[regnum], 4));
read_memory_integer (get_frame_saved_regs (frame)[regnum], 4));
write_register (FP_REGNUM, read_memory_integer (fp, 4));
write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));

26
gdb/s390-tdep.c
View file

@ -290,7 +290,7 @@ s390_get_frame_info (CORE_ADDR pc, struct frame_extra_info *fextra_info,
orig_sp = fi->frame;
if (! init_extra_info && fextra_info->initialised)
orig_sp += fextra_info->stack_bought;
saved_regs = fi->saved_regs;
saved_regs = get_frame_saved_regs (fi);
}
if (init_extra_info || !fextra_info->initialised)
{
@ -922,7 +922,7 @@ s390_frame_init_saved_regs (struct frame_info *fi)
int quick;
if (fi->saved_regs == NULL)
if (get_frame_saved_regs (fi) == NULL)
{
/* zalloc memsets the saved regs */
frame_saved_regs_zalloc (fi);
@ -962,10 +962,10 @@ s390_frame_saved_pc_nofix (struct frame_info *fi)
{
fi->extra_info->saved_pc_valid = 1;
if (fi->extra_info->good_prologue
&& fi->saved_regs[S390_RETADDR_REGNUM])
&& get_frame_saved_regs (fi)[S390_RETADDR_REGNUM])
fi->extra_info->saved_pc
= ADDR_BITS_REMOVE (read_memory_integer
(fi->saved_regs[S390_RETADDR_REGNUM],
(get_frame_saved_regs (fi)[S390_RETADDR_REGNUM],
S390_GPR_SIZE));
else
fi->extra_info->saved_pc
@ -1046,24 +1046,24 @@ s390_frame_chain (struct frame_info *thisframe)
}
else
{
if (thisframe->saved_regs)
if (get_frame_saved_regs (thisframe))
{
int regno;
if (prev_fextra_info.frame_pointer_saved_pc
&& thisframe->saved_regs[S390_FRAME_REGNUM])
&& get_frame_saved_regs (thisframe)[S390_FRAME_REGNUM])
regno = S390_FRAME_REGNUM;
else
regno = S390_SP_REGNUM;
if (thisframe->saved_regs[regno])
if (get_frame_saved_regs (thisframe)[regno])
{
/* The SP's entry of `saved_regs' is special. */
if (regno == S390_SP_REGNUM)
prev_fp = thisframe->saved_regs[regno];
prev_fp = get_frame_saved_regs (thisframe)[regno];
else
prev_fp =
read_memory_integer (thisframe->saved_regs[regno],
read_memory_integer (get_frame_saved_regs (thisframe)[regno],
S390_GPR_SIZE);
}
}
@ -1217,14 +1217,14 @@ s390_pop_frame_regular (struct frame_info *frame)
write_register (S390_PC_REGNUM, FRAME_SAVED_PC (frame));
/* Restore any saved registers. */
if (frame->saved_regs)
if (get_frame_saved_regs (frame))
{
for (regnum = 0; regnum < NUM_REGS; regnum++)
if (frame->saved_regs[regnum] != 0)
if (get_frame_saved_regs (frame)[regnum] != 0)
{
ULONGEST value;
value = read_memory_unsigned_integer (frame->saved_regs[regnum],
value = read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
REGISTER_RAW_SIZE (regnum));
write_register (regnum, value);
}
@ -1232,7 +1232,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, frame->saved_regs[S390_SP_REGNUM]);
write_register (S390_SP_REGNUM, get_frame_saved_regs (frame)[S390_SP_REGNUM]);
}
/* Throw away any cached frame information. */

66
gdb/sh-tdep.c
View file

@ -1000,8 +1000,8 @@ sh_find_callers_reg (struct frame_info *fi, int regnum)
FRAME_INIT_SAVED_REGS (fi);
if (!get_frame_pc (fi))
return 0;
if (fi->saved_regs[regnum] != 0)
return read_memory_integer (fi->saved_regs[regnum],
if (get_frame_saved_regs (fi)[regnum] != 0)
return read_memory_integer (get_frame_saved_regs (fi)[regnum],
REGISTER_RAW_SIZE (regnum));
}
return read_register (regnum);
@ -1025,13 +1025,13 @@ sh64_get_saved_pr (struct frame_info *fi, int pr_regnum)
media_mode = pc_is_isa32 (get_frame_pc (fi));
if (fi->saved_regs[pr_regnum] != 0)
if (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 (fi->saved_regs[pr_regnum], size);
return read_memory_integer (get_frame_saved_regs (fi)[pr_regnum], size);
}
}
return read_register (pr_regnum);
@ -1055,10 +1055,10 @@ sh_nofp_frame_init_saved_regs (struct frame_info *fi)
int r3_val = 0;
char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi), fi->frame);
if (fi->saved_regs == NULL)
if (get_frame_saved_regs (fi) == NULL)
frame_saved_regs_zalloc (fi);
else
memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
memset (get_frame_saved_regs (fi), 0, SIZEOF_FRAME_SAVED_REGS);
if (dummy_regs)
{
@ -1140,21 +1140,21 @@ sh_nofp_frame_init_saved_regs (struct frame_info *fi)
if (rn == FP_REGNUM)
have_fp = 1;
fi->saved_regs[rn] = fi->frame - where[rn] + depth - 4;
get_frame_saved_regs (fi)[rn] = fi->frame - where[rn] + depth - 4;
}
else
{
fi->saved_regs[rn] = 0;
get_frame_saved_regs (fi)[rn] = 0;
}
}
if (have_fp)
{
fi->saved_regs[SP_REGNUM] = read_memory_integer (fi->saved_regs[FP_REGNUM], 4);
get_frame_saved_regs (fi)[SP_REGNUM] = read_memory_integer (get_frame_saved_regs (fi)[FP_REGNUM], 4);
}
else
{
fi->saved_regs[SP_REGNUM] = fi->frame - 4;
get_frame_saved_regs (fi)[SP_REGNUM] = fi->frame - 4;
}
fi->extra_info->f_offset = depth - where[FP_REGNUM] - 4;
@ -1395,10 +1395,10 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi)
char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi), fi->frame);
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (fi->saved_regs == NULL)
if (get_frame_saved_regs (fi) == NULL)
frame_saved_regs_zalloc (fi);
else
memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
memset (get_frame_saved_regs (fi), 0, SIZEOF_FRAME_SAVED_REGS);
if (dummy_regs)
{
@ -1553,11 +1553,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. */
fi->saved_regs[register_number]= fi->frame - where[rn] + depth;
get_frame_saved_regs (fi)[register_number]= fi->frame - where[rn] + depth;
}
else
fi->saved_regs[register_number] = 0;
get_frame_saved_regs (fi)[register_number] = 0;
}
if (have_fp)
@ -1574,10 +1574,10 @@ sh64_nofp_frame_init_saved_regs (struct frame_info *fi)
size = 4;
else
size = REGISTER_RAW_SIZE (fp_regnum);
fi->saved_regs[sp_regnum] = read_memory_integer (fi->saved_regs[fp_regnum], size);
get_frame_saved_regs (fi)[sp_regnum] = read_memory_integer (get_frame_saved_regs (fi)[fp_regnum], size);
}
else
fi->saved_regs[sp_regnum] = fi->frame;
get_frame_saved_regs (fi)[sp_regnum] = fi->frame;
fi->extra_info->f_offset = depth - where[fp_regnum];
}
@ -1596,10 +1596,10 @@ sh_fp_frame_init_saved_regs (struct frame_info *fi)
char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi), fi->frame);
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
if (fi->saved_regs == NULL)
if (get_frame_saved_regs (fi) == NULL)
frame_saved_regs_zalloc (fi);
else
memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
memset (get_frame_saved_regs (fi), 0, SIZEOF_FRAME_SAVED_REGS);
if (dummy_regs)
{
@ -1692,22 +1692,22 @@ sh_fp_frame_init_saved_regs (struct frame_info *fi)
if (rn == FP_REGNUM)
have_fp = 1;
fi->saved_regs[rn] = fi->frame - where[rn] + depth - 4;
get_frame_saved_regs (fi)[rn] = fi->frame - where[rn] + depth - 4;
}
else
{
fi->saved_regs[rn] = 0;
get_frame_saved_regs (fi)[rn] = 0;
}
}
if (have_fp)
{
fi->saved_regs[SP_REGNUM] =
read_memory_integer (fi->saved_regs[FP_REGNUM], 4);
get_frame_saved_regs (fi)[SP_REGNUM] =
read_memory_integer (get_frame_saved_regs (fi)[FP_REGNUM], 4);
}
else
{
fi->saved_regs[SP_REGNUM] = fi->frame - 4;
get_frame_saved_regs (fi)[SP_REGNUM] = fi->frame - 4;
}
fi->extra_info->f_offset = depth - where[FP_REGNUM] - 4;
@ -1828,8 +1828,8 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
}
FRAME_INIT_SAVED_REGS (frame);
if (frame->saved_regs != NULL
&& frame->saved_regs[regnum] != 0)
if (get_frame_saved_regs (frame) != NULL
&& get_frame_saved_regs (frame)[regnum] != 0)
{
if (lval) /* found it saved on the stack */
*lval = lval_memory;
@ -1837,13 +1837,13 @@ sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
{
if (raw_buffer) /* SP register treated specially */
store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
frame->saved_regs[regnum]);
get_frame_saved_regs (frame)[regnum]);
}
else
{ /* any other register */
if (addrp)
*addrp = frame->saved_regs[regnum];
*addrp = get_frame_saved_regs (frame)[regnum];
if (raw_buffer)
{
int size;
@ -1854,9 +1854,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 (frame->saved_regs[regnum], raw_buffer, size);
read_memory (get_frame_saved_regs (frame)[regnum], raw_buffer, size);
else
read_memory (frame->saved_regs[regnum],
read_memory (get_frame_saved_regs (frame)[regnum],
raw_buffer
+ REGISTER_RAW_SIZE (live_regnum)
- size,
@ -1918,9 +1918,9 @@ sh_pop_frame (void)
/* Copy regs from where they were saved in the frame */
for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
if (frame->saved_regs[regnum])
if (get_frame_saved_regs (frame)[regnum])
write_register (regnum,
read_memory_integer (frame->saved_regs[regnum], 4));
read_memory_integer (get_frame_saved_regs (frame)[regnum], 4));
write_register (PC_REGNUM, frame->extra_info->return_pc);
write_register (SP_REGNUM, fp + 4);
@ -1948,7 +1948,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 (frame->saved_regs[regnum])
if (get_frame_saved_regs (frame)[regnum])
{
int size;
if (tdep->sh_abi == SH_ABI_32
@ -1959,7 +1959,7 @@ sh64_pop_frame (void)
size = REGISTER_RAW_SIZE (translate_insn_rn (regnum,
media_mode));
write_register (regnum,
read_memory_integer (frame->saved_regs[regnum],
read_memory_integer (get_frame_saved_regs (frame)[regnum],
size));
}

14
gdb/v850-tdep.c
View file

@ -802,8 +802,8 @@ v850_find_callers_reg (struct frame_info *fi, int regnum)
for (; fi; fi = fi->next)
if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
return deprecated_read_register_dummy (get_frame_pc (fi), fi->frame, regnum);
else if (fi->saved_regs[regnum] != 0)
return read_memory_unsigned_integer (fi->saved_regs[regnum],
else if (get_frame_saved_regs (fi)[regnum] != 0)
return read_memory_unsigned_integer (get_frame_saved_regs (fi)[regnum],
v850_register_raw_size (regnum));
return read_register (regnum);
@ -890,9 +890,9 @@ v850_pop_frame (void)
write_register (E_PC_REGNUM, FRAME_SAVED_PC (frame));
for (regnum = 0; regnum < E_NUM_REGS; regnum++)
if (frame->saved_regs[regnum] != 0)
if (get_frame_saved_regs (frame)[regnum] != 0)
write_register (regnum,
read_memory_unsigned_integer (frame->saved_regs[regnum],
read_memory_unsigned_integer (get_frame_saved_regs (frame)[regnum],
v850_register_raw_size (regnum)));
write_register (E_SP_REGNUM, get_frame_base (frame));
@ -1105,7 +1105,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 (!fi->saved_regs)
if (!get_frame_saved_regs (fi))
{
frame_saved_regs_zalloc (fi);
@ -1127,10 +1127,10 @@ v850_frame_init_saved_regs (struct frame_info *fi)
for (pifsr = pifsrs; pifsr->framereg; pifsr++)
{
fi->saved_regs[pifsr->reg] = pifsr->offset + fi->frame;
get_frame_saved_regs (fi)[pifsr->reg] = pifsr->offset + fi->frame;
if (pifsr->framereg == E_SP_REGNUM)
fi->saved_regs[pifsr->reg] += pi.frameoffset;
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

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

26
gdb/xstormy16-tdep.c
View file

@ -341,15 +341,15 @@ xstormy16_pop_frame (void)
{
/* Restore the saved regs. */
for (i = 0; i < NUM_REGS; i++)
if (fi->saved_regs[i])
if (get_frame_saved_regs (fi)[i])
{
if (i == SP_REGNUM)
write_register (i, fi->saved_regs[i]);
write_register (i, get_frame_saved_regs (fi)[i]);
else if (i == E_PC_REGNUM)
write_register (i, read_memory_integer (fi->saved_regs[i],
write_register (i, read_memory_integer (get_frame_saved_regs (fi)[i],
xstormy16_pc_size));
else
write_register (i, read_memory_integer (fi->saved_regs[i],
write_register (i, read_memory_integer (get_frame_saved_regs (fi)[i],
xstormy16_reg_size));
}
/* Restore the PC */
@ -490,7 +490,7 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
if (fi)
{
regnum = inst & 0x000f;
fi->saved_regs[regnum] = fi->extra_info->framesize;
get_frame_saved_regs (fi)[regnum] = fi->extra_info->framesize;
fi->extra_info->framesize += xstormy16_reg_size;
}
}
@ -546,7 +546,7 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
if (offset & 0x0800)
offset -= 0x1000;
fi->saved_regs[regnum] = fi->extra_info->framesize + offset;
get_frame_saved_regs (fi)[regnum] = fi->extra_info->framesize + offset;
}
next_addr += xstormy16_inst_size;
}
@ -593,12 +593,12 @@ xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
previous value would have been pushed). */
if (fi->extra_info->frameless_p)
{
fi->saved_regs[E_SP_REGNUM] = sp - fi->extra_info->framesize;
get_frame_saved_regs (fi)[E_SP_REGNUM] = sp - fi->extra_info->framesize;
fi->frame = sp;
}
else
{
fi->saved_regs[E_SP_REGNUM] = fp - fi->extra_info->framesize;
get_frame_saved_regs (fi)[E_SP_REGNUM] = fp - fi->extra_info->framesize;
fi->frame = fp;
}
@ -607,11 +607,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 (fi->saved_regs[regnum])
fi->saved_regs[regnum] += fi->saved_regs[E_SP_REGNUM];
if (get_frame_saved_regs (fi)[regnum])
get_frame_saved_regs (fi)[regnum] += get_frame_saved_regs (fi)[E_SP_REGNUM];
/* Save address of PC on stack. */
fi->saved_regs[E_PC_REGNUM] = fi->saved_regs[E_SP_REGNUM];
get_frame_saved_regs (fi)[E_PC_REGNUM] = get_frame_saved_regs (fi)[E_SP_REGNUM];
}
return next_addr;
@ -732,7 +732,7 @@ xstormy16_frame_init_saved_regs (struct frame_info *fi)
{
CORE_ADDR func_addr, func_end;
if (!fi->saved_regs)
if (!get_frame_saved_regs (fi))
{
frame_saved_regs_zalloc (fi);
@ -763,7 +763,7 @@ xstormy16_frame_saved_pc (struct frame_info *fi)
}
else
{
saved_pc = read_memory_unsigned_integer (fi->saved_regs[E_PC_REGNUM],
saved_pc = read_memory_unsigned_integer (get_frame_saved_regs (fi)[E_PC_REGNUM],
xstormy16_pc_size);
}