/* Target-dependent code for the IA-64 for GDB, the GNU debugger.
- Copyright 1999, 2000, 2001
- Free Software Foundation, Inc.
+
+ Copyright 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GDB.
static gdbarch_register_byte_ftype ia64_register_byte;
static gdbarch_breakpoint_from_pc_ftype ia64_breakpoint_from_pc;
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;
-static gdbarch_pop_frame_ftype ia64_pop_frame;
static gdbarch_saved_pc_after_call_ftype ia64_saved_pc_after_call;
static void ia64_pop_frame_regular (struct frame_info *frame);
static struct type *is_float_or_hfa_type (struct type *t);
#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)));
}
}
write_register (sp_regnum, FRAME_CHAIN (frame));
- write_pc (FRAME_SAVED_PC (frame));
+ write_pc (DEPRECATED_FRAME_SAVED_PC (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
size of the frame and the size of the locals (both wrt the
frame that we're going back to). This seems kind of strange,
especially since it seems like we ought to be subtracting the
- size of the locals... and we should; but the linux kernel
+ size of the locals... and we should; but the Linux kernel
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);
{
os_ident = elf_elfheader (info.abfd)->e_ident[EI_OSABI];
- /* If os_ident is 0, it is not necessarily the case that we're on a
- SYSV system. (ELFOSABI_NONE is defined to be 0.) GNU/Linux uses
- a note section to record OS/ABI info, but leaves e_ident[EI_OSABI]
- zero. So we have to check for note sections too. */
+ /* If os_ident is 0, it is not necessarily the case that we're
+ on a SYSV system. (ELFOSABI_NONE is defined to be 0.)
+ GNU/Linux uses a note section to record OS/ABI info, but
+ leaves e_ident[EI_OSABI] zero. So we have to check for note
+ sections too. */
if (os_ident == 0)
{
bfd_map_over_sections (info.abfd,
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
else
tdep->sigcontext_register_address = 0;
- /* We know that Linux won't have to resort to the native_find_global_pointer
- hackery. But that's the only one we know about so far, so if
- native_find_global_pointer is set to something non-zero, then use
- it. Otherwise fall back to using generic_elf_find_global_pointer.
- This arrangement should (in theory) allow us to cross debug Linux
- binaries from an AIX machine. */
+ /* We know that GNU/Linux won't have to resort to the
+ native_find_global_pointer hackery. But that's the only one we
+ know about so far, so if native_find_global_pointer is set to
+ something non-zero, then use it. Otherwise fall back to using
+ generic_elf_find_global_pointer. This arrangement should (in
+ theory) allow us to cross debug GNU/Linux binaries from an AIX
+ machine. */
if (os_ident == ELFOSABI_LINUX)
tdep->find_global_pointer = generic_elf_find_global_pointer;
else if (native_find_global_pointer != 0)
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_deprecated_frame_saved_pc (gdbarch, ia64_frame_saved_pc);
- set_gdbarch_frame_init_saved_regs (gdbarch, ia64_frame_init_saved_regs);
- set_gdbarch_get_saved_register (gdbarch, ia64_get_saved_register);
+ set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, ia64_frame_init_saved_regs);
+ set_gdbarch_deprecated_get_saved_register (gdbarch, ia64_get_saved_register);
set_gdbarch_register_convertible (gdbarch, ia64_register_convertible);
set_gdbarch_register_convert_to_virtual (gdbarch, ia64_register_convert_to_virtual);
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_pop_frame (gdbarch, ia64_pop_frame);
+ set_gdbarch_deprecated_pop_frame (gdbarch, ia64_pop_frame);
set_gdbarch_call_dummy_p (gdbarch, 1);
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);
set_gdbarch_function_start_offset (gdbarch, 0);
+ set_gdbarch_frame_args_skip (gdbarch, 0);
set_gdbarch_remote_translate_xfer_address (
gdbarch, ia64_remote_translate_xfer_address);
projects / deliverable / binutils-gdb.git / blobdiff