#include "language.h"
#include "osabi.h"
#include "gdb_assert.h"
-
+#include "infttrace.h"
/* For argument passing to the inferior */
#include "symtab.h"
+#include "infcall.h"
#ifdef USG
#include <sys/types.h>
static unsigned extract_5r_store (unsigned int);
-static void find_dummy_frame_regs (struct frame_info *,
- struct frame_saved_regs *);
+static void find_dummy_frame_regs (struct frame_info *, CORE_ADDR *);
static int find_proc_framesize (CORE_ADDR);
static int sign_extend (unsigned int, unsigned int);
-static int restore_pc_queue (struct frame_saved_regs *);
+static int restore_pc_queue (CORE_ADDR *);
static int hppa_alignof (struct type *);
int
hppa_use_struct_convention (int gcc_p, struct type *type)
{
- return (TYPE_LENGTH (type) > 2 * REGISTER_SIZE);
+ return (TYPE_LENGTH (type) > 2 * DEPRECATED_REGISTER_SIZE);
}
\f
{
struct unwind_table_entry *u;
- u = find_unwind_entry (frame->pc);
+ u = find_unwind_entry (get_frame_pc (frame));
if (u == 0)
return 0;
{
CORE_ADDR pc = get_frame_pc (frame);
struct unwind_table_entry *u;
- CORE_ADDR old_pc;
+ CORE_ADDR old_pc = 0;
int spun_around_loop = 0;
int rp_offset = 0;
are saved in the exact same order as GDB numbers registers. How
convienent. */
if (pc_in_interrupt_handler (pc))
- return read_memory_integer (frame->frame + PC_REGNUM * 4,
+ return read_memory_integer (get_frame_base (frame) + PC_REGNUM * 4,
TARGET_PTR_BIT / 8) & ~0x3;
- if ((frame->pc >= frame->frame
- && frame->pc <= (frame->frame
- /* A call dummy is sized in words, but it is
- actually a series of instructions. Account
- for that scaling factor. */
- + ((REGISTER_SIZE / INSTRUCTION_SIZE)
- * CALL_DUMMY_LENGTH)
- /* Similarly we have to account for 64bit
- wide register saves. */
- + (32 * REGISTER_SIZE)
- /* We always consider FP regs 8 bytes long. */
- + (NUM_REGS - FP0_REGNUM) * 8
- /* Similarly we have to account for 64bit
- wide register saves. */
- + (6 * REGISTER_SIZE))))
+ if ((get_frame_pc (frame) >= get_frame_base (frame)
+ && (get_frame_pc (frame)
+ <= (get_frame_base (frame)
+ /* A call dummy is sized in words, but it is actually a
+ series of instructions. Account for that scaling
+ factor. */
+ + ((DEPRECATED_REGISTER_SIZE / INSTRUCTION_SIZE)
+ * DEPRECATED_CALL_DUMMY_LENGTH)
+ /* Similarly we have to account for 64bit wide register
+ saves. */
+ + (32 * DEPRECATED_REGISTER_SIZE)
+ /* We always consider FP regs 8 bytes long. */
+ + (NUM_REGS - FP0_REGNUM) * 8
+ /* Similarly we have to account for 64bit wide register
+ saves. */
+ + (6 * DEPRECATED_REGISTER_SIZE)))))
{
- return read_memory_integer ((frame->frame
+ return read_memory_integer ((get_frame_base (frame)
+ (TARGET_PTR_BIT == 64 ? -16 : -20)),
TARGET_PTR_BIT / 8) & ~0x3;
}
handler caller, then we need to look in the saved
register area to get the return pointer (the values
in the registers may not correspond to anything useful). */
- if (frame->next
- && ((get_frame_type (frame->next) == SIGTRAMP_FRAME)
- || pc_in_interrupt_handler (frame->next->pc)))
+ if (get_next_frame (frame)
+ && ((get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME)
+ || pc_in_interrupt_handler (get_frame_pc (get_next_frame (frame)))))
{
- struct frame_saved_regs saved_regs;
-
- deprecated_get_frame_saved_regs (frame->next, &saved_regs);
- if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
+ CORE_ADDR *saved_regs;
+ hppa_frame_init_saved_regs (get_next_frame (frame));
+ saved_regs = get_frame_saved_regs (get_next_frame (frame));
+ if (read_memory_integer (saved_regs[FLAGS_REGNUM],
TARGET_PTR_BIT / 8) & 0x2)
{
- pc = read_memory_integer (saved_regs.regs[31],
+ pc = read_memory_integer (saved_regs[31],
TARGET_PTR_BIT / 8) & ~0x3;
/* Syscalls are really two frames. The syscall stub itself
with a return pointer in %rp and the kernel call with
a return pointer in %r31. We return the %rp variant
if %r31 is the same as frame->pc. */
- if (pc == frame->pc)
- pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
+ if (pc == get_frame_pc (frame))
+ pc = read_memory_integer (saved_regs[RP_REGNUM],
TARGET_PTR_BIT / 8) & ~0x3;
}
else
- pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
+ pc = read_memory_integer (saved_regs[RP_REGNUM],
TARGET_PTR_BIT / 8) & ~0x3;
}
else
frame is a signal or interrupt handler, then dig the right
information out of the saved register info. */
if (rp_offset == 0
- && frame->next
- && ((get_frame_type (frame->next) == SIGTRAMP_FRAME)
- || pc_in_interrupt_handler (frame->next->pc)))
+ && get_next_frame (frame)
+ && ((get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME)
+ || pc_in_interrupt_handler (get_frame_pc (get_next_frame (frame)))))
{
- struct frame_saved_regs saved_regs;
-
- deprecated_get_frame_saved_regs (frame->next, &saved_regs);
- if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
+ CORE_ADDR *saved_regs;
+ hppa_frame_init_saved_regs (get_next_frame (frame));
+ saved_regs = get_frame_saved_regs (get_next_frame (frame));
+ if (read_memory_integer (saved_regs[FLAGS_REGNUM],
TARGET_PTR_BIT / 8) & 0x2)
{
- pc = read_memory_integer (saved_regs.regs[31],
+ pc = read_memory_integer (saved_regs[31],
TARGET_PTR_BIT / 8) & ~0x3;
/* Syscalls are really two frames. The syscall stub itself
with a return pointer in %rp and the kernel call with
a return pointer in %r31. We return the %rp variant
if %r31 is the same as frame->pc. */
- if (pc == frame->pc)
- pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
+ if (pc == get_frame_pc (frame))
+ pc = read_memory_integer (saved_regs[RP_REGNUM],
TARGET_PTR_BIT / 8) & ~0x3;
}
else
- pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
+ pc = read_memory_integer (saved_regs[RP_REGNUM],
TARGET_PTR_BIT / 8) & ~0x3;
}
else if (rp_offset == 0)
else
{
old_pc = pc;
- pc = read_memory_integer (frame->frame + rp_offset,
+ pc = read_memory_integer (get_frame_base (frame) + rp_offset,
TARGET_PTR_BIT / 8) & ~0x3;
}
}
int flags;
int framesize;
- if (frame->next && !fromleaf)
+ if (get_next_frame (frame) && !fromleaf)
return;
/* If the next frame represents a frameless function invocation then
frame. (we always want frame->frame to point at the lowest address
in the frame). */
if (framesize == -1)
- frame->frame = TARGET_READ_FP ();
+ deprecated_update_frame_base_hack (frame, deprecated_read_fp ());
else
- frame->frame -= framesize;
+ deprecated_update_frame_base_hack (frame, get_frame_base (frame) - framesize);
return;
}
flags = read_register (FLAGS_REGNUM);
if (flags & 2) /* In system call? */
- frame->pc = read_register (31) & ~0x3;
+ deprecated_update_frame_pc_hack (frame, read_register (31) & ~0x3);
/* The outermost frame is always derived from PC-framesize
explain, but the parent *always* creates some stack space for
the child. So the child actually does have a frame of some
sorts, and its base is the high address in its parent's frame. */
- framesize = find_proc_framesize (frame->pc);
+ framesize = find_proc_framesize (get_frame_pc (frame));
if (framesize == -1)
- frame->frame = TARGET_READ_FP ();
+ deprecated_update_frame_base_hack (frame, deprecated_read_fp ());
else
- frame->frame = read_register (SP_REGNUM) - framesize;
+ deprecated_update_frame_base_hack (frame, read_register (SP_REGNUM) - framesize);
}
\f
/* Given a GDB frame, determine the address of the calling function's
/* A frame in the current frame list, or zero. */
struct frame_info *saved_regs_frame = 0;
- /* Where the registers were saved in saved_regs_frame.
- If saved_regs_frame is zero, this is garbage. */
- struct frame_saved_regs saved_regs;
+ /* Where the registers were saved in saved_regs_frame. If
+ saved_regs_frame is zero, this is garbage. */
+ CORE_ADDR *saved_regs = NULL;
CORE_ADDR caller_pc;
/* If this is a threaded application, and we see the
routine "__pthread_exit", treat it as the stack root
for this thread. */
- min_frame_symbol = lookup_minimal_symbol_by_pc (frame->pc);
- frame_symbol = find_pc_function (frame->pc);
+ min_frame_symbol = lookup_minimal_symbol_by_pc (get_frame_pc (frame));
+ frame_symbol = find_pc_function (get_frame_pc (frame));
if ((min_frame_symbol != 0) /* && (frame_symbol == 0) */ )
{
are easy; at *sp we have a full save state strucutre which we can
pull the old stack pointer from. Also see frame_saved_pc for
code to dig a saved PC out of the save state structure. */
- if (pc_in_interrupt_handler (frame->pc))
- frame_base = read_memory_integer (frame->frame + SP_REGNUM * 4,
+ if (pc_in_interrupt_handler (get_frame_pc (frame)))
+ frame_base = read_memory_integer (get_frame_base (frame) + SP_REGNUM * 4,
TARGET_PTR_BIT / 8);
#ifdef FRAME_BASE_BEFORE_SIGTRAMP
else if ((get_frame_type (frame) == SIGTRAMP_FRAME))
}
#endif
else
- frame_base = frame->frame;
+ frame_base = get_frame_base (frame);
/* Get frame sizes for the current frame and the frame of the
caller. */
- my_framesize = find_proc_framesize (frame->pc);
+ my_framesize = find_proc_framesize (get_frame_pc (frame));
caller_pc = DEPRECATED_FRAME_SAVED_PC (frame);
/* If we can't determine the caller's PC, then it's not likely we can
We use information from unwind descriptors to determine if %r3
is saved into the stack (Entry_GR field has this information). */
- for (tmp_frame = frame; tmp_frame; tmp_frame = tmp_frame->next)
+ for (tmp_frame = frame; tmp_frame; tmp_frame = get_next_frame (tmp_frame))
{
- u = find_unwind_entry (tmp_frame->pc);
+ u = find_unwind_entry (get_frame_pc (tmp_frame));
if (!u)
{
the dynamic linker will give you a PC that has none. Thus, I've
disabled this warning. */
#if 0
- warning ("Unable to find unwind for PC 0x%x -- Help!", tmp_frame->pc);
+ warning ("Unable to find unwind for PC 0x%x -- Help!", get_frame_pc (tmp_frame));
#endif
return (CORE_ADDR) 0;
}
if (u->Save_SP
|| (get_frame_type (tmp_frame) == SIGTRAMP_FRAME)
- || pc_in_interrupt_handler (tmp_frame->pc))
+ || pc_in_interrupt_handler (get_frame_pc (tmp_frame)))
break;
/* Entry_GR specifies the number of callee-saved general registers
/* The unwind entry claims that r3 is saved here. However,
in optimized code, GCC often doesn't actually save r3.
We'll discover this if we look at the prologue. */
- deprecated_get_frame_saved_regs (tmp_frame, &saved_regs);
+ hppa_frame_init_saved_regs (tmp_frame);
+ saved_regs = get_frame_saved_regs (tmp_frame);
saved_regs_frame = tmp_frame;
/* If we have an address for r3, that's good. */
- if (saved_regs.regs[FP_REGNUM])
+ if (saved_regs[DEPRECATED_FP_REGNUM])
break;
}
}
pointer. */
if (u->Save_SP
&& !(get_frame_type (tmp_frame) == SIGTRAMP_FRAME)
- && !pc_in_interrupt_handler (tmp_frame->pc))
+ && !pc_in_interrupt_handler (get_frame_pc (tmp_frame)))
{
- return read_memory_integer (tmp_frame->frame, TARGET_PTR_BIT / 8);
+ return read_memory_integer (get_frame_base (tmp_frame), TARGET_PTR_BIT / 8);
}
/* %r3 was saved somewhere in the stack. Dig it out. */
else
system call has a variable sized stack frame. */
if (tmp_frame != saved_regs_frame)
- deprecated_get_frame_saved_regs (tmp_frame, &saved_regs);
+ {
+ hppa_frame_init_saved_regs (tmp_frame);
+ saved_regs = get_frame_saved_regs (tmp_frame);
+ }
/* Abominable hack. */
if (current_target.to_has_execution == 0
- && ((saved_regs.regs[FLAGS_REGNUM]
- && (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
+ && ((saved_regs[FLAGS_REGNUM]
+ && (read_memory_integer (saved_regs[FLAGS_REGNUM],
TARGET_PTR_BIT / 8)
& 0x2))
- || (saved_regs.regs[FLAGS_REGNUM] == 0
+ || (saved_regs[FLAGS_REGNUM] == 0
&& read_register (FLAGS_REGNUM) & 0x2)))
{
u = find_unwind_entry (DEPRECATED_FRAME_SAVED_PC (frame));
if (!u)
{
- return read_memory_integer (saved_regs.regs[FP_REGNUM],
+ return read_memory_integer (saved_regs[DEPRECATED_FP_REGNUM],
TARGET_PTR_BIT / 8);
}
else
}
}
- return read_memory_integer (saved_regs.regs[FP_REGNUM],
+ return read_memory_integer (saved_regs[DEPRECATED_FP_REGNUM],
TARGET_PTR_BIT / 8);
}
}
{
/* Get the innermost frame. */
tmp_frame = frame;
- while (tmp_frame->next != NULL)
- tmp_frame = tmp_frame->next;
+ while (get_next_frame (tmp_frame) != NULL)
+ tmp_frame = get_next_frame (tmp_frame);
if (tmp_frame != saved_regs_frame)
- deprecated_get_frame_saved_regs (tmp_frame, &saved_regs);
+ {
+ hppa_frame_init_saved_regs (tmp_frame);
+ saved_regs = get_frame_saved_regs (tmp_frame);
+ }
/* Abominable hack. See above. */
if (current_target.to_has_execution == 0
- && ((saved_regs.regs[FLAGS_REGNUM]
- && (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
+ && ((saved_regs[FLAGS_REGNUM]
+ && (read_memory_integer (saved_regs[FLAGS_REGNUM],
TARGET_PTR_BIT / 8)
& 0x2))
- || (saved_regs.regs[FLAGS_REGNUM] == 0
+ || (saved_regs[FLAGS_REGNUM] == 0
&& read_register (FLAGS_REGNUM) & 0x2)))
{
u = find_unwind_entry (DEPRECATED_FRAME_SAVED_PC (frame));
if (!u)
{
- return read_memory_integer (saved_regs.regs[FP_REGNUM],
+ return read_memory_integer (saved_regs[DEPRECATED_FP_REGNUM],
TARGET_PTR_BIT / 8);
}
else
/* The value in %r3 was never saved into the stack (thus %r3 still
holds the value of the previous frame pointer). */
- return TARGET_READ_FP ();
+ return deprecated_read_fp ();
}
}
\f
struct unwind_table_entry *u, *next_u = NULL;
struct frame_info *next;
- u = find_unwind_entry (thisframe->pc);
+ u = find_unwind_entry (get_frame_pc (thisframe));
if (u == NULL)
return 1;
next = get_next_frame (thisframe);
if (next)
- next_u = find_unwind_entry (next->pc);
+ next_u = find_unwind_entry (get_frame_pc (next));
/* If this frame does not save SP, has no stack, isn't a stub,
and doesn't "call" an interrupt routine or signal handler caller,
then its not valid. */
if (u->Save_SP || u->Total_frame_size || u->stub_unwind.stub_type != 0
- || (thisframe->next && (get_frame_type (thisframe->next) == SIGTRAMP_FRAME))
+ || (get_next_frame (thisframe) && (get_frame_type (get_next_frame (thisframe)) == SIGTRAMP_FRAME))
|| (next_u && next_u->HP_UX_interrupt_marker))
return 1;
- if (pc_in_linker_stub (thisframe->pc))
+ if (pc_in_linker_stub (get_frame_pc (thisframe)))
return 1;
return 0;
/* The 32bit and 64bit ABIs save the return pointer into different
stack slots. */
- if (REGISTER_SIZE == 8)
- write_memory (sp - 16, (char *) &int_buffer, REGISTER_SIZE);
+ if (DEPRECATED_REGISTER_SIZE == 8)
+ write_memory (sp - 16, (char *) &int_buffer, DEPRECATED_REGISTER_SIZE);
else
- write_memory (sp - 20, (char *) &int_buffer, REGISTER_SIZE);
+ write_memory (sp - 20, (char *) &int_buffer, DEPRECATED_REGISTER_SIZE);
- int_buffer = TARGET_READ_FP ();
- write_memory (sp, (char *) &int_buffer, REGISTER_SIZE);
+ int_buffer = deprecated_read_fp ();
+ write_memory (sp, (char *) &int_buffer, DEPRECATED_REGISTER_SIZE);
- write_register (FP_REGNUM, sp);
+ write_register (DEPRECATED_FP_REGNUM, sp);
- sp += 2 * REGISTER_SIZE;
+ sp += 2 * DEPRECATED_REGISTER_SIZE;
for (regnum = 1; regnum < 32; regnum++)
- if (regnum != RP_REGNUM && regnum != FP_REGNUM)
+ if (regnum != RP_REGNUM && regnum != DEPRECATED_FP_REGNUM)
sp = push_word (sp, read_register (regnum));
/* This is not necessary for the 64bit ABI. In fact it is dangerous. */
- if (REGISTER_SIZE != 8)
+ if (DEPRECATED_REGISTER_SIZE != 8)
sp += 4;
for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
static void
find_dummy_frame_regs (struct frame_info *frame,
- struct frame_saved_regs *frame_saved_regs)
+ CORE_ADDR frame_saved_regs[])
{
- CORE_ADDR fp = frame->frame;
+ CORE_ADDR fp = get_frame_base (frame);
int i;
/* The 32bit and 64bit ABIs save RP into different locations. */
- if (REGISTER_SIZE == 8)
- frame_saved_regs->regs[RP_REGNUM] = (fp - 16) & ~0x3;
+ if (DEPRECATED_REGISTER_SIZE == 8)
+ frame_saved_regs[RP_REGNUM] = (fp - 16) & ~0x3;
else
- frame_saved_regs->regs[RP_REGNUM] = (fp - 20) & ~0x3;
+ frame_saved_regs[RP_REGNUM] = (fp - 20) & ~0x3;
- frame_saved_regs->regs[FP_REGNUM] = fp;
+ frame_saved_regs[DEPRECATED_FP_REGNUM] = fp;
- frame_saved_regs->regs[1] = fp + (2 * REGISTER_SIZE);
+ frame_saved_regs[1] = fp + (2 * DEPRECATED_REGISTER_SIZE);
- for (fp += 3 * REGISTER_SIZE, i = 3; i < 32; i++)
+ for (fp += 3 * DEPRECATED_REGISTER_SIZE, i = 3; i < 32; i++)
{
- if (i != FP_REGNUM)
+ if (i != DEPRECATED_FP_REGNUM)
{
- frame_saved_regs->regs[i] = fp;
- fp += REGISTER_SIZE;
+ frame_saved_regs[i] = fp;
+ fp += DEPRECATED_REGISTER_SIZE;
}
}
/* This is not necessary or desirable for the 64bit ABI. */
- if (REGISTER_SIZE != 8)
+ if (DEPRECATED_REGISTER_SIZE != 8)
fp += 4;
for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8)
- frame_saved_regs->regs[i] = fp;
-
- frame_saved_regs->regs[IPSW_REGNUM] = fp;
- frame_saved_regs->regs[SAR_REGNUM] = fp + REGISTER_SIZE;
- frame_saved_regs->regs[PCOQ_HEAD_REGNUM] = fp + 2 * REGISTER_SIZE;
- frame_saved_regs->regs[PCSQ_HEAD_REGNUM] = fp + 3 * REGISTER_SIZE;
- frame_saved_regs->regs[PCOQ_TAIL_REGNUM] = fp + 4 * REGISTER_SIZE;
- frame_saved_regs->regs[PCSQ_TAIL_REGNUM] = fp + 5 * REGISTER_SIZE;
+ frame_saved_regs[i] = fp;
+
+ frame_saved_regs[IPSW_REGNUM] = fp;
+ frame_saved_regs[SAR_REGNUM] = fp + DEPRECATED_REGISTER_SIZE;
+ frame_saved_regs[PCOQ_HEAD_REGNUM] = fp + 2 * DEPRECATED_REGISTER_SIZE;
+ frame_saved_regs[PCSQ_HEAD_REGNUM] = fp + 3 * DEPRECATED_REGISTER_SIZE;
+ frame_saved_regs[PCOQ_TAIL_REGNUM] = fp + 4 * DEPRECATED_REGISTER_SIZE;
+ frame_saved_regs[PCSQ_TAIL_REGNUM] = fp + 5 * DEPRECATED_REGISTER_SIZE;
}
void
register struct frame_info *frame = get_current_frame ();
register CORE_ADDR fp, npc, target_pc;
register int regnum;
- struct frame_saved_regs fsr;
+ CORE_ADDR *fsr;
double freg_buffer;
fp = get_frame_base (frame);
- deprecated_get_frame_saved_regs (frame, &fsr);
+ hppa_frame_init_saved_regs (frame);
+ fsr = get_frame_saved_regs (frame);
#ifndef NO_PC_SPACE_QUEUE_RESTORE
- if (fsr.regs[IPSW_REGNUM]) /* Restoring a call dummy frame */
- restore_pc_queue (&fsr);
+ if (fsr[IPSW_REGNUM]) /* Restoring a call dummy frame */
+ restore_pc_queue (fsr);
#endif
for (regnum = 31; regnum > 0; regnum--)
- if (fsr.regs[regnum])
- write_register (regnum, read_memory_integer (fsr.regs[regnum],
- REGISTER_SIZE));
+ if (fsr[regnum])
+ write_register (regnum, read_memory_integer (fsr[regnum],
+ DEPRECATED_REGISTER_SIZE));
for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM; regnum--)
- if (fsr.regs[regnum])
+ if (fsr[regnum])
{
- read_memory (fsr.regs[regnum], (char *) &freg_buffer, 8);
+ read_memory (fsr[regnum], (char *) &freg_buffer, 8);
deprecated_write_register_bytes (REGISTER_BYTE (regnum),
(char *) &freg_buffer, 8);
}
- if (fsr.regs[IPSW_REGNUM])
+ if (fsr[IPSW_REGNUM])
write_register (IPSW_REGNUM,
- read_memory_integer (fsr.regs[IPSW_REGNUM],
- REGISTER_SIZE));
+ read_memory_integer (fsr[IPSW_REGNUM],
+ DEPRECATED_REGISTER_SIZE));
- if (fsr.regs[SAR_REGNUM])
+ if (fsr[SAR_REGNUM])
write_register (SAR_REGNUM,
- read_memory_integer (fsr.regs[SAR_REGNUM],
- REGISTER_SIZE));
+ read_memory_integer (fsr[SAR_REGNUM],
+ DEPRECATED_REGISTER_SIZE));
/* If the PC was explicitly saved, then just restore it. */
- if (fsr.regs[PCOQ_TAIL_REGNUM])
+ if (fsr[PCOQ_TAIL_REGNUM])
{
- npc = read_memory_integer (fsr.regs[PCOQ_TAIL_REGNUM],
- REGISTER_SIZE);
+ npc = read_memory_integer (fsr[PCOQ_TAIL_REGNUM],
+ DEPRECATED_REGISTER_SIZE);
write_register (PCOQ_TAIL_REGNUM, npc);
}
/* Else use the value in %rp to set the new PC. */
write_pc (npc);
}
- write_register (FP_REGNUM, read_memory_integer (fp, REGISTER_SIZE));
+ write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, DEPRECATED_REGISTER_SIZE));
- if (fsr.regs[IPSW_REGNUM]) /* call dummy */
+ if (fsr[IPSW_REGNUM]) /* call dummy */
write_register (SP_REGNUM, fp - 48);
else
write_register (SP_REGNUM, fp);
Don't skip through the trampoline if we're popping a dummy frame. */
target_pc = SKIP_TRAMPOLINE_CODE (npc & ~0x3) & ~0x3;
- if (target_pc && !fsr.regs[IPSW_REGNUM])
+ if (target_pc && !fsr[IPSW_REGNUM])
{
struct symtab_and_line sal;
struct breakpoint *breakpoint;
queue space registers. */
static int
-restore_pc_queue (struct frame_saved_regs *fsr)
+restore_pc_queue (CORE_ADDR *fsr)
{
CORE_ADDR pc = read_pc ();
- CORE_ADDR new_pc = read_memory_integer (fsr->regs[PCOQ_HEAD_REGNUM],
+ CORE_ADDR new_pc = read_memory_integer (fsr[PCOQ_HEAD_REGNUM],
TARGET_PTR_BIT / 8);
struct target_waitstatus w;
int insn_count;
So, load up the registers and single step until we are in the
right place. */
- write_register (21, read_memory_integer (fsr->regs[PCSQ_HEAD_REGNUM],
- REGISTER_SIZE));
+ write_register (21, read_memory_integer (fsr[PCSQ_HEAD_REGNUM],
+ DEPRECATED_REGISTER_SIZE));
write_register (22, new_pc);
for (insn_count = 0; insn_count < 3; insn_count++)
the left. We do this by promoting them to full-width,
although the ABI says to pad them with garbage. */
if (is_integral_type (arg_type)
- && TYPE_LENGTH (arg_type) < REGISTER_SIZE)
+ && TYPE_LENGTH (arg_type) < DEPRECATED_REGISTER_SIZE)
{
args[i] = value_cast ((TYPE_UNSIGNED (arg_type)
? builtin_type_unsigned_long
/* Align the size of the argument to the word size for this
target. */
- bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
+ bytes_reserved = (lengths[i] + DEPRECATED_REGISTER_SIZE - 1) & -DEPRECATED_REGISTER_SIZE;
offset[i] = cum_bytes_reserved;
if (bytes_reserved > 8)
{
/* Round up the offset to a multiple of two slots. */
- int new_offset = ((offset[i] + 2*REGISTER_SIZE-1)
- & -(2*REGISTER_SIZE));
+ int new_offset = ((offset[i] + 2*DEPRECATED_REGISTER_SIZE-1)
+ & -(2*DEPRECATED_REGISTER_SIZE));
/* Note the space we've wasted, if any. */
bytes_reserved += new_offset - offset[i];
/* Align the size of the argument to the word size for this
target. */
- bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
+ bytes_reserved = (lengths[i] + DEPRECATED_REGISTER_SIZE - 1) & -DEPRECATED_REGISTER_SIZE;
offset[i] = (cum_bytes_reserved
+ (lengths[i] > 4 ? bytes_reserved : lengths[i]));
/* If the argument is a double word argument, then it needs to be
double word aligned. */
- if ((bytes_reserved == 2 * REGISTER_SIZE)
- && (offset[i] % 2 * REGISTER_SIZE))
+ if ((bytes_reserved == 2 * DEPRECATED_REGISTER_SIZE)
+ && (offset[i] % 2 * DEPRECATED_REGISTER_SIZE))
{
int new_offset = 0;
/* BYTES_RESERVED is already aligned to the word, so we put
This will leave one empty word on the stack, and one unused
register as mandated by the ABI. */
- new_offset = ((offset[i] + 2 * REGISTER_SIZE - 1)
- & -(2 * REGISTER_SIZE));
+ new_offset = ((offset[i] + 2 * DEPRECATED_REGISTER_SIZE - 1)
+ & -(2 * DEPRECATED_REGISTER_SIZE));
- if ((new_offset - offset[i]) >= 2 * REGISTER_SIZE)
+ if ((new_offset - offset[i]) >= 2 * DEPRECATED_REGISTER_SIZE)
{
- bytes_reserved += REGISTER_SIZE;
- offset[i] += REGISTER_SIZE;
+ bytes_reserved += DEPRECATED_REGISTER_SIZE;
+ offset[i] += DEPRECATED_REGISTER_SIZE;
}
}
into a call sequence of the above form stored at DUMMYNAME.
On the hppa we need to call the stack dummy through $$dyncall.
- Therefore our version of FIX_CALL_DUMMY takes an extra argument,
- real_pc, which is the location where gdb should start up the
- inferior to do the function call.
+ Therefore our version of DEPRECATED_FIX_CALL_DUMMY takes an extra
+ argument, real_pc, which is the location where gdb should start up
+ the inferior to do the function call.
This has to work across several versions of hpux, bsd, osf1. It has to
work regardless of what compiler was used to build the inferior program.
at *(fun+4). Note the call dummy is *NOT* allowed to
trash %r19 before calling the target function. */
write_register (19, read_memory_integer ((fun & ~0x3) + 4,
- REGISTER_SIZE));
+ DEPRECATED_REGISTER_SIZE));
/* Now get the real address for the function we are calling, it's
at *fun. */
}
/* This is the only site that may directly read_register () the FP
- register. All others must use TARGET_READ_FP (). */
- return read_register (FP_REGNUM);
+ register. All others must use deprecated_read_fp (). */
+ return read_register (DEPRECATED_FP_REGNUM);
}
CORE_ADDR
int start;
- char *buf = alloca (max_register_size (current_gdbarch));
+ char buf[MAX_REGISTER_SIZE];
long long reg_val;
if (!know_which)
static void
pa_print_fp_reg (int i)
{
- char *raw_buffer = alloca (max_register_size (current_gdbarch));
- char *virtual_buffer = alloca (max_register_size (current_gdbarch));
+ char raw_buffer[MAX_REGISTER_SIZE];
+ char virtual_buffer[MAX_REGISTER_SIZE];
/* Get 32bits of data. */
frame_register_read (deprecated_selected_frame, i, raw_buffer);
static void
pa_strcat_fp_reg (int i, struct ui_file *stream, enum precision_type precision)
{
- char *raw_buffer = alloca (max_register_size (current_gdbarch));
- char *virtual_buffer = alloca (max_register_size (current_gdbarch));
+ char raw_buffer[MAX_REGISTER_SIZE];
+ char virtual_buffer[MAX_REGISTER_SIZE];
fputs_filtered (REGISTER_NAME (i), stream);
print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), stream);
if (precision == double_precision && (i % 2) == 0)
{
- char *raw_buf = alloca (max_register_size (current_gdbarch));
+ char raw_buf[MAX_REGISTER_SIZE];
/* Get the data in raw format for the 2nd half. */
frame_register_read (deprecated_selected_frame, i + 1, raw_buf);
for (i = 3; i < u->Entry_GR + 3; i++)
{
/* Frame pointer gets saved into a special location. */
- if (u->Save_SP && i == FP_REGNUM)
+ if (u->Save_SP && i == DEPRECATED_FP_REGNUM)
continue;
save_gr |= (1 << i);
return (skip_prologue_hard_way (pc));
}
-/* Put here the code to store, into a struct frame_saved_regs,
- the addresses of the saved registers of frame described by FRAME_INFO.
- This includes special registers such as pc and fp saved in special
- ways in the stack frame. sp is even more special:
- the address we return for it IS the sp for the next frame. */
+/* Put here the code to store, into the SAVED_REGS, the addresses of
+ the saved registers of frame described by FRAME_INFO. This
+ includes special registers such as pc and fp saved in special ways
+ in the stack frame. sp is even more special: the address we return
+ for it IS the sp for the next frame. */
void
hppa_frame_find_saved_regs (struct frame_info *frame_info,
- struct frame_saved_regs *frame_saved_regs)
+ CORE_ADDR frame_saved_regs[])
{
CORE_ADDR pc;
struct unwind_table_entry *u;
int final_iteration;
/* Zero out everything. */
- memset (frame_saved_regs, '\0', sizeof (struct frame_saved_regs));
+ memset (frame_saved_regs, '\0', SIZEOF_FRAME_SAVED_REGS);
/* Call dummy frames always look the same, so there's no need to
examine the dummy code to determine locations of saved registers;
instead, let find_dummy_frame_regs fill in the correct offsets
for the saved registers. */
- if ((frame_info->pc >= frame_info->frame
- && frame_info->pc <= (frame_info->frame
- /* A call dummy is sized in words, but it is
- actually a series of instructions. Account
- for that scaling factor. */
- + ((REGISTER_SIZE / INSTRUCTION_SIZE)
- * CALL_DUMMY_LENGTH)
- /* Similarly we have to account for 64bit
- wide register saves. */
- + (32 * REGISTER_SIZE)
- /* We always consider FP regs 8 bytes long. */
- + (NUM_REGS - FP0_REGNUM) * 8
- /* Similarly we have to account for 64bit
- wide register saves. */
- + (6 * REGISTER_SIZE))))
+ if ((get_frame_pc (frame_info) >= get_frame_base (frame_info)
+ && (get_frame_pc (frame_info)
+ <= (get_frame_base (frame_info)
+ /* A call dummy is sized in words, but it is actually a
+ series of instructions. Account for that scaling
+ factor. */
+ + ((DEPRECATED_REGISTER_SIZE / INSTRUCTION_SIZE)
+ * DEPRECATED_CALL_DUMMY_LENGTH)
+ /* Similarly we have to account for 64bit wide register
+ saves. */
+ + (32 * DEPRECATED_REGISTER_SIZE)
+ /* We always consider FP regs 8 bytes long. */
+ + (NUM_REGS - FP0_REGNUM) * 8
+ /* Similarly we have to account for 64bit wide register
+ saves. */
+ + (6 * DEPRECATED_REGISTER_SIZE)))))
find_dummy_frame_regs (frame_info, frame_saved_regs);
/* Interrupt handlers are special too. They lay out the register
state in the exact same order as the register numbers in GDB. */
- if (pc_in_interrupt_handler (frame_info->pc))
+ if (pc_in_interrupt_handler (get_frame_pc (frame_info)))
{
for (i = 0; i < NUM_REGS; i++)
{
/* SP is a little special. */
if (i == SP_REGNUM)
- frame_saved_regs->regs[SP_REGNUM]
- = read_memory_integer (frame_info->frame + SP_REGNUM * 4,
+ frame_saved_regs[SP_REGNUM]
+ = read_memory_integer (get_frame_base (frame_info) + SP_REGNUM * 4,
TARGET_PTR_BIT / 8);
else
- frame_saved_regs->regs[i] = frame_info->frame + i * 4;
+ frame_saved_regs[i] = get_frame_base (frame_info) + i * 4;
}
return;
}
/* Get the starting address of the function referred to by the PC
saved in frame. */
- pc = get_pc_function_start (frame_info->pc);
+ pc = get_frame_func (frame_info);
/* Yow! */
u = find_unwind_entry (pc);
for (i = 3; i < u->Entry_GR + 3; i++)
{
/* Frame pointer gets saved into a special location. */
- if (u->Save_SP && i == FP_REGNUM)
+ if (u->Save_SP && i == DEPRECATED_FP_REGNUM)
continue;
save_gr |= (1 << i);
/* The frame always represents the value of %sp at entry to the
current function (and is thus equivalent to the "saved" stack
pointer. */
- frame_saved_regs->regs[SP_REGNUM] = frame_info->frame;
+ frame_saved_regs[SP_REGNUM] = get_frame_base (frame_info);
/* Loop until we find everything of interest or hit a branch.
GCC code. */
final_iteration = 0;
while ((save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
- && pc <= frame_info->pc)
+ && pc <= get_frame_pc (frame_info))
{
status = target_read_memory (pc, buf, 4);
inst = extract_unsigned_integer (buf, 4);
if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
{
save_rp = 0;
- frame_saved_regs->regs[RP_REGNUM] = frame_info->frame - 20;
+ frame_saved_regs[RP_REGNUM] = get_frame_base (frame_info) - 20;
}
else if (inst == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
{
save_rp = 0;
- frame_saved_regs->regs[RP_REGNUM] = frame_info->frame - 16;
+ frame_saved_regs[RP_REGNUM] = get_frame_base (frame_info) - 16;
}
/* Note if we saved SP into the stack. This also happens to indicate
if ( (inst & 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
|| (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
{
- frame_saved_regs->regs[FP_REGNUM] = frame_info->frame;
+ frame_saved_regs[DEPRECATED_FP_REGNUM] = get_frame_base (frame_info);
save_sp = 0;
}
/* Account for general and floating-point register saves. */
reg = inst_saves_gr (inst);
if (reg >= 3 && reg <= 18
- && (!u->Save_SP || reg != FP_REGNUM))
+ && (!u->Save_SP || reg != DEPRECATED_FP_REGNUM))
{
save_gr &= ~(1 << reg);
/* stwm with a positive displacement is a *post modify*. */
if ((inst >> 26) == 0x1b
&& extract_14 (inst) >= 0)
- frame_saved_regs->regs[reg] = frame_info->frame;
+ frame_saved_regs[reg] = get_frame_base (frame_info);
/* A std has explicit post_modify forms. */
else if ((inst & 0xfc00000c0) == 0x70000008)
- frame_saved_regs->regs[reg] = frame_info->frame;
+ frame_saved_regs[reg] = get_frame_base (frame_info);
else
{
CORE_ADDR offset;
/* Handle code with and without frame pointers. */
if (u->Save_SP)
- frame_saved_regs->regs[reg]
- = frame_info->frame + offset;
+ frame_saved_regs[reg]
+ = get_frame_base (frame_info) + offset;
else
- frame_saved_regs->regs[reg]
- = (frame_info->frame + (u->Total_frame_size << 3)
+ frame_saved_regs[reg]
+ = (get_frame_base (frame_info) + (u->Total_frame_size << 3)
+ offset);
}
}
/* 1st HP CC FP register store. After this instruction
we've set enough state that the GCC and HPCC code are
both handled in the same manner. */
- frame_saved_regs->regs[reg + FP4_REGNUM + 4] = frame_info->frame;
+ frame_saved_regs[reg + FP4_REGNUM + 4] = get_frame_base (frame_info);
fp_loc = 8;
}
else
{
- frame_saved_regs->regs[reg + FP0_REGNUM + 4]
- = frame_info->frame + fp_loc;
+ frame_saved_regs[reg + FP0_REGNUM + 4]
+ = get_frame_base (frame_info) + fp_loc;
fp_loc += 8;
}
}
}
}
+/* XXX - deprecated. This is a compatibility function for targets
+ that do not yet implement DEPRECATED_FRAME_INIT_SAVED_REGS. */
+/* Find the addresses in which registers are saved in FRAME. */
+
+void
+hppa_frame_init_saved_regs (struct frame_info *frame)
+{
+ if (get_frame_saved_regs (frame) == NULL)
+ frame_saved_regs_zalloc (frame);
+ hppa_frame_find_saved_regs (frame, get_frame_saved_regs (frame));
+}
/* Exception handling support for the HP-UX ANSI C++ compiler.
The compiler (aCC) provides a callback for exception events;
return (struct exception_event_record *) NULL;
select_frame (fi);
- throw_addr = fi->pc;
+ throw_addr = get_frame_pc (fi);
/* Go back to original (top) frame */
select_frame (curr_frame);
? (8 - TYPE_LENGTH (type))
: (4 - TYPE_LENGTH (type))),
valbuf, TYPE_LENGTH (type));
- if (! SOFT_FLOAT && TYPE_CODE (type) == TYPE_CODE_FLT)
+ if (TYPE_CODE (type) == TYPE_CODE_FLT)
deprecated_write_register_bytes (REGISTER_BYTE (FP4_REGNUM),
valbuf, TYPE_LENGTH (type));
}
void
hppa_extract_return_value (struct type *type, char *regbuf, char *valbuf)
{
- if (! SOFT_FLOAT && TYPE_CODE (type) == TYPE_CODE_FLT)
+ if (TYPE_CODE (type) == TYPE_CODE_FLT)
memcpy (valbuf,
(char *)regbuf + REGISTER_BYTE (FP4_REGNUM),
TYPE_LENGTH (type));
hppa_register_raw_size (int reg_nr)
{
/* All registers have the same size. */
- return REGISTER_SIZE;
+ return DEPRECATED_REGISTER_SIZE;
}
/* Index within the register vector of the first byte of the space i
CORE_ADDR
hppa_frame_args_address (struct frame_info *fi)
{
- return fi->frame;
+ return get_frame_base (fi);
}
CORE_ADDR
hppa_frame_locals_address (struct frame_info *fi)
{
- return fi->frame;
+ return get_frame_base (fi);
}
int
set_gdbarch_in_solib_call_trampoline (gdbarch, hppa_in_solib_call_trampoline);
set_gdbarch_in_solib_return_trampoline (gdbarch,
hppa_in_solib_return_trampoline);
- set_gdbarch_saved_pc_after_call (gdbarch, hppa_saved_pc_after_call);
+ set_gdbarch_deprecated_saved_pc_after_call (gdbarch, hppa_saved_pc_after_call);
set_gdbarch_inner_than (gdbarch, hppa_inner_than);
set_gdbarch_stack_align (gdbarch, hppa_stack_align);
- set_gdbarch_extra_stack_alignment_needed (gdbarch, 0);
set_gdbarch_decr_pc_after_break (gdbarch, 0);
- set_gdbarch_register_size (gdbarch, 4);
+ set_gdbarch_deprecated_register_size (gdbarch, 4);
set_gdbarch_num_regs (gdbarch, hppa_num_regs);
- set_gdbarch_fp_regnum (gdbarch, 3);
+ set_gdbarch_deprecated_fp_regnum (gdbarch, 3);
set_gdbarch_sp_regnum (gdbarch, 30);
set_gdbarch_fp0_regnum (gdbarch, 64);
set_gdbarch_pc_regnum (gdbarch, PCOQ_HEAD_REGNUM);
set_gdbarch_deprecated_max_register_raw_size (gdbarch, 4);
set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 8);
set_gdbarch_register_virtual_type (gdbarch, hppa_register_virtual_type);
- set_gdbarch_store_struct_return (gdbarch, hppa_store_struct_return);
+ set_gdbarch_deprecated_store_struct_return (gdbarch, hppa_store_struct_return);
set_gdbarch_deprecated_extract_return_value (gdbarch,
hppa_extract_return_value);
set_gdbarch_use_struct_convention (gdbarch, hppa_use_struct_convention);
set_gdbarch_frame_args_skip (gdbarch, 0);
set_gdbarch_deprecated_push_dummy_frame (gdbarch, hppa_push_dummy_frame);
set_gdbarch_deprecated_pop_frame (gdbarch, hppa_pop_frame);
- set_gdbarch_call_dummy_length (gdbarch, INSTRUCTION_SIZE * 28);
- set_gdbarch_call_dummy_start_offset (gdbarch, 0);
- /* set_gdbarch_fix_call_dummy (gdbarch, hppa_fix_call_dummy); */
- set_gdbarch_push_arguments (gdbarch, hppa_push_arguments);
+ set_gdbarch_deprecated_call_dummy_length (gdbarch, INSTRUCTION_SIZE * 28);
+ /* set_gdbarch_deprecated_fix_call_dummy (gdbarch, hppa_fix_call_dummy); */
+ set_gdbarch_deprecated_push_arguments (gdbarch, hppa_push_arguments);
set_gdbarch_smash_text_address (gdbarch, hppa_smash_text_address);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
set_gdbarch_read_pc (gdbarch, hppa_target_read_pc);
set_gdbarch_write_pc (gdbarch, hppa_target_write_pc);
- set_gdbarch_read_fp (gdbarch, hppa_target_read_fp);
+ set_gdbarch_deprecated_target_read_fp (gdbarch, hppa_target_read_fp);
return gdbarch;
}
void break_at_finish_at_depth_command (char *arg, int from_tty);
gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
- tm_print_insn = print_insn_hppa;
+ deprecated_tm_print_insn = print_insn_hppa;
add_cmd ("unwind", class_maintenance, unwind_command,
"Print unwind table entry at given address.",
projects / deliverable / binutils-gdb.git / blobdiff