/* Target dependent code for CRIS, for GDB, the GNU debugger.
- Copyright 2001 Free Software Foundation, Inc.
+ Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
Contributed by Axis Communications AB.
Written by Hendrik Ruijter, Stefan Andersson, and Orjan Friberg.
short source_register;
/* This frame is with respect to a leaf until a push srp is found. */
- fi->extra_info->leaf_function = 1;
+ get_frame_extra_info (fi)->leaf_function = 1;
/* This frame is without the FP until a push fp is found. */
have_fp = 0;
/* We only want to know the end of the prologue when fi->saved_regs == 0.
When the saved registers are allocated full information is required. */
- if (fi->saved_regs)
+ if (get_frame_saved_regs (fi))
{
for (regno = 0; regno < NUM_REGS; regno++)
- fi->saved_regs[regno] = 0;
+ get_frame_saved_regs (fi)[regno] = 0;
}
/* Find the prologue instructions. */
{
return ip;
}
- fi->extra_info->leaf_function = 0;
+ get_frame_extra_info (fi)->leaf_function = 0;
}
else if (regno == FP_REGNUM)
{
/* We only want to know the end of the prologue when
fi->saved_regs == 0. */
- if (!fi->saved_regs)
+ if (!get_frame_saved_regs (fi))
return ip;
if (have_fp)
{
- fi->saved_regs[FP_REGNUM] = get_frame_base (fi);
+ get_frame_saved_regs (fi)[FP_REGNUM] = get_frame_base (fi);
/* Calculate the addresses. */
for (regno = regsave; regno >= 0; regno--)
{
- fi->saved_regs[regno] = get_frame_base (fi) - val;
+ get_frame_saved_regs (fi)[regno] = get_frame_base (fi) - val;
val -= 4;
}
- if (fi->extra_info->leaf_function)
+ if (get_frame_extra_info (fi)->leaf_function)
{
/* Set the register SP to contain the stack pointer of
the caller. */
- fi->saved_regs[SP_REGNUM] = get_frame_base (fi) + 4;
+ get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 4;
}
else
{
/* Set the register SP to contain the stack pointer of
the caller. */
- fi->saved_regs[SP_REGNUM] = get_frame_base (fi) + 8;
+ get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 8;
/* Set the register SRP to contain the return address of
the caller. */
- fi->saved_regs[SRP_REGNUM] = get_frame_base (fi) + 4;
+ get_frame_saved_regs (fi)[SRP_REGNUM] = get_frame_base (fi) + 4;
}
}
return ip;
CORE_ADDR
cris_skip_prologue_main (CORE_ADDR pc, int frameless_p)
{
- struct frame_info fi;
- static struct frame_extra_info fei;
+ struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
+ struct frame_info *fi;
struct symtab_and_line sal = find_pc_line (pc, 0);
int best_limit;
CORE_ADDR pc_after_prologue;
- /* frame_info now contains dynamic memory. Since fi is a dummy here,
- I use static memory for extra_info, and don't bother allocating
- memory for saved_regs. */
- fi.saved_regs = 0;
- fi.extra_info = &fei;
+ /* frame_info now contains dynamic memory. Since fi is a dummy
+ here, I don't bother allocating memory for saved_regs. */
+ fi = deprecated_frame_xmalloc_with_cleanup (0, sizeof (struct frame_extra_info));
/* If there is no symbol information then sal.end == 0, and we end up
examining only the first instruction in the function prologue.
else
best_limit = pc + 100;
- pc_after_prologue = cris_examine (pc, best_limit, &fi, frameless_p);
+ pc_after_prologue = cris_examine (pc, best_limit, fi, frameless_p);
+ do_cleanups (old_chain);
return pc_after_prologue;
}
return frameless_look_for_prologue (fi);
}
-/* See frame.h. Determines the address of all registers in the current stack
- frame storing each in frame->saved_regs. Space for frame->saved_regs shall
- be allocated by FRAME_INIT_SAVED_REGS using either frame_saved_regs_zalloc
- or frame_obstack_alloc. */
+/* See frame.h. Determines the address of all registers in the
+ current stack frame storing each in frame->saved_regs. Space for
+ frame->saved_regs shall be allocated by
+ DEPRECATED_FRAME_INIT_SAVED_REGS using frame_saved_regs_zalloc. */
void
cris_frame_init_saved_regs (struct frame_info *fi)
CORE_ADDR ip;
struct symtab_and_line sal;
int best_limit;
- char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi), fi->frame);
+ char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi),
+ get_frame_base (fi));
/* Examine the entire prologue. */
register int frameless_p = 0;
/* Has this frame's registers already been initialized? */
- if (fi->saved_regs)
+ if (get_frame_saved_regs (fi))
return;
frame_saved_regs_zalloc (fi);
/* I don't see this ever happening, considering the context in which
cris_frame_init_saved_regs is called (always when we're not in
a dummy frame). */
- memcpy (&fi->saved_regs, dummy_regs, sizeof (fi->saved_regs));
+ memcpy (get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS);
}
else
{
- ip = get_pc_function_start (get_frame_pc (fi));
+ ip = get_frame_func (fi);
sal = find_pc_line (ip, 0);
/* If there is no symbol information then sal.end == 0, and we end up
void
cris_init_extra_frame_info (int fromleaf, struct frame_info *fi)
{
- if (fi->next)
+ if (get_next_frame (fi))
{
/* Called from get_prev_frame. */
- deprecated_update_frame_pc_hack (fi, FRAME_SAVED_PC (fi->next));
+ deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
}
- fi->extra_info = (struct frame_extra_info *)
- frame_obstack_alloc (sizeof (struct frame_extra_info));
+ frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
- fi->extra_info->return_pc = 0;
- fi->extra_info->leaf_function = 0;
+ get_frame_extra_info (fi)->return_pc = 0;
+ get_frame_extra_info (fi)->leaf_function = 0;
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi),
+ get_frame_base (fi),
+ get_frame_base (fi)))
{
/* We need to setup fi->frame here because run_stack_dummy gets it wrong
by assuming it's always FP. */
- fi->frame = deprecated_read_register_dummy (get_frame_pc (fi), fi->frame,
- SP_REGNUM);
- fi->extra_info->return_pc =
- deprecated_read_register_dummy (get_frame_pc (fi), fi->frame, PC_REGNUM);
+ deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), SP_REGNUM));
+ get_frame_extra_info (fi)->return_pc =
+ deprecated_read_register_dummy (get_frame_pc (fi),
+ get_frame_base (fi), PC_REGNUM);
/* FIXME: Is this necessarily true? */
- fi->extra_info->leaf_function = 0;
+ get_frame_extra_info (fi)->leaf_function = 0;
}
else
{
/* Check fromleaf/frameless_function_invocation. (FIXME) */
- if (fi->saved_regs[SRP_REGNUM] != 0)
+ if (get_frame_saved_regs (fi)[SRP_REGNUM] != 0)
{
/* SRP was saved on the stack; non-leaf function. */
- fi->extra_info->return_pc =
- read_memory_integer (fi->saved_regs[SRP_REGNUM],
+ get_frame_extra_info (fi)->return_pc =
+ read_memory_integer (get_frame_saved_regs (fi)[SRP_REGNUM],
REGISTER_RAW_SIZE (SRP_REGNUM));
}
else
{
/* SRP is still in a register; leaf function. */
- fi->extra_info->return_pc = read_register (SRP_REGNUM);
+ get_frame_extra_info (fi)->return_pc = read_register (SRP_REGNUM);
/* FIXME: Should leaf_function be set to 1 here? */
- fi->extra_info->leaf_function = 1;
+ get_frame_extra_info (fi)->leaf_function = 1;
}
}
}
CORE_ADDR
cris_frame_chain (struct frame_info *fi)
{
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi),
+ get_frame_base (fi),
+ get_frame_base (fi)))
{
- return fi->frame;
+ return get_frame_base (fi);
}
else if (!inside_entry_file (get_frame_pc (fi)))
{
CORE_ADDR
cris_frame_saved_pc (struct frame_info *fi)
{
- return fi->extra_info->return_pc;
+ return get_frame_extra_info (fi)->return_pc;
}
/* Setup the function arguments for calling a function in the inferior. */
register int regno;
register int stack_offset = 0;
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi),
+ get_frame_base (fi),
+ get_frame_base (fi)))
{
/* This happens when we hit a breakpoint set at the entry point,
when returning from a dummy frame. */
after SP was saved. */
for (regno = 0; regno < FP_REGNUM; regno++)
{
- if (fi->saved_regs[regno])
+ if (get_frame_saved_regs (fi)[regno])
{
write_register (regno,
- read_memory_integer (fi->saved_regs[regno], 4));
+ read_memory_integer (get_frame_saved_regs (fi)[regno], 4));
}
}
- if (fi->saved_regs[FP_REGNUM])
+ if (get_frame_saved_regs (fi)[FP_REGNUM])
{
/* Pop the frame pointer (R8). It was pushed before SP
was saved. */
write_register (FP_REGNUM,
- read_memory_integer (fi->saved_regs[FP_REGNUM], 4));
+ read_memory_integer (get_frame_saved_regs (fi)[FP_REGNUM], 4));
stack_offset += 4;
/* Not a leaf function. */
- if (fi->saved_regs[SRP_REGNUM])
+ if (get_frame_saved_regs (fi)[SRP_REGNUM])
{
/* SRP was pushed before SP was saved. */
stack_offset += 4;
}
/* Restore the SP and adjust for R8 and (possibly) SRP. */
- write_register (SP_REGNUM, fi->saved_regs[FP_REGNUM] + stack_offset);
+ write_register (SP_REGNUM, get_frame_saved_regs (fi)[FP_REGNUM] + stack_offset);
}
else
{
}
/* Restore the PC. */
- write_register (PC_REGNUM, fi->extra_info->return_pc);
+ write_register (PC_REGNUM, get_frame_extra_info (fi)->return_pc);
}
flush_cached_frames ();
}
/* Just a forward declaration. */
-unsigned long
-get_data_from_address (unsigned short *inst, CORE_ADDR address);
+unsigned long get_data_from_address (unsigned short *inst, CORE_ADDR address);
/* Calculates the prefix value for the general case of offset addressing
mode. */
if (storage_needed > 0)
{
symbol_table = (asymbol **) xmalloc (storage_needed);
- back_to = make_cleanup (free, (PTR) symbol_table);
+ back_to = make_cleanup (free, symbol_table);
number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
for (i = 0; i < number_of_symbols; i++)
if (tdep->cris_abi == CRIS_ABI_ORIGINAL)
{
set_gdbarch_double_bit (gdbarch, 32);
- set_gdbarch_push_arguments (gdbarch, cris_abi_original_push_arguments);
+ set_gdbarch_deprecated_push_arguments (gdbarch, cris_abi_original_push_arguments);
set_gdbarch_deprecated_store_return_value (gdbarch,
cris_abi_original_store_return_value);
set_gdbarch_deprecated_extract_return_value
else if (tdep->cris_abi == CRIS_ABI_V2)
{
set_gdbarch_double_bit (gdbarch, 64);
- set_gdbarch_push_arguments (gdbarch, cris_abi_v2_push_arguments);
+ set_gdbarch_deprecated_push_arguments (gdbarch, cris_abi_v2_push_arguments);
set_gdbarch_deprecated_store_return_value (gdbarch, cris_abi_v2_store_return_value);
set_gdbarch_deprecated_extract_return_value
(gdbarch, cris_abi_v2_extract_return_value);
set_gdbarch_register_raw_size (gdbarch, cris_register_size);
/* The largest value REGISTER_RAW_SIZE can have. */
- set_gdbarch_max_register_raw_size (gdbarch, 32);
+ set_gdbarch_deprecated_max_register_raw_size (gdbarch, 32);
/* The length of the registers in the program's representation. */
set_gdbarch_register_virtual_size (gdbarch, cris_register_size);
/* The largest value REGISTER_VIRTUAL_SIZE can have. */
- set_gdbarch_max_register_virtual_size (gdbarch, 32);
+ set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 32);
set_gdbarch_register_virtual_type (gdbarch, cris_register_virtual_type);
/* Use generic dummy frames. */
- /* Where to execute the call in the memory segments. */
- set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
-
- /* Start execution at the beginning of dummy. */
- set_gdbarch_call_dummy_start_offset (gdbarch, 0);
- set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
-
- /* Set to 1 since call_dummy_breakpoint_offset was defined. */
- set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
-
/* Read all about dummy frames in blockframe.c. */
- set_gdbarch_call_dummy_length (gdbarch, 0);
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
/* Defined to 1 to indicate that the target supports inferior function
calls. */
- set_gdbarch_call_dummy_p (gdbarch, 1);
set_gdbarch_call_dummy_words (gdbarch, 0);
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
- /* No stack adjustment needed when peforming an inferior function call. */
- set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
- set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
-
- set_gdbarch_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
+ set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
/* No register requires conversion from raw format to virtual format. */
set_gdbarch_register_convertible (gdbarch, generic_register_convertible_not);
- set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
- set_gdbarch_push_return_address (gdbarch, cris_push_return_address);
- set_gdbarch_pop_frame (gdbarch, cris_pop_frame);
+ set_gdbarch_deprecated_push_return_address (gdbarch, cris_push_return_address);
+ set_gdbarch_deprecated_pop_frame (gdbarch, cris_pop_frame);
- set_gdbarch_store_struct_return (gdbarch, cris_store_struct_return);
+ set_gdbarch_deprecated_store_struct_return (gdbarch, cris_store_struct_return);
set_gdbarch_deprecated_extract_struct_value_address
(gdbarch, cris_extract_struct_value_address);
set_gdbarch_use_struct_convention (gdbarch, cris_use_struct_convention);
- set_gdbarch_frame_init_saved_regs (gdbarch, cris_frame_init_saved_regs);
- set_gdbarch_init_extra_frame_info (gdbarch, cris_init_extra_frame_info);
+ set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, cris_frame_init_saved_regs);
+ set_gdbarch_deprecated_init_extra_frame_info (gdbarch, cris_init_extra_frame_info);
set_gdbarch_skip_prologue (gdbarch, cris_skip_prologue);
set_gdbarch_prologue_frameless_p (gdbarch, generic_prologue_frameless_p);
set_gdbarch_frame_args_skip (gdbarch, 0);
set_gdbarch_frameless_function_invocation
(gdbarch, cris_frameless_function_invocation);
- set_gdbarch_frame_chain (gdbarch, cris_frame_chain);
- set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
+ set_gdbarch_deprecated_frame_chain (gdbarch, cris_frame_chain);
- set_gdbarch_frame_saved_pc (gdbarch, cris_frame_saved_pc);
- set_gdbarch_saved_pc_after_call (gdbarch, cris_saved_pc_after_call);
+ set_gdbarch_deprecated_frame_saved_pc (gdbarch, cris_frame_saved_pc);
+ set_gdbarch_deprecated_saved_pc_after_call (gdbarch, cris_saved_pc_after_call);
set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
- /* No extra stack alignment needed. Set to 1 by default. */
- set_gdbarch_extra_stack_alignment_needed (gdbarch, 0);
-
/* Helpful for backtracing and returning in a call dummy. */
set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
+ /* Should be using push_dummy_call. */
+ set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
+
/* Use target_specific function to define link map offsets. */
set_solib_svr4_fetch_link_map_offsets
(gdbarch, cris_linux_svr4_fetch_link_map_offsets);
projects / binutils-gdb.git / blobdiff