/* 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.
#include "solib.h" /* Support for shared libraries. */
#include "solib-svr4.h" /* For struct link_map_offsets. */
+#include "gdb_string.h"
enum cris_num_regs
};
/* Register numbers of various important registers.
- FP_REGNUM Contains address of executing stack frame.
+ DEPRECATED_FP_REGNUM Contains address of executing stack frame.
STR_REGNUM Contains the address of structure return values.
RET_REGNUM Contains the return value when shorter than or equal to 32 bits
ARG1_REGNUM Contains the first parameter to a function.
SRP_REGNUM Subroutine return pointer register.
BRP_REGNUM Breakpoint return pointer register. */
-/* FP_REGNUM = 8, SP_REGNUM = 14, and PC_REGNUM = 15 have been incorporated
- into the multi-arch framework. */
+/* DEPRECATED_FP_REGNUM = 8, SP_REGNUM = 14, and PC_REGNUM = 15 have
+ been incorporated into the multi-arch framework. */
enum cris_regnums
{
CORE_ADDR frame
CORE_ADDR pc
- int signal_handler_caller
+ enum frame_type type;
CORE_ADDR return_pc
int leaf_function
of the register PC. All other frames contain the content of the
register PC in the next frame.
- The variable signal_handler_caller is non-zero when the frame is
- associated with the call of a signal handler.
+ The variable `type' indicates the frame's type: normal, SIGTRAMP
+ (associated with a signal handler), dummy (associated with a dummy
+ frame).
The variable return_pc contains the address where execution should be
resumed when the present frame has finished, the return address.
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)
+ else if (regno == DEPRECATED_FP_REGNUM)
{
have_fp = 1;
}
break;
}
}
- else if (cris_get_operand2 (insn) == FP_REGNUM
+ else if (cris_get_operand2 (insn) == DEPRECATED_FP_REGNUM
/* The size is a fixed-size. */
&& ((insn & 0x0F00) >> 8) == 0x0001
/* A negative offset. */
break;
}
}
- else if (cris_get_operand2 (insn) == FP_REGNUM
+ else if (cris_get_operand2 (insn) == DEPRECATED_FP_REGNUM
/* The size is a fixed-size. */
&& ((insn & 0x0F00) >> 8) == 0x0001
/* A positive offset. */
/* 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] = FRAME_FP (fi);
+ get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] = get_frame_base (fi);
/* Calculate the addresses. */
for (regno = regsave; regno >= 0; regno--)
{
- fi->saved_regs[regno] = FRAME_FP (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] = FRAME_FP (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] = FRAME_FP (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] = FRAME_FP (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;
}
{
int len = TYPE_LENGTH (type);
- if (len <= REGISTER_SIZE)
- write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, len);
+ if (len <= DEPRECATED_REGISTER_SIZE)
+ deprecated_write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, len);
else
internal_error (__FILE__, __LINE__, "cris_abi_original_store_return_value: type length too large.");
}
{
int len = TYPE_LENGTH (type);
- if (len <= 2 * REGISTER_SIZE)
+ if (len <= 2 * DEPRECATED_REGISTER_SIZE)
{
/* Note that this works since R10 and R11 are consecutive registers. */
- write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf, len);
+ deprecated_write_register_bytes (REGISTER_BYTE (RET_REGNUM), valbuf,
+ len);
}
else
internal_error (__FILE__, __LINE__, "cris_abi_v2_store_return_value: type length too large.");
int
cris_register_bytes_ok (long bytes)
{
- return (bytes == REGISTER_BYTES);
+ return (bytes == DEPRECATED_REGISTER_BYTES);
}
/* Extract from an array regbuf containing the raw register state a function
{
int len = TYPE_LENGTH (type);
- if (len <= REGISTER_SIZE)
+ if (len <= DEPRECATED_REGISTER_SIZE)
memcpy (valbuf, regbuf + REGISTER_BYTE (RET_REGNUM), len);
else
internal_error (__FILE__, __LINE__, "cris_abi_original_extract_return_value: type length too large");
{
int len = TYPE_LENGTH (type);
- if (len <= 2 * REGISTER_SIZE)
+ if (len <= 2 * DEPRECATED_REGISTER_SIZE)
memcpy (valbuf, regbuf + REGISTER_BYTE (RET_REGNUM), len);
else
internal_error (__FILE__, __LINE__, "cris_abi_v2_extract_return_value: type length too large");
int
cris_frameless_function_invocation (struct frame_info *fi)
{
- if (fi->signal_handler_caller)
+ if ((get_frame_type (fi) == SIGTRAMP_FRAME))
return 0;
else
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 (fi->pc, 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 (fi->pc);
+ 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. */
- fi->pc = 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 (PC_IN_CALL_DUMMY (fi->pc, 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 = generic_read_register_dummy (fi->pc, fi->frame, SP_REGNUM);
- fi->extra_info->return_pc =
- generic_read_register_dummy (fi->pc, fi->frame, PC_REGNUM);
+ /* We need to setup fi->frame here because call_function_by_hand
+ gets it wrong by assuming it's always FP. */
+ 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 (PC_IN_CALL_DUMMY (fi->pc, 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 (fi->pc))
+ else if (!inside_entry_file (get_frame_pc (fi)))
{
- return read_memory_unsigned_integer (FRAME_FP (fi), 4);
+ return read_memory_unsigned_integer (get_frame_base (fi), 4);
}
else
{
CORE_ADDR
cris_frame_saved_pc (struct frame_info *fi)
{
- return fi->extra_info->return_pc;
-}
-
-/* Return the address of the argument block for the frame described
- by struct frame_info. */
-
-CORE_ADDR
-cris_frame_args_address (struct frame_info *fi)
-{
- return FRAME_FP (fi);
-}
-
-/* Return the address of the locals block for the frame
- described by struct frame_info. */
-
-CORE_ADDR
-cris_frame_locals_address (struct frame_info *fi)
-{
- return FRAME_FP (fi);
+ return get_frame_extra_info (fi)->return_pc;
}
/* Setup the function arguments for calling a function in the inferior. */
/* Make sure there's space on the stack. Allocate space for data and a
parameter to refer to that data. */
for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
- stack_alloc += (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + REGISTER_SIZE);
+ stack_alloc += (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + DEPRECATED_REGISTER_SIZE);
sp -= stack_alloc;
/* We may over-allocate a little here, but that won't hurt anything. */
/* Initialize stack frame pointers. */
fp_params = sp;
- fp_data = sp + (nargs * REGISTER_SIZE);
+ fp_data = sp + (nargs * DEPRECATED_REGISTER_SIZE);
/* Now load as many as possible of the first arguments into
registers, and push the rest onto the stack. */
len = TYPE_LENGTH (type);
val = (char *) VALUE_CONTENTS (args[argnum]);
- if (len <= REGISTER_SIZE && argreg <= ARG4_REGNUM)
+ if (len <= DEPRECATED_REGISTER_SIZE && argreg <= ARG4_REGNUM)
{
/* Data fits in a register; put it in the first available
register. */
write_register (argreg, *(unsigned long *) val);
argreg++;
}
- else if (len > REGISTER_SIZE && argreg <= ARG4_REGNUM)
+ else if (len > DEPRECATED_REGISTER_SIZE && argreg <= ARG4_REGNUM)
{
/* Data does not fit in register; pass it on the stack and
put its address in the first available register. */
fp_data += len;
argreg++;
}
- else if (len > REGISTER_SIZE)
+ else if (len > DEPRECATED_REGISTER_SIZE)
{
/* Data does not fit in register; put both data and
parameter on the stack. */
write_memory (fp_data, val, len);
- write_memory (fp_params, (char *) (&fp_data), REGISTER_SIZE);
+ write_memory (fp_params, (char *) (&fp_data), DEPRECATED_REGISTER_SIZE);
fp_data += len;
- fp_params += REGISTER_SIZE;
+ fp_params += DEPRECATED_REGISTER_SIZE;
}
else
{
/* Data fits in a register, but we are out of registers;
put the parameter on the stack. */
- write_memory (fp_params, val, REGISTER_SIZE);
- fp_params += REGISTER_SIZE;
+ write_memory (fp_params, val, DEPRECATED_REGISTER_SIZE);
+ fp_params += DEPRECATED_REGISTER_SIZE;
}
}
int reg_demand;
len = TYPE_LENGTH (VALUE_TYPE (args[argnum]));
- reg_demand = (len / REGISTER_SIZE) + (len % REGISTER_SIZE != 0 ? 1 : 0);
+ reg_demand = (len / DEPRECATED_REGISTER_SIZE) + (len % DEPRECATED_REGISTER_SIZE != 0 ? 1 : 0);
- /* reg_demand * REGISTER_SIZE is the amount of memory we might need to
- allocate for this argument. 2 * REGISTER_SIZE is the amount of stack
- space we might need to pass the argument itself (either by value or by
+ /* reg_demand * DEPRECATED_REGISTER_SIZE is the amount of memory
+ we might need to allocate for this argument. 2 *
+ DEPRECATED_REGISTER_SIZE is the amount of stack space we
+ might need to pass the argument itself (either by value or by
reference). */
- stack_alloc += (reg_demand * REGISTER_SIZE + 2 * REGISTER_SIZE);
+ stack_alloc += (reg_demand * DEPRECATED_REGISTER_SIZE + 2 * DEPRECATED_REGISTER_SIZE);
}
sp -= stack_alloc;
/* We may over-allocate a little here, but that won't hurt anything. */
/* Initialize frame pointers. */
fp_arg = sp;
- fp_mem = sp + (nargs * (2 * REGISTER_SIZE));
+ fp_mem = sp + (nargs * (2 * DEPRECATED_REGISTER_SIZE));
/* Now load as many as possible of the first arguments into registers,
and push the rest onto the stack. */
val = (char *) VALUE_CONTENTS (args[argnum]);
/* How may registers worth of storage do we need for this argument? */
- reg_demand = (len / REGISTER_SIZE) + (len % REGISTER_SIZE != 0 ? 1 : 0);
+ reg_demand = (len / DEPRECATED_REGISTER_SIZE) + (len % DEPRECATED_REGISTER_SIZE != 0 ? 1 : 0);
- if (len <= (2 * REGISTER_SIZE)
+ if (len <= (2 * DEPRECATED_REGISTER_SIZE)
&& (argreg + reg_demand - 1 <= ARG4_REGNUM))
{
/* Data passed by value. Fits in available register(s). */
{
write_register (argreg, *(unsigned long *) val);
argreg++;
- val += REGISTER_SIZE;
+ val += DEPRECATED_REGISTER_SIZE;
}
}
- else if (len <= (2 * REGISTER_SIZE) && argreg <= ARG4_REGNUM)
+ else if (len <= (2 * DEPRECATED_REGISTER_SIZE) && argreg <= ARG4_REGNUM)
{
/* Data passed by value. Does not fit in available register(s).
Use the register(s) first, then the stack. */
{
write_register (argreg, *(unsigned long *) val);
argreg++;
- val += REGISTER_SIZE;
+ val += DEPRECATED_REGISTER_SIZE;
}
else
{
- /* I guess this memory write could write the remaining data
- all at once instead of in REGISTER_SIZE chunks. */
- write_memory (fp_arg, val, REGISTER_SIZE);
- fp_arg += REGISTER_SIZE;
- val += REGISTER_SIZE;
+ /* I guess this memory write could write the
+ remaining data all at once instead of in
+ DEPRECATED_REGISTER_SIZE chunks. */
+ write_memory (fp_arg, val, DEPRECATED_REGISTER_SIZE);
+ fp_arg += DEPRECATED_REGISTER_SIZE;
+ val += DEPRECATED_REGISTER_SIZE;
}
}
}
- else if (len > (2 * REGISTER_SIZE))
+ else if (len > (2 * DEPRECATED_REGISTER_SIZE))
{
/* Data passed by reference. Put it on the stack. */
write_memory (fp_mem, val, len);
- write_memory (fp_arg, (char *) (&fp_mem), REGISTER_SIZE);
+ write_memory (fp_arg, (char *) (&fp_mem), DEPRECATED_REGISTER_SIZE);
/* fp_mem need not be word-aligned since it's just a chunk of
memory being pointed at. That is, += len would do. */
- fp_mem += reg_demand * REGISTER_SIZE;
- fp_arg += REGISTER_SIZE;
+ fp_mem += reg_demand * DEPRECATED_REGISTER_SIZE;
+ fp_arg += DEPRECATED_REGISTER_SIZE;
}
else
{
/* fp_arg must be word-aligned (i.e., don't += len) to match
the function prologue. */
- fp_arg += reg_demand * REGISTER_SIZE;
+ fp_arg += reg_demand * DEPRECATED_REGISTER_SIZE;
}
}
register int regno;
register int stack_offset = 0;
- if (PC_IN_CALL_DUMMY (fi->pc, 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. */
/* Restore general registers R0 - R7. They were pushed on the stack
after SP was saved. */
- for (regno = 0; regno < FP_REGNUM; regno++)
+ for (regno = 0; regno < DEPRECATED_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)[DEPRECATED_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));
+ write_register (DEPRECATED_FP_REGNUM,
+ read_memory_integer (get_frame_saved_regs (fi)[DEPRECATED_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)[DEPRECATED_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. */
static int
cris_delayed_get_disassembler (bfd_vma addr, disassemble_info *info)
{
- tm_print_insn = cris_get_disassembler (exec_bfd);
+ deprecated_tm_print_insn = cris_get_disassembler (exec_bfd);
return TARGET_PRINT_INSN (addr, info);
}
function (since there's no push srp in that case). */
int innermost_frame = 1;
- read_register_gen (PC_REGNUM, (char *) &pc);
- read_register_gen (SP_REGNUM, (char *) &sp);
+ deprecated_read_register_gen (PC_REGNUM, (char *) &pc);
+ deprecated_read_register_gen (SP_REGNUM, (char *) &sp);
/* We make an explicit return when we can't find an outer frame. */
while (1)
/* We couldn't find a push srp in the prologue, so this must be
a leaf function, and thus we use the srp register directly.
This should happen at most once, for the innermost function. */
- read_register_gen (SRP_REGNUM, (char *) &pc);
+ deprecated_read_register_gen (SRP_REGNUM, (char *) &pc);
}
else
{
gdbarch_register (bfd_arch_cris, cris_gdbarch_init, cris_dump_tdep);
/* Used in disassembly. */
- tm_print_insn = cris_delayed_get_disassembler;
+ deprecated_tm_print_insn = cris_delayed_get_disassembler;
/* CRIS-specific user-commands. */
c = add_set_cmd ("cris-version", class_support, var_integer,
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++)
tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
gdbarch = gdbarch_alloc (&info, tdep);
+ /* 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);
+
tdep->cris_version = cris_version;
tdep->cris_mode = cris_mode;
tdep->cris_abi = cris_abi;
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_store_return_value (gdbarch,
+ 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
(gdbarch, cris_abi_original_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_store_return_value (gdbarch, cris_abi_v2_store_return_value);
+ 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_reg_struct_has_addr (gdbarch,
/* There are 32 registers (some of which may not be implemented). */
set_gdbarch_num_regs (gdbarch, 32);
set_gdbarch_sp_regnum (gdbarch, 14);
- set_gdbarch_fp_regnum (gdbarch, 8);
+ set_gdbarch_deprecated_fp_regnum (gdbarch, 8);
set_gdbarch_pc_regnum (gdbarch, 15);
set_gdbarch_register_name (gdbarch, cris_register_name);
/* Length of ordinary registers used in push_word and a few other places.
REGISTER_RAW_SIZE is the real way to know how big a register is. */
- set_gdbarch_register_size (gdbarch, 4);
+ set_gdbarch_deprecated_register_size (gdbarch, 4);
/* NEW */
set_gdbarch_register_bytes_ok (gdbarch, cris_register_bytes_ok);
internal_error (__FILE__, __LINE__, "cris_gdbarch_init: unknown CRIS version");
}
- set_gdbarch_register_bytes (gdbarch, register_bytes);
+ set_gdbarch_deprecated_register_bytes (gdbarch, register_bytes);
/* Returns the register offset for the first byte of register regno's space
in the saved register state. */
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. */
- set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
-
- /* Where to execute the call in the memory segments. */
- set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
- 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_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point);
+ 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);
+ set_gdbarch_deprecated_call_dummy_words (gdbarch, 0);
+ set_gdbarch_deprecated_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, 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_frame_args_address (gdbarch, cris_frame_args_address);
- set_gdbarch_frame_locals_address (gdbarch, cris_frame_locals_address);
- 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 / deliverable / binutils-gdb.git / blobdiff