/* Target-dependent code for the IA-64 for GDB, the GNU debugger.
- Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ Copyright 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GDB.
static gdbarch_frame_chain_ftype ia64_frame_chain;
static gdbarch_frame_saved_pc_ftype ia64_frame_saved_pc;
static gdbarch_skip_prologue_ftype ia64_skip_prologue;
-static gdbarch_frame_init_saved_regs_ftype ia64_frame_init_saved_regs;
static gdbarch_get_saved_register_ftype ia64_get_saved_register;
-static gdbarch_extract_return_value_ftype ia64_extract_return_value;
-static gdbarch_extract_struct_value_address_ftype ia64_extract_struct_value_address;
+static gdbarch_deprecated_extract_return_value_ftype ia64_extract_return_value;
+static gdbarch_deprecated_extract_struct_value_address_ftype ia64_extract_struct_value_address;
static gdbarch_use_struct_convention_ftype ia64_use_struct_convention;
static gdbarch_frameless_function_invocation_ftype ia64_frameless_function_invocation;
-static gdbarch_init_extra_frame_info_ftype ia64_init_extra_frame_info;
-static gdbarch_store_return_value_ftype ia64_store_return_value;
static gdbarch_store_struct_return_ftype ia64_store_struct_return;
static gdbarch_push_arguments_ftype ia64_push_arguments;
static gdbarch_push_return_address_ftype ia64_push_return_address;
#define FIND_GLOBAL_POINTER \
(gdbarch_tdep (current_gdbarch)->find_global_pointer)
-static char *
+static const char *
ia64_register_name (int reg)
{
return ia64_register_names[reg];
if (frame == NULL)
internal_error (__FILE__, __LINE__,
"read_sigcontext_register: NULL frame");
- if (!frame->signal_handler_caller)
+ if (!(get_frame_type (frame) == SIGTRAMP_FRAME))
internal_error (__FILE__, __LINE__,
- "read_sigcontext_register: frame not a signal_handler_caller");
+ "read_sigcontext_register: frame not a signal trampoline");
if (SIGCONTEXT_REGISTER_ADDRESS == 0)
internal_error (__FILE__, __LINE__,
"read_sigcontext_register: SIGCONTEXT_REGISTER_ADDRESS is 0");
- regaddr = SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regnum);
+ regaddr = SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), regnum);
if (regaddr)
return read_memory_integer (regaddr, REGISTER_RAW_SIZE (regnum));
else
int slotnum = (int) (addr & 0x0f) / SLOT_MULTIPLIER;
long long instr;
int val;
+ int template;
if (slotnum > 2)
error("Can't insert breakpoint for slot numbers greater than 2.");
addr &= ~0x0f;
val = target_read_memory (addr, bundle, BUNDLE_LEN);
+
+ /* Check for L type instruction in 2nd slot, if present then
+ bump up the slot number to the 3rd slot */
+ template = extract_bit_field (bundle, 0, 5);
+ if (slotnum == 1 && template_encoding_table[template][1] == L)
+ {
+ slotnum = 2;
+ }
+
instr = slotN_contents (bundle, slotnum);
memcpy(contents_cache, &instr, sizeof(instr));
replace_slotN_contents (bundle, BREAKPOINT, slotnum);
int slotnum = (addr & 0x0f) / SLOT_MULTIPLIER;
long long instr;
int val;
+ int template;
addr &= ~0x0f;
val = target_read_memory (addr, bundle, BUNDLE_LEN);
+
+ /* Check for L type instruction in 2nd slot, if present then
+ bump up the slot number to the 3rd slot */
+ template = extract_bit_field (bundle, 0, 5);
+ if (slotnum == 1 && template_encoding_table[template][1] == L)
+ {
+ slotnum = 2;
+ }
+
memcpy (&instr, contents_cache, sizeof instr);
replace_slotN_contents (bundle, instr, slotnum);
if (val == 0)
/* We don't really want to use this, but remote.c needs to call it in order
to figure out if Z-packets are supported or not. Oh, well. */
-unsigned char *
+const unsigned char *
ia64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
{
static unsigned char breakpoint[] =
even really hard to compute the frame chain, but it can be
computationally expensive. So, instead of making life difficult
(and slow), we pick a more convenient representation of the frame
- chain, knowing that we'll have to make some small adjustments
- in other places. (E.g, note that read_fp() and write_fp() are
- actually read_sp() and write_sp() below in ia64_gdbarch_init()
- below.)
+ chain, knowing that we'll have to make some small adjustments in
+ other places. (E.g, note that read_fp() is actually read_sp() in
+ ia64_gdbarch_init() below.)
Okay, so what is the frame chain exactly? It'll be the SP value
at the time that the function in question was entered.
CORE_ADDR
ia64_frame_chain (struct frame_info *frame)
{
- if (frame->signal_handler_caller)
+ if ((get_frame_type (frame) == SIGTRAMP_FRAME))
return read_sigcontext_register (frame, sp_regnum);
- else if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
- return frame->frame;
+ else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
+ get_frame_base (frame),
+ get_frame_base (frame)))
+ return get_frame_base (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);
+ DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
+ 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;
+ return (get_frame_base (frame)
+ + get_frame_extra_info (frame)->mem_stack_frame_size);
}
}
CORE_ADDR
ia64_frame_saved_pc (struct frame_info *frame)
{
- if (frame->signal_handler_caller)
+ if ((get_frame_type (frame) == SIGTRAMP_FRAME))
return read_sigcontext_register (frame, pc_regnum);
- else if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
- return generic_read_register_dummy (frame->pc, frame->frame, pc_regnum);
+ else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
+ get_frame_base (frame),
+ get_frame_base (frame)))
+ return deprecated_read_register_dummy (get_frame_pc (frame),
+ get_frame_base (frame), pc_regnum);
else
{
- FRAME_INIT_SAVED_REGS (frame);
+ DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
- if (frame->saved_regs[IA64_VRAP_REGNUM])
- return read_memory_integer (frame->saved_regs[IA64_VRAP_REGNUM], 8);
- else if (frame->next && frame->next->signal_handler_caller)
- return read_sigcontext_register (frame->next, IA64_BR0_REGNUM);
+ if (get_frame_saved_regs (frame)[IA64_VRAP_REGNUM])
+ return read_memory_integer (get_frame_saved_regs (frame)[IA64_VRAP_REGNUM], 8);
+ else if (get_next_frame (frame)
+ && (get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME))
+ return read_sigcontext_register (get_next_frame (frame), IA64_BR0_REGNUM);
else /* either frameless, or not far enough along in the prologue... */
return ia64_saved_pc_after_call (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;
if (frame
&& !do_fsr_stuff
- && frame->extra_info->after_prologue != 0
- && frame->extra_info->after_prologue <= lim_pc)
- return frame->extra_info->after_prologue;
+ && get_frame_extra_info (frame)->after_prologue != 0
+ && get_frame_extra_info (frame)->after_prologue <= lim_pc)
+ return get_frame_extra_info (frame)->after_prologue;
lim_pc = refine_prologue_limit (pc, lim_pc, &trust_limit);
/* Hmm... whether or not this will work will depend on
where the pc is. If it's still early in the prologue
this'll be wrong. FIXME */
- spill_addr = (frame ? frame->frame : 0)
+ spill_addr = (frame ? get_frame_base (frame) : 0)
+ (rM == 12 ? 0 : mem_stack_frame_size)
+ imm;
spill_reg = rN;
&& ((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;
{
/* 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)
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);
/* Extract the size of the rotating portion of the stack
frame and the register rename base from the current
frame marker. */
- sor = ((frame->extra_info->cfm >> 14) & 0xf) * 8;
- rrb_gr = (frame->extra_info->cfm >> 18) & 0x7f;
+ sor = ((get_frame_extra_info (frame)->cfm >> 14) & 0xf) * 8;
+ rrb_gr = (get_frame_extra_info (frame)->cfm >> 18) & 0x7f;
- for (i = 0, addr = frame->extra_info->bsp;
- i < frame->extra_info->sof;
+ for (i = 0, addr = get_frame_extra_info (frame)->bsp;
+ i < get_frame_extra_info (frame)->sof;
i++, addr += 8)
{
if (IS_NaT_COLLECTION_ADDR (addr))
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;
}
}
- if (frame && frame->extra_info) {
- frame->extra_info->after_prologue = last_prologue_pc;
- frame->extra_info->mem_stack_frame_size = mem_stack_frame_size;
- frame->extra_info->fp_reg = fp_reg;
- }
+ if (frame && get_frame_extra_info (frame))
+ {
+ get_frame_extra_info (frame)->after_prologue = last_prologue_pc;
+ get_frame_extra_info (frame)->mem_stack_frame_size = mem_stack_frame_size;
+ get_frame_extra_info (frame)->fp_reg = fp_reg;
+ }
return last_prologue_pc;
}
void
ia64_frame_init_saved_regs (struct frame_info *frame)
{
- if (frame->saved_regs)
+ if (get_frame_saved_regs (frame))
return;
- if (frame->signal_handler_caller && SIGCONTEXT_REGISTER_ADDRESS)
+ if ((get_frame_type (frame) == SIGTRAMP_FRAME) && SIGCONTEXT_REGISTER_ADDRESS)
{
int regno;
frame_saved_regs_zalloc (frame);
- frame->saved_regs[IA64_VRAP_REGNUM] =
- SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_IP_REGNUM);
- frame->saved_regs[IA64_CFM_REGNUM] =
- SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_CFM_REGNUM);
- frame->saved_regs[IA64_PSR_REGNUM] =
- SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_PSR_REGNUM);
+ get_frame_saved_regs (frame)[IA64_VRAP_REGNUM] =
+ SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_IP_REGNUM);
+ get_frame_saved_regs (frame)[IA64_CFM_REGNUM] =
+ SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_CFM_REGNUM);
+ get_frame_saved_regs (frame)[IA64_PSR_REGNUM] =
+ SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (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] =
- SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_RNAT_REGNUM);
- frame->saved_regs[IA64_CCV_REGNUM] =
- SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_CCV_REGNUM);
- frame->saved_regs[IA64_UNAT_REGNUM] =
- SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_UNAT_REGNUM);
- frame->saved_regs[IA64_FPSR_REGNUM] =
- SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_FPSR_REGNUM);
- frame->saved_regs[IA64_PFS_REGNUM] =
- SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_PFS_REGNUM);
- frame->saved_regs[IA64_LC_REGNUM] =
- SIGCONTEXT_REGISTER_ADDRESS (frame->frame, IA64_LC_REGNUM);
+ get_frame_saved_regs (frame)[IA64_RNAT_REGNUM] =
+ SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_RNAT_REGNUM);
+ get_frame_saved_regs (frame)[IA64_CCV_REGNUM] =
+ SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_CCV_REGNUM);
+ get_frame_saved_regs (frame)[IA64_UNAT_REGNUM] =
+ SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_UNAT_REGNUM);
+ get_frame_saved_regs (frame)[IA64_FPSR_REGNUM] =
+ SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_FPSR_REGNUM);
+ get_frame_saved_regs (frame)[IA64_PFS_REGNUM] =
+ SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_PFS_REGNUM);
+ get_frame_saved_regs (frame)[IA64_LC_REGNUM] =
+ SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), IA64_LC_REGNUM);
for (regno = IA64_GR1_REGNUM; regno <= IA64_GR31_REGNUM; regno++)
if (regno != sp_regnum)
- frame->saved_regs[regno] =
- SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
+ get_frame_saved_regs (frame)[regno] =
+ SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), regno);
for (regno = IA64_BR0_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
- frame->saved_regs[regno] =
- SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
+ get_frame_saved_regs (frame)[regno] =
+ SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), regno);
for (regno = IA64_FR2_REGNUM; regno <= IA64_BR7_REGNUM; regno++)
- frame->saved_regs[regno] =
- SIGCONTEXT_REGISTER_ADDRESS (frame->frame, regno);
+ get_frame_saved_regs (frame)[regno] =
+ SIGCONTEXT_REGISTER_ADDRESS (get_frame_base (frame), regno);
}
else
{
CORE_ADDR func_start;
- func_start = get_pc_function_start (frame->pc);
- examine_prologue (func_start, frame->pc, frame);
+ func_start = get_pc_function_start (get_frame_pc (frame));
+ examine_prologue (func_start, get_frame_pc (frame), frame);
}
}
if (lval != NULL)
*lval = not_lval;
- is_dummy_frame = PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame);
+ is_dummy_frame = DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
+ get_frame_base (frame),
+ get_frame_base (frame));
- if (regnum == SP_REGNUM && frame->next)
+ if (regnum == SP_REGNUM && get_next_frame (frame))
{
/* Handle SP values for all frames but the topmost. */
- store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), frame->frame);
+ store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
+ get_frame_base (frame));
}
else if (regnum == IA64_BSP_REGNUM)
{
store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
- frame->extra_info->bsp);
+ get_frame_extra_info (frame)->bsp);
}
else if (regnum == IA64_VFP_REGNUM)
{
for the frame pointer, it'll be found by ia64_find_saved_register()
above. If the function lacks one of these frame pointers, we can
still provide a value since we know the size of the frame */
- CORE_ADDR vfp = frame->frame + frame->extra_info->mem_stack_frame_size;
+ CORE_ADDR vfp = (get_frame_base (frame)
+ + get_frame_extra_info (frame)->mem_stack_frame_size);
store_address (raw_buffer, REGISTER_RAW_SIZE (IA64_VFP_REGNUM), vfp);
}
else if (IA64_PR0_REGNUM <= regnum && regnum <= IA64_PR63_REGNUM)
{
/* Fetch predicate register rename base from current frame
marker for this frame. */
- int rrb_pr = (frame->extra_info->cfm >> 32) & 0x3f;
+ int rrb_pr = (get_frame_extra_info (frame)->cfm >> 32) & 0x3f;
/* Adjust the register number to account for register rotation. */
regnum = IA64_PR16_REGNUM
if (!is_dummy_frame)
{
- FRAME_INIT_SAVED_REGS (frame);
- gr_addr = frame->saved_regs[ regnum - IA64_NAT0_REGNUM
- + IA64_GR0_REGNUM];
+ DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
+ gr_addr = get_frame_saved_regs (frame)[ regnum - IA64_NAT0_REGNUM
+ + IA64_GR0_REGNUM];
}
if (gr_addr)
{
else if (regnum == IA64_IP_REGNUM)
{
CORE_ADDR pc;
- if (frame->next)
+ if (get_next_frame (frame))
{
/* FIXME: Set *addrp, *lval when possible. */
- pc = ia64_frame_saved_pc (frame->next);
+ pc = ia64_frame_saved_pc (get_next_frame (frame));
}
else
{
CORE_ADDR addr = 0;
if (!is_dummy_frame)
{
- FRAME_INIT_SAVED_REGS (frame);
- addr = frame->saved_regs[regnum];
+ DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
+ addr = get_frame_saved_regs (frame)[regnum];
}
if (addr != 0)
{
/* Fetch floating point register rename base from current
frame marker for this frame. */
- int rrb_fr = (frame->extra_info->cfm >> 25) & 0x7f;
+ int rrb_fr = (get_frame_extra_info (frame)->cfm >> 25) & 0x7f;
/* Adjust the floating point register number to account for
register rotation. */
+ ((regnum - IA64_FR32_REGNUM) + rrb_fr) % 96;
}
- generic_get_saved_register (raw_buffer, optimized, addrp, frame,
- regnum, lval);
+ deprecated_generic_get_saved_register (raw_buffer, optimized, addrp,
+ frame, regnum, lval);
}
}
int
ia64_frameless_function_invocation (struct frame_info *frame)
{
- FRAME_INIT_SAVED_REGS (frame);
- return (frame->extra_info->mem_stack_frame_size == 0);
+ DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
+ return (get_frame_extra_info (frame)->mem_stack_frame_size == 0);
}
CORE_ADDR
ia64_init_extra_frame_info (int fromleaf, struct frame_info *frame)
{
CORE_ADDR bsp, cfm;
- int next_frame_is_call_dummy = ((frame->next != NULL)
- && PC_IN_CALL_DUMMY (frame->next->pc, frame->next->frame,
- frame->next->frame));
+ int next_frame_is_call_dummy = ((get_next_frame (frame) != NULL)
+ && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (get_next_frame (frame)),
+ get_frame_base (get_next_frame (frame)),
+ get_frame_base (get_next_frame (frame))));
- frame->extra_info = (struct frame_extra_info *)
- frame_obstack_alloc (sizeof (struct frame_extra_info));
+ frame_extra_info_zalloc (frame, sizeof (struct frame_extra_info));
- if (frame->next == 0)
+ if (get_next_frame (frame) == 0)
{
bsp = read_register (IA64_BSP_REGNUM);
cfm = read_register (IA64_CFM_REGNUM);
}
- else if (frame->next->signal_handler_caller)
+ else if ((get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME))
{
- bsp = read_sigcontext_register (frame->next, IA64_BSP_REGNUM);
- cfm = read_sigcontext_register (frame->next, IA64_CFM_REGNUM);
+ bsp = read_sigcontext_register (get_next_frame (frame), IA64_BSP_REGNUM);
+ cfm = read_sigcontext_register (get_next_frame (frame), IA64_CFM_REGNUM);
}
else if (next_frame_is_call_dummy)
{
- bsp = generic_read_register_dummy (frame->next->pc, frame->next->frame,
- IA64_BSP_REGNUM);
- cfm = generic_read_register_dummy (frame->next->pc, frame->next->frame,
- IA64_CFM_REGNUM);
+ bsp = deprecated_read_register_dummy (get_frame_pc (get_next_frame (frame)),
+ get_frame_base (get_next_frame (frame)),
+ IA64_BSP_REGNUM);
+ cfm = deprecated_read_register_dummy (get_frame_pc (get_next_frame (frame)),
+ get_frame_base (get_next_frame (frame)),
+ IA64_CFM_REGNUM);
}
else
{
- struct frame_info *frn = frame->next;
-
- FRAME_INIT_SAVED_REGS (frn);
-
- if (frn->saved_regs[IA64_CFM_REGNUM] != 0)
- cfm = read_memory_integer (frn->saved_regs[IA64_CFM_REGNUM], 8);
- else if (frn->next && frn->next->signal_handler_caller)
- cfm = read_sigcontext_register (frn->next, IA64_PFS_REGNUM);
- else if (frn->next
- && PC_IN_CALL_DUMMY (frn->next->pc, frn->next->frame,
- frn->next->frame))
- cfm = generic_read_register_dummy (frn->next->pc, frn->next->frame,
- IA64_PFS_REGNUM);
+ struct frame_info *frn = get_next_frame (frame);
+
+ DEPRECATED_FRAME_INIT_SAVED_REGS (frn);
+
+ 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 (get_next_frame (frn) && (get_frame_type (get_next_frame (frn)) == SIGTRAMP_FRAME))
+ cfm = read_sigcontext_register (get_next_frame (frn), IA64_PFS_REGNUM);
+ else if (get_next_frame (frn)
+ && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (get_next_frame (frn)),
+ get_frame_base (get_next_frame (frn)),
+ get_frame_base (get_next_frame (frn))))
+ cfm = deprecated_read_register_dummy (get_frame_pc (get_next_frame (frn)),
+ get_frame_base (get_next_frame (frn)),
+ IA64_PFS_REGNUM);
else
cfm = read_register (IA64_PFS_REGNUM);
- bsp = frn->extra_info->bsp;
+ bsp = get_frame_extra_info (frn)->bsp;
}
- frame->extra_info->cfm = cfm;
- frame->extra_info->sof = cfm & 0x7f;
- frame->extra_info->sol = (cfm >> 7) & 0x7f;
- if (frame->next == 0
- || frame->next->signal_handler_caller
+ get_frame_extra_info (frame)->cfm = cfm;
+ get_frame_extra_info (frame)->sof = cfm & 0x7f;
+ get_frame_extra_info (frame)->sol = (cfm >> 7) & 0x7f;
+ if (get_next_frame (frame) == 0
+ || (get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME)
|| next_frame_is_call_dummy)
- frame->extra_info->bsp = rse_address_add (bsp, -frame->extra_info->sof);
+ get_frame_extra_info (frame)->bsp =
+ rse_address_add (bsp, -get_frame_extra_info (frame)->sof);
else
- frame->extra_info->bsp = rse_address_add (bsp, -frame->extra_info->sol);
+ get_frame_extra_info (frame)->bsp =
+ rse_address_add (bsp, -get_frame_extra_info (frame)->sol);
- frame->extra_info->after_prologue = 0;
- frame->extra_info->mem_stack_frame_size = -1; /* Not yet determined */
- frame->extra_info->fp_reg = 0;
+ get_frame_extra_info (frame)->after_prologue = 0;
+ get_frame_extra_info (frame)->mem_stack_frame_size = -1; /* Not yet determined */
+ get_frame_extra_info (frame)->fp_reg = 0;
}
static int
float_elt_type,
floatreg,
VALUE_CONTENTS (arg) + argoffset,
- ®isters[REGISTER_BYTE (floatreg)]);
+ &deprecated_registers[REGISTER_BYTE (floatreg)]);
floatreg++;
argoffset += TYPE_LENGTH (float_elt_type);
len -= TYPE_LENGTH (float_elt_type);
/* Store the struct return value in r8 if necessary. */
if (struct_return)
{
- store_address (®isters[REGISTER_BYTE (IA64_GR8_REGNUM)],
+ store_address (&deprecated_registers[REGISTER_BYTE (IA64_GR8_REGNUM)],
REGISTER_RAW_SIZE (IA64_GR8_REGNUM),
struct_addr);
}
if (TYPE_CODE (type) == TYPE_CODE_FLT)
{
ia64_register_convert_to_raw (type, IA64_FR8_REGNUM, valbuf,
- ®isters[REGISTER_BYTE (IA64_FR8_REGNUM)]);
+ &deprecated_registers[REGISTER_BYTE (IA64_FR8_REGNUM)]);
target_store_registers (IA64_FR8_REGNUM);
}
else
- write_register_bytes (REGISTER_BYTE (IA64_GR8_REGNUM),
- valbuf, TYPE_LENGTH (type));
+ deprecated_write_register_bytes (REGISTER_BYTE (IA64_GR8_REGNUM),
+ valbuf, TYPE_LENGTH (type));
}
void
int regno;
CORE_ADDR bsp, cfm, pfs;
- FRAME_INIT_SAVED_REGS (frame);
+ DEPRECATED_FRAME_INIT_SAVED_REGS (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
&& 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)));
}
}
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
wants bsp to be set at the end of all used registers. It's
likely that this code will need to be revised to accomodate
other operating systems. */
- bsp = rse_address_add (frame->extra_info->bsp,
+ bsp = rse_address_add (get_frame_extra_info (frame)->bsp,
(pfs & 0x7f) - ((pfs >> 7) & 0x7f));
write_register (IA64_BSP_REGNUM, bsp);
gdbarch = gdbarch_alloc (&info, tdep);
tdep->os_ident = os_ident;
+ /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
+ ready to unwind the PC first (see frame.c:get_prev_frame()). */
+ set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
/* Set the method of obtaining the sigcontext addresses at which
registers are saved. The method of checking to see if
set_gdbarch_register_bytes (gdbarch, ia64_num_regs * 8 + 128*8);
set_gdbarch_register_byte (gdbarch, ia64_register_byte);
set_gdbarch_register_raw_size (gdbarch, ia64_register_raw_size);
- set_gdbarch_max_register_raw_size (gdbarch, 16);
+ set_gdbarch_deprecated_max_register_raw_size (gdbarch, 16);
set_gdbarch_register_virtual_size (gdbarch, ia64_register_virtual_size);
- set_gdbarch_max_register_virtual_size (gdbarch, 16);
+ set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 16);
set_gdbarch_register_virtual_type (gdbarch, ia64_register_virtual_type);
set_gdbarch_skip_prologue (gdbarch, ia64_skip_prologue);
set_gdbarch_saved_pc_after_call (gdbarch, ia64_saved_pc_after_call);
set_gdbarch_frame_chain (gdbarch, ia64_frame_chain);
- set_gdbarch_frame_chain_valid (gdbarch, generic_func_frame_chain_valid);
set_gdbarch_frame_saved_pc (gdbarch, ia64_frame_saved_pc);
- set_gdbarch_frame_init_saved_regs (gdbarch, ia64_frame_init_saved_regs);
+ set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, ia64_frame_init_saved_regs);
set_gdbarch_get_saved_register (gdbarch, ia64_get_saved_register);
set_gdbarch_register_convertible (gdbarch, ia64_register_convertible);
set_gdbarch_register_convert_to_raw (gdbarch, ia64_register_convert_to_raw);
set_gdbarch_use_struct_convention (gdbarch, ia64_use_struct_convention);
- set_gdbarch_extract_return_value (gdbarch, ia64_extract_return_value);
+ set_gdbarch_deprecated_extract_return_value (gdbarch, ia64_extract_return_value);
set_gdbarch_store_struct_return (gdbarch, ia64_store_struct_return);
- set_gdbarch_store_return_value (gdbarch, ia64_store_return_value);
- set_gdbarch_extract_struct_value_address (gdbarch, ia64_extract_struct_value_address);
+ set_gdbarch_deprecated_store_return_value (gdbarch, ia64_store_return_value);
+ set_gdbarch_deprecated_extract_struct_value_address (gdbarch, ia64_extract_struct_value_address);
set_gdbarch_memory_insert_breakpoint (gdbarch, ia64_memory_insert_breakpoint);
set_gdbarch_memory_remove_breakpoint (gdbarch, ia64_memory_remove_breakpoint);
set_gdbarch_write_pc (gdbarch, ia64_write_pc);
/* Settings for calling functions in the inferior. */
- set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
set_gdbarch_call_dummy_length (gdbarch, 0);
set_gdbarch_push_arguments (gdbarch, ia64_push_arguments);
set_gdbarch_push_return_address (gdbarch, ia64_push_return_address);
set_gdbarch_call_dummy_words (gdbarch, ia64_call_dummy_words);
set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (ia64_call_dummy_words));
set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
- set_gdbarch_init_extra_frame_info (gdbarch, ia64_init_extra_frame_info);
+ set_gdbarch_deprecated_init_extra_frame_info (gdbarch, ia64_init_extra_frame_info);
set_gdbarch_frame_args_address (gdbarch, ia64_frame_args_address);
set_gdbarch_frame_locals_address (gdbarch, ia64_frame_locals_address);
is all read_fp() is used for), simply use the stack pointer value
instead. */
set_gdbarch_read_fp (gdbarch, generic_target_read_sp);
- set_gdbarch_write_fp (gdbarch, generic_target_write_sp);
/* Settings that should be unnecessary. */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
- set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
set_gdbarch_call_dummy_start_offset (gdbarch, 0);
- set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
- set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
set_gdbarch_decr_pc_after_break (gdbarch, 0);
projects / deliverable / binutils-gdb.git / blobdiff