#include "defs.h"
#include "frame.h"
+#include "frame-unwind.h"
+#include "frame-base.h"
+#include "trad-frame.h"
+#include "dwarf2-frame.h"
#include "symtab.h"
#include "inferior.h"
#include "gdbtypes.h"
};
/* Register numbers of various important registers.
- DEPRECATED_FP_REGNUM Contains address of executing stack frame.
+ CRIS_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. */
-/* DEPRECATED_FP_REGNUM = 8, SP_REGNUM = 14, and PC_REGNUM = 15 have
- been incorporated into the multi-arch framework. */
-
enum cris_regnums
{
/* Enums with respect to the general registers, valid for all
CRIS versions. */
+ CRIS_FP_REGNUM = 8,
STR_REGNUM = 9,
RET_REGNUM = 10,
ARG1_REGNUM = 10,
0
};
-/* CRIS ABI, set via the user command 'set cris-abi'.
- There are two flavours:
- 1. Original ABI with 32-bit doubles, where arguments <= 4 bytes are
- passed by value.
- 2. New ABI with 64-bit doubles, where arguments <= 8 bytes are passed by
- value. */
-static const char *usr_cmd_cris_abi;
-
-/* Indicates whether to trust the above variable. */
-static int usr_cmd_cris_abi_valid = 0;
-
-/* These variables are strings instead of enums to make them usable as
- parameters to add_set_enum_cmd. */
-static const char CRIS_ABI_ORIGINAL[] = "CRIS_ABI_ORIGINAL";
-static const char CRIS_ABI_V2[] = "CRIS_ABI_V2";
-static const char CRIS_ABI_SYMBOL[] = ".$CRIS_ABI_V2";
-static const char *cris_abi_enums[] =
-{
- CRIS_ABI_ORIGINAL,
- CRIS_ABI_V2,
- 0
-};
-
/* CRIS architecture specific information. */
struct gdbarch_tdep
{
int cris_version;
const char *cris_mode;
- const char *cris_abi;
};
/* Functions for accessing target dependent data. */
return (gdbarch_tdep (current_gdbarch)->cris_mode);
}
-struct frame_extra_info
+struct cris_unwind_cache
{
+ /* The previous frame's inner most stack address. Used as this
+ frame ID's stack_addr. */
+ CORE_ADDR prev_sp;
+ /* The frame's base, optionally used by the high-level debug info. */
+ CORE_ADDR base;
+ int size;
+ /* How far the SP and r8 (FP) have been offset from the start of
+ the stack frame (as defined by the previous frame's stack
+ pointer). */
+ LONGEST sp_offset;
+ LONGEST r8_offset;
+ int uses_frame;
+
+ /* From old frame_extra_info struct. */
CORE_ADDR return_pc;
int leaf_function;
+
+ /* Table indicating the location of each and every register. */
+ struct trad_frame_saved_reg *saved_regs;
};
/* The instruction environment needed to find single-step breakpoints. */
inst_env. */
static void cris_gdb_func (enum cris_op_type, unsigned short, inst_env_type *);
-static CORE_ADDR cris_skip_prologue_main (CORE_ADDR pc, int frameless_p);
-
static struct gdbarch *cris_gdbarch_init (struct gdbarch_info,
struct gdbarch_list *);
static void cris_mode_update (char *ignore_args, int from_tty,
struct cmd_list_element *c);
-static void cris_abi_update (char *ignore_args, int from_tty,
- struct cmd_list_element *c);
-
static CORE_ADDR bfd_lookup_symbol (bfd *, const char *);
+static CORE_ADDR cris_scan_prologue (CORE_ADDR pc,
+ struct frame_info *next_frame,
+ struct cris_unwind_cache *info);
+
+static CORE_ADDR cris_unwind_pc (struct gdbarch *gdbarch,
+ struct frame_info *next_frame);
+
+static CORE_ADDR cris_unwind_sp (struct gdbarch *gdbarch,
+ struct frame_info *next_frame);
+
+/* When arguments must be pushed onto the stack, they go on in reverse
+ order. The below implements a FILO (stack) to do this. */
+
+/* Borrowed from d10v-tdep.c. */
+
+struct stack_item
+{
+ int len;
+ struct stack_item *prev;
+ void *data;
+};
+
+static struct stack_item *
+push_stack_item (struct stack_item *prev, void *contents, int len)
+{
+ struct stack_item *si;
+ si = xmalloc (sizeof (struct stack_item));
+ si->data = xmalloc (len);
+ si->len = len;
+ si->prev = prev;
+ memcpy (si->data, contents, len);
+ return si;
+}
+
+static struct stack_item *
+pop_stack_item (struct stack_item *si)
+{
+ struct stack_item *dead = si;
+ si = si->prev;
+ xfree (dead->data);
+ xfree (dead);
+ return si;
+}
+
+/* Put here the code to store, into fi->saved_regs, the addresses of
+ the saved registers of frame described by FRAME_INFO. This
+ includes special registers such as pc and fp saved in special ways
+ in the stack frame. sp is even more special: the address we return
+ for it IS the sp for the next frame. */
+
+struct cris_unwind_cache *
+cris_frame_unwind_cache (struct frame_info *next_frame,
+ void **this_prologue_cache)
+{
+ CORE_ADDR pc;
+ struct cris_unwind_cache *info;
+ int i;
+
+ if ((*this_prologue_cache))
+ return (*this_prologue_cache);
+
+ info = FRAME_OBSTACK_ZALLOC (struct cris_unwind_cache);
+ (*this_prologue_cache) = info;
+ info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
+
+ /* Zero all fields. */
+ info->prev_sp = 0;
+ info->base = 0;
+ info->size = 0;
+ info->sp_offset = 0;
+ info->r8_offset = 0;
+ info->uses_frame = 0;
+ info->return_pc = 0;
+ info->leaf_function = 0;
+
+ /* Prologue analysis does the rest... */
+ cris_scan_prologue (frame_func_unwind (next_frame), next_frame, info);
+
+ return info;
+}
+
+/* Given a GDB frame, determine the address of the calling function's
+ frame. This will be used to create a new GDB frame struct. */
+
+static void
+cris_frame_this_id (struct frame_info *next_frame,
+ void **this_prologue_cache,
+ struct frame_id *this_id)
+{
+ struct cris_unwind_cache *info
+ = cris_frame_unwind_cache (next_frame, this_prologue_cache);
+ CORE_ADDR base;
+ CORE_ADDR func;
+ struct frame_id id;
+
+ /* The FUNC is easy. */
+ func = frame_func_unwind (next_frame);
+
+ /* Hopefully the prologue analysis either correctly determined the
+ frame's base (which is the SP from the previous frame), or set
+ that base to "NULL". */
+ base = info->prev_sp;
+ if (base == 0)
+ return;
+
+ id = frame_id_build (base, func);
+
+ (*this_id) = id;
+}
+
+static void
+cris_frame_prev_register (struct frame_info *next_frame,
+ void **this_prologue_cache,
+ int regnum, int *optimizedp,
+ enum lval_type *lvalp, CORE_ADDR *addrp,
+ int *realnump, void *bufferp)
+{
+ struct cris_unwind_cache *info
+ = cris_frame_unwind_cache (next_frame, this_prologue_cache);
+ trad_frame_prev_register (next_frame, info->saved_regs, regnum,
+ optimizedp, lvalp, addrp, realnump, bufferp);
+}
+
+/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
+ dummy frame. The frame ID's base needs to match the TOS value
+ saved by save_dummy_frame_tos(), and the PC match the dummy frame's
+ breakpoint. */
+
+static struct frame_id
+cris_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+ return frame_id_build (cris_unwind_sp (gdbarch, next_frame),
+ frame_pc_unwind (next_frame));
+}
+
+static CORE_ADDR
+cris_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
+{
+ /* Align to the size of an instruction (so that they can safely be
+ pushed onto the stack). */
+ return sp & ~3;
+}
+
+static CORE_ADDR
+cris_push_dummy_code (struct gdbarch *gdbarch,
+ CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
+ struct value **args, int nargs,
+ struct type *value_type,
+ CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
+{
+ /* Allocate space sufficient for a breakpoint. */
+ sp = (sp - 4) & ~3;
+ /* Store the address of that breakpoint */
+ *bp_addr = sp;
+ /* CRIS always starts the call at the callee's entry point. */
+ *real_pc = funaddr;
+ return sp;
+}
+
+static CORE_ADDR
+cris_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
+ struct regcache *regcache, CORE_ADDR bp_addr,
+ int nargs, struct value **args, CORE_ADDR sp,
+ int struct_return, CORE_ADDR struct_addr)
+{
+ int stack_alloc;
+ int stack_offset;
+ int argreg;
+ int argnum;
+
+ CORE_ADDR regval;
+
+ /* The function's arguments and memory allocated by gdb for the arguments to
+ point at reside in separate areas on the stack.
+ Both frame pointers grow toward higher addresses. */
+ CORE_ADDR fp_arg;
+ CORE_ADDR fp_mem;
+
+ struct stack_item *si = NULL;
+
+ /* Push the return address. */
+ regcache_cooked_write_unsigned (regcache, SRP_REGNUM, bp_addr);
+
+ /* Are we returning a value using a structure return or a normal value
+ return? struct_addr is the address of the reserved space for the return
+ structure to be written on the stack. */
+ if (struct_return)
+ {
+ regcache_cooked_write_unsigned (regcache, STR_REGNUM, struct_addr);
+ }
+
+ /* Now load as many as possible of the first arguments into registers,
+ and push the rest onto the stack. */
+ argreg = ARG1_REGNUM;
+ stack_offset = 0;
+
+ for (argnum = 0; argnum < nargs; argnum++)
+ {
+ int len;
+ char *val;
+ int reg_demand;
+ int i;
+
+ len = TYPE_LENGTH (VALUE_TYPE (args[argnum]));
+ val = (char *) VALUE_CONTENTS (args[argnum]);
+
+ /* How may registers worth of storage do we need for this argument? */
+ reg_demand = (len / 4) + (len % 4 != 0 ? 1 : 0);
+
+ if (len <= (2 * 4) && (argreg + reg_demand - 1 <= ARG4_REGNUM))
+ {
+ /* Data passed by value. Fits in available register(s). */
+ for (i = 0; i < reg_demand; i++)
+ {
+ regcache_cooked_write_unsigned (regcache, argreg,
+ *(unsigned long *) val);
+ argreg++;
+ val += 4;
+ }
+ }
+ else if (len <= (2 * 4) && argreg <= ARG4_REGNUM)
+ {
+ /* Data passed by value. Does not fit in available register(s).
+ Use the register(s) first, then the stack. */
+ for (i = 0; i < reg_demand; i++)
+ {
+ if (argreg <= ARG4_REGNUM)
+ {
+ regcache_cooked_write_unsigned (regcache, argreg,
+ *(unsigned long *) val);
+ argreg++;
+ val += 4;
+ }
+ else
+ {
+ /* Push item for later so that pushed arguments
+ come in the right order. */
+ si = push_stack_item (si, val, 4);
+ val += 4;
+ }
+ }
+ }
+ else if (len > (2 * 4))
+ {
+ /* FIXME */
+ internal_error (__FILE__, __LINE__, "We don't do this");
+ }
+ else
+ {
+ /* Data passed by value. No available registers. Put it on
+ the stack. */
+ si = push_stack_item (si, val, len);
+ }
+ }
+
+ while (si)
+ {
+ /* fp_arg must be word-aligned (i.e., don't += len) to match
+ the function prologue. */
+ sp = (sp - si->len) & ~3;
+ write_memory (sp, si->data, si->len);
+ si = pop_stack_item (si);
+ }
+
+ /* Finally, update the SP register. */
+ regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp);
+
+ return sp;
+}
+
+static const struct frame_unwind cris_frame_unwind = {
+ NORMAL_FRAME,
+ cris_frame_this_id,
+ cris_frame_prev_register
+};
+
+const struct frame_unwind *
+cris_frame_sniffer (struct frame_info *next_frame)
+{
+ return &cris_frame_unwind;
+}
+
+static CORE_ADDR
+cris_frame_base_address (struct frame_info *next_frame, void **this_cache)
+{
+ struct cris_unwind_cache *info
+ = cris_frame_unwind_cache (next_frame, this_cache);
+ return info->base;
+}
+
+static const struct frame_base cris_frame_base = {
+ &cris_frame_unwind,
+ cris_frame_base_address,
+ cris_frame_base_address,
+ cris_frame_base_address
+};
+
/* Frames information. The definition of the struct frame_info is
CORE_ADDR frame
determine that it is a prologue (1). */
static CORE_ADDR
-cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi,
- int frameless_p)
+cris_scan_prologue (CORE_ADDR pc, struct frame_info *next_frame,
+ struct cris_unwind_cache *info)
{
/* Present instruction. */
unsigned short insn;
/* move.d r<source_register>,rS */
short source_register;
- /* This frame is with respect to a leaf until a push srp is found. */
- get_frame_extra_info (fi)->leaf_function = 1;
+ /* Scan limit. */
+ int limit;
- /* This frame is without the FP until a push fp is found. */
- have_fp = 0;
+ /* This frame is with respect to a leaf until a push srp is found. */
+ if (info)
+ {
+ info->leaf_function = 1;
+ }
/* Assume nothing on stack. */
val = 0;
regsave = -1;
- /* No information about register contents so far. */
+ /* If we were called without a next_frame, that means we were called
+ from cris_skip_prologue which already tried to find the end of the
+ prologue through the symbol information. 64 instructions past current
+ pc is arbitrarily chosen, but at least it means we'll stop eventually. */
+ limit = next_frame ? frame_pc_unwind (next_frame) : pc + 64;
- /* 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 (deprecated_get_frame_saved_regs (fi))
- {
- for (regno = 0; regno < NUM_REGS; regno++)
- deprecated_get_frame_saved_regs (fi)[regno] = 0;
- }
-
/* Find the prologue instructions. */
- do
+ while (pc < limit)
{
- insn = read_memory_unsigned_integer (ip, sizeof (short));
- ip += sizeof (short);
+ insn = read_memory_unsigned_integer (pc, 2);
+ pc += 2;
if (insn == 0xE1FC)
{
/* push <reg> 32 bit instruction */
- insn_next = read_memory_unsigned_integer (ip, sizeof (short));
- ip += sizeof (short);
+ insn_next = read_memory_unsigned_integer (pc, 2);
+ pc += 2;
regno = cris_get_operand2 (insn_next);
-
+ if (info)
+ {
+ info->sp_offset += 4;
+ }
/* This check, meant to recognize srp, used to be regno ==
(SRP_REGNUM - NUM_GENREGS), but that covers r11 also. */
if (insn_next == 0xBE7E)
{
- if (frameless_p)
- {
- return ip;
- }
- get_frame_extra_info (fi)->leaf_function = 0;
- }
- else if (regno == DEPRECATED_FP_REGNUM)
- {
- have_fp = 1;
+ if (info)
+ {
+ info->leaf_function = 0;
+ }
}
}
else if (insn == 0x866E)
{
/* move.d sp,r8 */
- if (frameless_p)
- {
- return ip;
- }
+ if (info)
+ {
+ info->uses_frame = 1;
+ info->r8_offset = info->sp_offset;
+ }
continue;
}
else if (cris_get_operand2 (insn) == SP_REGNUM
&& cris_get_opcode (insn) == 0x000A)
{
/* subq <val>,sp */
- val = cris_get_quick_value (insn);
+ if (info)
+ {
+ info->sp_offset += cris_get_quick_value (insn);
+ }
}
else if (cris_get_mode (insn) == 0x0002
&& cris_get_opcode (insn) == 0x000F
&& cris_get_operand1 (insn) == SP_REGNUM)
{
/* movem r<regsave>,[sp] */
- if (frameless_p)
- {
- return ip;
- }
regsave = cris_get_operand2 (insn);
}
else if (cris_get_operand2 (insn) == SP_REGNUM
register. Used for CRIS v8 i.e. ETRAX 100 and newer if <val>
is between 64 and 128.
movem r<regsave>,[sp=sp-<val>] */
- val = -cris_get_signed_offset (insn);
- insn_next = read_memory_unsigned_integer (ip, sizeof (short));
- ip += sizeof (short);
+ if (info)
+ {
+ info->sp_offset += -cris_get_signed_offset (insn);
+ }
+ insn_next = read_memory_unsigned_integer (pc, 2);
+ pc += 2;
if (cris_get_mode (insn_next) == PREFIX_ASSIGN_MODE
&& cris_get_opcode (insn_next) == 0x000F
&& cris_get_size (insn_next) == 0x0003
&& cris_get_operand1 (insn_next) == SP_REGNUM)
{
- if (frameless_p)
- {
- return ip;
- }
regsave = cris_get_operand2 (insn_next);
}
else
{
/* The prologue ended before the limit was reached. */
- ip -= 2 * sizeof (short);
+ pc -= 4;
break;
}
}
&& cris_get_size (insn) == 0x0002)
{
/* move.d r<10..13>,r<0..15> */
- if (frameless_p)
- {
- return ip;
- }
source_register = cris_get_operand1 (insn);
/* FIXME? In the glibc solibs, the prologue might contain something
if (source_register < ARG1_REGNUM || source_register > ARG4_REGNUM)
{
/* The prologue ended before the limit was reached. */
- ip -= sizeof (short);
+ pc -= 2;
break;
}
}
- else if (cris_get_operand2 (insn) == DEPRECATED_FP_REGNUM
+ else if (cris_get_operand2 (insn) == CRIS_FP_REGNUM
/* The size is a fixed-size. */
&& ((insn & 0x0F00) >> 8) == 0x0001
/* A negative offset. */
&& (cris_get_signed_offset (insn) < 0))
{
/* move.S rZ,[r8-U] (?) */
- insn_next = read_memory_unsigned_integer (ip, sizeof (short));
- ip += sizeof (short);
+ insn_next = read_memory_unsigned_integer (pc, 2);
+ pc += 2;
regno = cris_get_operand2 (insn_next);
if ((regno >= 0 && regno < SP_REGNUM)
&& cris_get_mode (insn_next) == PREFIX_OFFSET_MODE
else
{
/* The prologue ended before the limit was reached. */
- ip -= 2 * sizeof (short);
+ pc -= 4;
break;
}
}
- else if (cris_get_operand2 (insn) == DEPRECATED_FP_REGNUM
+ else if (cris_get_operand2 (insn) == CRIS_FP_REGNUM
/* The size is a fixed-size. */
&& ((insn & 0x0F00) >> 8) == 0x0001
/* A positive offset. */
&& (cris_get_signed_offset (insn) > 0))
{
/* move.S [r8+U],rZ (?) */
- insn_next = read_memory_unsigned_integer (ip, sizeof (short));
- ip += sizeof (short);
+ insn_next = read_memory_unsigned_integer (pc, 2);
+ pc += 2;
regno = cris_get_operand2 (insn_next);
if ((regno >= 0 && regno < SP_REGNUM)
&& cris_get_mode (insn_next) == PREFIX_OFFSET_MODE
else
{
/* The prologue ended before the limit was reached. */
- ip -= 2 * sizeof (short);
+ pc -= 4;
break;
}
}
else
{
/* The prologue ended before the limit was reached. */
- ip -= sizeof (short);
+ pc -= 2;
break;
}
}
- while (ip < limit);
- /* We only want to know the end of the prologue when
- fi->saved_regs == 0. */
- if (!deprecated_get_frame_saved_regs (fi))
- return ip;
+ /* We only want to know the end of the prologue when next_frame and info
+ are NULL (called from cris_skip_prologue i.e.). */
+ if (next_frame == NULL && info == NULL)
+ {
+ return pc;
+ }
- if (have_fp)
+ info->size = info->sp_offset;
+
+ /* Compute the previous frame's stack pointer (which is also the
+ frame's ID's stack address), and this frame's base pointer. */
+ if (info->uses_frame)
{
- deprecated_get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] = get_frame_base (fi);
-
- /* Calculate the addresses. */
- for (regno = regsave; regno >= 0; regno--)
- {
- deprecated_get_frame_saved_regs (fi)[regno] = get_frame_base (fi) - val;
- val -= 4;
- }
- if (get_frame_extra_info (fi)->leaf_function)
- {
- /* Set the register SP to contain the stack pointer of
- the caller. */
- deprecated_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. */
- deprecated_get_frame_saved_regs (fi)[SP_REGNUM] = get_frame_base (fi) + 8;
+ ULONGEST this_base;
+ /* The SP was moved to the FP. This indicates that a new frame
+ was created. Get THIS frame's FP value by unwinding it from
+ the next frame. */
+ frame_unwind_unsigned_register (next_frame, CRIS_FP_REGNUM,
+ &this_base);
+ info->base = this_base;
+ /* The FP points at the last saved register. Adjust the FP back
+ to before the first saved register giving the SP. */
+ info->prev_sp = info->base + info->r8_offset;
+ }
+ else
+ {
+ ULONGEST this_base;
+ /* Assume that the FP is this frame's SP but with that pushed
+ stack space added back. */
+ frame_unwind_unsigned_register (next_frame, SP_REGNUM, &this_base);
+ info->base = this_base;
+ info->prev_sp = info->base + info->size;
+ }
- /* Set the register SRP to contain the return address of
- the caller. */
- deprecated_get_frame_saved_regs (fi)[SRP_REGNUM] = get_frame_base (fi) + 4;
- }
+ info->saved_regs[CRIS_FP_REGNUM].addr = info->base;
+
+ /* Calculate the addresses for the saved registers on the stack. */
+ /* FIXME: The address calculation should really be done on the fly while
+ we're analyzing the prologue (we only hold one regsave value as it is
+ now). */
+ val = info->sp_offset;
+
+ for (regno = regsave; regno >= 0; regno--)
+ {
+ info->saved_regs[regno].addr = info->base + info->r8_offset - val;
+ val -= 4;
+ }
+
+ /* The previous frame's SP needed to be computed. Save the computed
+ value. */
+ trad_frame_set_value (info->saved_regs, SP_REGNUM, info->prev_sp);
+
+ if (!info->leaf_function)
+ {
+ /* SRP saved on the stack. */
+ info->saved_regs[SRP_REGNUM].addr = info->base + 4;
}
- return ip;
+
+ /* The PC is found in SRP (the actual register or located on the stack). */
+ info->saved_regs[PC_REGNUM] = info->saved_regs[SRP_REGNUM];
+
+ return pc;
}
/* Advance pc beyond any function entry prologue instructions at pc
to reach some "real" code. */
-static CORE_ADDR
-cris_skip_prologue (CORE_ADDR pc)
-{
- return cris_skip_prologue_main (pc, 0);
-}
-
/* Given a PC value corresponding to the start of a function, return the PC
of the first instruction after the function prologue. */
static CORE_ADDR
-cris_skip_prologue_main (CORE_ADDR pc, int frameless_p)
+cris_skip_prologue (CORE_ADDR pc)
{
- 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 func_addr, func_end;
+ struct symtab_and_line sal;
CORE_ADDR pc_after_prologue;
- /* 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.
- Exaggerating the limit seems to be harmless. */
- if (sal.end > 0)
- best_limit = sal.end;
- else
- best_limit = pc + 100;
+ /* If we have line debugging information, then the end of the prologue
+ should the first assembly instruction of the first source line. */
+ if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
+ {
+ sal = find_pc_line (func_addr, 0);
+ if (sal.end > 0 && sal.end < func_end)
+ return sal.end;
+ }
- pc_after_prologue = cris_examine (pc, best_limit, fi, frameless_p);
- do_cleanups (old_chain);
+ pc_after_prologue = cris_scan_prologue (pc, NULL, NULL);
return pc_after_prologue;
}
+static CORE_ADDR
+cris_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+ ULONGEST pc;
+ frame_unwind_unsigned_register (next_frame, PC_REGNUM, &pc);
+ return pc;
+}
+
+static CORE_ADDR
+cris_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
+{
+ ULONGEST sp;
+ frame_unwind_unsigned_register (next_frame, SP_REGNUM, &sp);
+ return sp;
+}
+
/* Use the program counter to determine the contents and size of a breakpoint
instruction. It returns a pointer to a string of bytes that encode a
breakpoint instruction, stores the length of the string to *lenptr, and
return break_insn;
}
-/* Returns the register SRP (subroutine return pointer) which must contain
- the content of the register PC after a function call. */
-
-static CORE_ADDR
-cris_saved_pc_after_call (struct frame_info *frame)
-{
- return read_register (SRP_REGNUM);
-}
-
/* Returns 1 if spec_reg is applicable to the current gdbarch's CRIS version,
0 otherwise. */
/* R0 - R13, P8, P15 */
return builtin_type_unsigned_long;
}
- else if (regno > P3_REGNUM && regno < P8_REGNUM)
- {
- /* P4, CCR, DCR0, DCR1 */
- return builtin_type_unsigned_short;
- }
- else if (regno > PC_REGNUM && regno < P4_REGNUM)
- {
- /* P0, P1, P2, P3 */
- return builtin_type_unsigned_char;
- }
- else
- {
- /* Invalid register. */
- return builtin_type_void;
- }
-}
-
-/* Stores a function return value of type type, where valbuf is the address
- of the value to be stored. */
-
-/* In the original CRIS ABI, R10 is used to store return values. */
-
-static void
-cris_abi_original_store_return_value (struct type *type, char *valbuf)
-{
- int len = TYPE_LENGTH (type);
-
- if (len <= DEPRECATED_REGISTER_SIZE)
- deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (RET_REGNUM), valbuf, len);
- else
- internal_error (__FILE__, __LINE__, "cris_abi_original_store_return_value: type length too large.");
-}
-
-/* In the CRIS ABI V2, R10 and R11 are used to store return values. */
-
-static void
-cris_abi_v2_store_return_value (struct type *type, char *valbuf)
-{
- int len = TYPE_LENGTH (type);
-
- if (len <= 2 * DEPRECATED_REGISTER_SIZE)
- {
- /* Note that this works since R10 and R11 are consecutive registers. */
- deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (RET_REGNUM),
- valbuf, len);
- }
- else
- internal_error (__FILE__, __LINE__, "cris_abi_v2_store_return_value: type length too large.");
-}
-
-/* Return the name of register regno as a string. Return NULL for an invalid or
- unimplemented register. */
-
-static const char *
-cris_register_name (int regno)
-{
- static char *cris_genreg_names[] =
- { "r0", "r1", "r2", "r3", \
- "r4", "r5", "r6", "r7", \
- "r8", "r9", "r10", "r11", \
- "r12", "r13", "sp", "pc" };
-
- int i;
- int spec_regno;
-
- if (regno >= 0 && regno < NUM_GENREGS)
- {
- /* General register. */
- return cris_genreg_names[regno];
- }
- else if (regno >= NUM_GENREGS && regno < NUM_REGS)
- {
- /* Special register (R16 - R31). cris_spec_regs is zero-based.
- Adjust regno accordingly. */
- spec_regno = regno - NUM_GENREGS;
-
- /* The entries in cris_spec_regs are stored in register number order,
- which means we can shortcut into the array when searching it. */
- for (i = spec_regno; cris_spec_regs[i].name != NULL; i++)
- {
- if (cris_spec_regs[i].number == spec_regno
- && cris_spec_reg_applicable (cris_spec_regs[i]))
- /* Go with the first applicable register. */
- return cris_spec_regs[i].name;
- }
- /* Special register not applicable to this CRIS version. */
- return NULL;
- }
- else
- {
- /* Invalid register. */
- return NULL;
- }
-}
-
-static int
-cris_register_bytes_ok (long bytes)
-{
- return (bytes == DEPRECATED_REGISTER_BYTES);
-}
-
-/* Extract from an array regbuf containing the raw register state a function
- return value of type type, and copy that, in virtual format, into
- valbuf. */
-
-/* In the original CRIS ABI, R10 is used to return values. */
-
-static void
-cris_abi_original_extract_return_value (struct type *type, char *regbuf,
- char *valbuf)
-{
- int len = TYPE_LENGTH (type);
-
- if (len <= DEPRECATED_REGISTER_SIZE)
- memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (RET_REGNUM), len);
- else
- internal_error (__FILE__, __LINE__, "cris_abi_original_extract_return_value: type length too large");
-}
-
-/* In the CRIS ABI V2, R10 and R11 are used to store return values. */
-
-static void
-cris_abi_v2_extract_return_value (struct type *type, char *regbuf,
- char *valbuf)
-{
- int len = TYPE_LENGTH (type);
-
- if (len <= 2 * DEPRECATED_REGISTER_SIZE)
- memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (RET_REGNUM), len);
- else
- internal_error (__FILE__, __LINE__, "cris_abi_v2_extract_return_value: type length too large");
-}
-
-/* Store the address of the place in which to copy the structure the
- subroutine will return. In the CRIS ABI, R9 is used in order to
- pass the address of the allocated area where a structure return
- value must be stored. */
-
-static void
-cris_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
-{
- write_register (STR_REGNUM, addr);
-}
-
-/* Returns 1 if the given type will be passed by pointer rather than
- directly. */
-
-/* In the original CRIS ABI, arguments shorter than or equal to 32 bits are
- passed by value. */
-
-static int
-cris_abi_original_reg_struct_has_addr (int gcc_p, struct type *type)
-{
- return (TYPE_LENGTH (type) > 4);
-}
-
-/* In the CRIS ABI V2, arguments shorter than or equal to 64 bits are passed
- by value. */
-
-static int
-cris_abi_v2_reg_struct_has_addr (int gcc_p, struct type *type)
-{
- return (TYPE_LENGTH (type) > 8);
-}
-
-/* Returns 1 if the function invocation represented by fi does not have a
- stack frame associated with it. Otherwise return 0. */
-
-static int
-cris_frameless_function_invocation (struct frame_info *fi)
-{
- if ((get_frame_type (fi) == SIGTRAMP_FRAME))
- return 0;
- else
- return legacy_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
- DEPRECATED_FRAME_INIT_SAVED_REGS using frame_saved_regs_zalloc. */
-
-static 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),
- get_frame_base (fi));
-
- /* Examine the entire prologue. */
- int frameless_p = 0;
-
- /* Has this frame's registers already been initialized? */
- if (deprecated_get_frame_saved_regs (fi))
- return;
-
- frame_saved_regs_zalloc (fi);
-
- if (dummy_regs)
- {
- /* 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 (deprecated_get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS);
- }
- else
- {
- 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
- examining only the first instruction in the function prologue.
- Exaggerating the limit seems to be harmless. */
- if (sal.end > 0)
- best_limit = sal.end;
- else
- best_limit = ip + 100;
-
- cris_examine (ip, best_limit, fi, frameless_p);
- }
-}
-
-/* Initialises the extra frame information at the creation of a new frame.
- The inparameter fromleaf is 0 when the call is from create_new_frame.
- When the call is from get_prev_frame_info, fromleaf is determined by
- cris_frameless_function_invocation. */
-
-static void
-cris_init_extra_frame_info (int fromleaf, struct frame_info *fi)
-{
- if (get_next_frame (fi))
- {
- /* Called from get_prev_frame. */
- deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
- }
-
- frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
-
- 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),
- get_frame_base (fi),
- get_frame_base (fi)))
- {
- /* 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? */
- get_frame_extra_info (fi)->leaf_function = 0;
- }
- else
- {
- cris_frame_init_saved_regs (fi);
-
- /* Check fromleaf/frameless_function_invocation. (FIXME) */
-
- if (deprecated_get_frame_saved_regs (fi)[SRP_REGNUM] != 0)
- {
- /* SRP was saved on the stack; non-leaf function. */
- get_frame_extra_info (fi)->return_pc =
- read_memory_integer (deprecated_get_frame_saved_regs (fi)[SRP_REGNUM],
- DEPRECATED_REGISTER_RAW_SIZE (SRP_REGNUM));
- }
- else
- {
- /* SRP is still in a register; leaf function. */
- get_frame_extra_info (fi)->return_pc = read_register (SRP_REGNUM);
- /* FIXME: Should leaf_function be set to 1 here? */
- get_frame_extra_info (fi)->leaf_function = 1;
- }
- }
-}
-
-/* Return the content of the frame pointer in the present frame. In other
- words, determine the address of the calling function's frame. */
-
-static CORE_ADDR
-cris_frame_chain (struct frame_info *fi)
-{
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi),
- get_frame_base (fi),
- get_frame_base (fi)))
+ else if (regno > P3_REGNUM && regno < P8_REGNUM)
{
- return get_frame_base (fi);
+ /* P4, CCR, DCR0, DCR1 */
+ return builtin_type_unsigned_short;
}
- else if (!deprecated_inside_entry_file (get_frame_pc (fi)))
+ else if (regno > PC_REGNUM && regno < P4_REGNUM)
{
- return read_memory_unsigned_integer (get_frame_base (fi), 4);
+ /* P0, P1, P2, P3 */
+ return builtin_type_unsigned_char;
}
else
{
- return 0;
+ /* Invalid register. */
+ return builtin_type_void;
}
}
-/* Return the saved PC (which equals the return address) of this frame. */
-
-static CORE_ADDR
-cris_frame_saved_pc (struct frame_info *fi)
-{
- return get_frame_extra_info (fi)->return_pc;
-}
+/* Stores a function return value of type type, where valbuf is the address
+ of the value to be stored. */
-/* Setup the function arguments for calling a function in the inferior. */
+/* In the CRIS ABI, R10 and R11 are used to store return values. */
-static CORE_ADDR
-cris_abi_original_push_arguments (int nargs, struct value **args,
- CORE_ADDR sp, int struct_return,
- CORE_ADDR struct_addr)
+static void
+cris_store_return_value (struct type *type, struct regcache *regcache,
+ const void *valbuf)
{
- int stack_alloc;
- int stack_offset;
- int argreg;
- int argnum;
- struct type *type;
- int len;
- CORE_ADDR regval;
- char *val;
-
- /* Data and parameters reside in different areas on the stack.
- Both frame pointers grow toward higher addresses. */
- CORE_ADDR fp_params;
- CORE_ADDR fp_data;
+ ULONGEST val;
+ int len = TYPE_LENGTH (type);
- /* Are we returning a value using a structure return or a normal value
- return? struct_addr is the address of the reserved space for the return
- structure to be written on the stack. */
- if (struct_return)
+ if (len <= 4)
{
- write_register (STR_REGNUM, struct_addr);
+ /* Put the return value in R10. */
+ val = extract_unsigned_integer (valbuf, len);
+ regcache_cooked_write_unsigned (regcache, ARG1_REGNUM, val);
}
-
- /* 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])) + 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 * DEPRECATED_REGISTER_SIZE);
-
- /* Now load as many as possible of the first arguments into
- registers, and push the rest onto the stack. */
- argreg = ARG1_REGNUM;
- stack_offset = 0;
-
- for (argnum = 0; argnum < nargs; argnum++)
+ else if (len <= 8)
{
- type = VALUE_TYPE (args[argnum]);
- len = TYPE_LENGTH (type);
- val = (char *) VALUE_CONTENTS (args[argnum]);
-
- 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 > 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. */
- write_memory (fp_data, val, len);
- write_register (argreg, fp_data);
- fp_data += len;
- argreg++;
- }
- 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), DEPRECATED_REGISTER_SIZE);
- fp_data += len;
- 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, DEPRECATED_REGISTER_SIZE);
- fp_params += DEPRECATED_REGISTER_SIZE;
- }
+ /* Put the return value in R10 and R11. */
+ val = extract_unsigned_integer (valbuf, 4);
+ regcache_cooked_write_unsigned (regcache, ARG1_REGNUM, val);
+ val = extract_unsigned_integer ((char *)valbuf + 4, len - 4);
+ regcache_cooked_write_unsigned (regcache, ARG2_REGNUM, val);
}
-
- return sp;
+ else
+ error ("cris_store_return_value: type length too large.");
}
-static CORE_ADDR
-cris_abi_v2_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
- int struct_return, CORE_ADDR struct_addr)
-{
- int stack_alloc;
- int stack_offset;
- int argreg;
- int argnum;
+/* Return the name of register regno as a string. Return NULL for an invalid or
+ unimplemented register. */
- CORE_ADDR regval;
+static const char *
+cris_register_name (int regno)
+{
+ static char *cris_genreg_names[] =
+ { "r0", "r1", "r2", "r3", \
+ "r4", "r5", "r6", "r7", \
+ "r8", "r9", "r10", "r11", \
+ "r12", "r13", "sp", "pc" };
- /* The function's arguments and memory allocated by gdb for the arguments to
- point at reside in separate areas on the stack.
- Both frame pointers grow toward higher addresses. */
- CORE_ADDR fp_arg;
- CORE_ADDR fp_mem;
-
- /* Are we returning a value using a structure return or a normal value
- return? struct_addr is the address of the reserved space for the return
- structure to be written on the stack. */
- if (struct_return)
- {
- write_register (STR_REGNUM, struct_addr);
- }
+ int i;
+ int spec_regno;
- /* Allocate enough to keep things word-aligned on both parts of the
- stack. */
- stack_alloc = 0;
- for (argnum = 0; argnum < nargs; argnum++)
+ if (regno >= 0 && regno < NUM_GENREGS)
{
- int len;
- int reg_demand;
-
- len = TYPE_LENGTH (VALUE_TYPE (args[argnum]));
- reg_demand = (len / DEPRECATED_REGISTER_SIZE) + (len % DEPRECATED_REGISTER_SIZE != 0 ? 1 : 0);
-
- /* 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 * DEPRECATED_REGISTER_SIZE + 2 * DEPRECATED_REGISTER_SIZE);
+ /* General register. */
+ return cris_genreg_names[regno];
}
- 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 * DEPRECATED_REGISTER_SIZE));
-
- /* Now load as many as possible of the first arguments into registers,
- and push the rest onto the stack. */
- argreg = ARG1_REGNUM;
- stack_offset = 0;
-
- for (argnum = 0; argnum < nargs; argnum++)
+ else if (regno >= NUM_GENREGS && regno < NUM_REGS)
{
- int len;
- char *val;
- int reg_demand;
- int i;
-
- len = TYPE_LENGTH (VALUE_TYPE (args[argnum]));
- val = (char *) VALUE_CONTENTS (args[argnum]);
+ /* Special register (R16 - R31). cris_spec_regs is zero-based.
+ Adjust regno accordingly. */
+ spec_regno = regno - NUM_GENREGS;
- /* How may registers worth of storage do we need for this argument? */
- reg_demand = (len / DEPRECATED_REGISTER_SIZE) + (len % DEPRECATED_REGISTER_SIZE != 0 ? 1 : 0);
-
- if (len <= (2 * DEPRECATED_REGISTER_SIZE)
- && (argreg + reg_demand - 1 <= ARG4_REGNUM))
- {
- /* Data passed by value. Fits in available register(s). */
- for (i = 0; i < reg_demand; i++)
- {
- write_register (argreg, *(unsigned long *) val);
- argreg++;
- val += DEPRECATED_REGISTER_SIZE;
- }
- }
- 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. */
- for (i = 0; i < reg_demand; i++)
- {
- if (argreg <= ARG4_REGNUM)
- {
- write_register (argreg, *(unsigned long *) val);
- argreg++;
- val += DEPRECATED_REGISTER_SIZE;
- }
- else
- {
- /* 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 * 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), 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 * DEPRECATED_REGISTER_SIZE;
- fp_arg += DEPRECATED_REGISTER_SIZE;
- }
- else
+ /* The entries in cris_spec_regs are stored in register number order,
+ which means we can shortcut into the array when searching it. */
+ for (i = spec_regno; cris_spec_regs[i].name != NULL; i++)
{
- /* Data passed by value. No available registers. Put it on
- the stack. */
- write_memory (fp_arg, val, len);
-
- /* fp_arg must be word-aligned (i.e., don't += len) to match
- the function prologue. */
- fp_arg += reg_demand * DEPRECATED_REGISTER_SIZE;
+ if (cris_spec_regs[i].number == spec_regno
+ && cris_spec_reg_applicable (cris_spec_regs[i]))
+ /* Go with the first applicable register. */
+ return cris_spec_regs[i].name;
}
+ /* Special register not applicable to this CRIS version. */
+ return NULL;
+ }
+ else
+ {
+ /* Invalid register. */
+ return NULL;
}
-
- return sp;
}
-/* Never put the return address on the stack. The register SRP is pushed
- by the called function unless it is a leaf-function. Due to the BRP
- register the PC will change when continue is sent. */
-
-static CORE_ADDR
-cris_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
+static int
+cris_register_bytes_ok (long bytes)
{
- write_register (SRP_REGNUM, entry_point_address ());
- return sp;
+ return (bytes == DEPRECATED_REGISTER_BYTES);
}
-/* Restore the machine to the state it had before the current frame
- was created. Discard the innermost frame from the stack and restore
- all saved registers. */
+/* Extract from an array regbuf containing the raw register state a function
+ return value of type type, and copy that, in virtual format, into
+ valbuf. */
+
+/* In the CRIS ABI, R10 and R11 are used to store return values. */
-static void
-cris_pop_frame (void)
+static void
+cris_extract_return_value (struct type *type, struct regcache *regcache,
+ void *valbuf)
{
- struct frame_info *fi = get_current_frame ();
- int regno;
- int stack_offset = 0;
+ ULONGEST val;
+ int len = TYPE_LENGTH (type);
- if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi),
- get_frame_base (fi),
- get_frame_base (fi)))
+ if (len <= 4)
{
- /* This happens when we hit a breakpoint set at the entry point,
- when returning from a dummy frame. */
- generic_pop_dummy_frame ();
+ /* Get the return value from R10. */
+ regcache_cooked_read_unsigned (regcache, ARG1_REGNUM, &val);
+ store_unsigned_integer (valbuf, len, val);
}
- else
+ else if (len <= 8)
{
- cris_frame_init_saved_regs (fi);
-
- /* For each register, the address of where it was saved on entry to
- the frame now lies in fi->saved_regs[regno], or zero if it was not
- saved. This includes special registers such as PC and FP saved in
- special ways in the stack frame. The SP_REGNUM is even more
- special, the address here is the SP for the next frame, not the
- address where the SP was saved. */
-
- /* Restore general registers R0 - R7. They were pushed on the stack
- after SP was saved. */
- for (regno = 0; regno < DEPRECATED_FP_REGNUM; regno++)
- {
- if (deprecated_get_frame_saved_regs (fi)[regno])
- {
- write_register (regno,
- read_memory_integer (deprecated_get_frame_saved_regs (fi)[regno], 4));
- }
- }
-
- if (deprecated_get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM])
- {
- /* Pop the frame pointer (R8). It was pushed before SP
- was saved. */
- write_register (DEPRECATED_FP_REGNUM,
- read_memory_integer (deprecated_get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM], 4));
- stack_offset += 4;
-
- /* Not a leaf function. */
- if (deprecated_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, deprecated_get_frame_saved_regs (fi)[DEPRECATED_FP_REGNUM] + stack_offset);
- }
- else
- {
- /* Currently, we can't get the correct info into fi->saved_regs
- without a frame pointer. */
- }
-
- /* Restore the PC. */
- write_register (PC_REGNUM, get_frame_extra_info (fi)->return_pc);
+ /* Get the return value from R10 and R11. */
+ regcache_cooked_read_unsigned (regcache, ARG1_REGNUM, &val);
+ store_unsigned_integer (valbuf, 4, val);
+ regcache_cooked_read_unsigned (regcache, ARG2_REGNUM, &val);
+ store_unsigned_integer ((char *)valbuf + 4, len - 4, val);
}
- flush_cached_frames ();
+ else
+ error ("cris_extract_return_value: type length too large");
+}
+
+/* Returns 1 if the given type will be passed by pointer rather than
+ directly. */
+
+/* In the CRIS ABI, arguments shorter than or equal to 64 bits are passed
+ by value. */
+
+static int
+cris_reg_struct_has_addr (int gcc_p, struct type *type)
+{
+ return (TYPE_LENGTH (type) > 8);
}
/* Calculates a value that measures how good inst_args constraints an
set_cmd_sfunc (c, cris_mode_update);
add_show_from_set (c, &showlist);
- c = add_set_enum_cmd ("cris-abi", class_support, cris_abi_enums,
- &usr_cmd_cris_abi,
- "Set the current CRIS ABI version.", &setlist);
- set_cmd_sfunc (c, cris_abi_update);
- add_show_from_set (c, &showlist);
-
c = add_cmd ("cris-fpless-backtrace", class_support, cris_fpless_backtrace,
"Display call chain using the subroutine return pointer.\n"
"Note that this displays the address after the jump to the "
tdep->cris_version);
fprintf_unfiltered (file, "cris_dump_tdep: tdep->cris_mode = %s\n",
tdep->cris_mode);
- fprintf_unfiltered (file, "cris_dump_tdep: tdep->cris_abi = %s\n",
- tdep->cris_abi);
-
}
}
}
}
-static void
-cris_abi_update (char *ignore_args, int from_tty,
- struct cmd_list_element *c)
-{
- struct gdbarch_info info;
-
- /* NOTE: cagney/2002-03-17: The add_show_from_set() function clones
- the set command passed as a parameter. The clone operation will
- include (BUG?) any ``set'' command callback, if present.
- Commands like ``info set'' call all the ``show'' command
- callbacks. Unfortunately, for ``show'' commands cloned from
- ``set'', this includes callbacks belonging to ``set'' commands.
- Making this worse, this only occures if add_show_from_set() is
- called after add_cmd_sfunc() (BUG?). */
-
- /* From here on, trust the user's CRIS ABI setting. */
- if (cmd_type (c) == set_cmd)
- {
- usr_cmd_cris_abi_valid = 1;
-
- /* Update the current architecture, if needed. */
- gdbarch_info_init (&info);
- if (!gdbarch_update_p (info))
- internal_error (__FILE__, __LINE__, "cris_gdbarch_update: failed to update architecture.");
- }
-}
-
/* Copied from pa64solib.c, with a couple of minor changes. */
static CORE_ADDR
struct gdbarch_tdep *tdep;
int cris_version;
const char *cris_mode;
- const char *cris_abi;
- CORE_ADDR cris_abi_sym = 0;
int register_bytes;
if (usr_cmd_cris_version_valid)
cris_mode = CRIS_MODE_SUPERVISOR;
}
- if (usr_cmd_cris_abi_valid)
- {
- /* Trust the user's ABI setting. */
- cris_abi = usr_cmd_cris_abi;
- }
- else if (info.abfd)
- {
- if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
- {
- /* An elf target uses the new ABI. */
- cris_abi = CRIS_ABI_V2;
- }
- else if (bfd_get_flavour (info.abfd) == bfd_target_aout_flavour)
- {
- /* An a.out target may use either ABI. Look for hints in the
- symbol table. */
- cris_abi_sym = bfd_lookup_symbol (info.abfd, CRIS_ABI_SYMBOL);
- cris_abi = cris_abi_sym ? CRIS_ABI_V2 : CRIS_ABI_ORIGINAL;
- }
- else
- {
- /* Unknown bfd flavour. Assume it's the new ABI. */
- cris_abi = CRIS_ABI_V2;
- }
- }
- else if (arches != NULL)
- {
- /* No bfd available. Stick with the ABI from the most recently
- selected architecture of this same family (the head of arches
- always points to this). (This is to avoid changing the ABI
- when the user updates the architecture with the 'set
- cris-version' command.) */
- cris_abi = gdbarch_tdep (arches->gdbarch)->cris_abi;
- }
- else
- {
- /* No bfd, and no previously selected architecture available.
- Assume it's the new ABI. */
- cris_abi = CRIS_ABI_V2;
- }
-
/* Make the current settings visible to the user. */
usr_cmd_cris_version = cris_version;
usr_cmd_cris_mode = cris_mode;
- usr_cmd_cris_abi = cris_abi;
/* Find a candidate among the list of pre-declared architectures. Both
CRIS version and ABI must match. */
arches = gdbarch_list_lookup_by_info (arches->next, &info))
{
if ((gdbarch_tdep (arches->gdbarch)->cris_version == cris_version)
- && (gdbarch_tdep (arches->gdbarch)->cris_mode == cris_mode)
- && (gdbarch_tdep (arches->gdbarch)->cris_abi == cris_abi))
+ && (gdbarch_tdep (arches->gdbarch)->cris_mode == cris_mode))
return arches->gdbarch;
}
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, deprecated_init_frame_pc_default);
-
tdep->cris_version = cris_version;
tdep->cris_mode = cris_mode;
- tdep->cris_abi = cris_abi;
/* INIT shall ensure that the INFO.BYTE_ORDER is non-zero. */
switch (info.byte_order)
internal_error (__FILE__, __LINE__, "cris_gdbarch_init: unknown byte order in info");
}
- /* Initialize the ABI dependent things. */
- if (tdep->cris_abi == CRIS_ABI_ORIGINAL)
- {
- set_gdbarch_double_bit (gdbarch, 32);
- 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);
- set_gdbarch_deprecated_reg_struct_has_addr
- (gdbarch, cris_abi_original_reg_struct_has_addr);
- }
- else if (tdep->cris_abi == CRIS_ABI_V2)
- {
- set_gdbarch_double_bit (gdbarch, 64);
- 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_deprecated_reg_struct_has_addr
- (gdbarch, cris_abi_v2_reg_struct_has_addr);
- }
- else
- internal_error (__FILE__, __LINE__, "cris_gdbarch_init: unknown CRIS ABI");
+ /* FIXME: Should be replaced by a cris_return_value implementation. */
+ set_gdbarch_store_return_value (gdbarch, cris_store_return_value);
+ set_gdbarch_extract_return_value (gdbarch, cris_extract_return_value);
+ set_gdbarch_deprecated_reg_struct_has_addr (gdbarch,
+ cris_reg_struct_has_addr);
+ set_gdbarch_use_struct_convention (gdbarch, always_use_struct_convention);
- /* The default definition of a long double is 2 * TARGET_DOUBLE_BIT,
- which means we have to set this explicitly. */
- set_gdbarch_long_double_bit (gdbarch, 64);
-
/* 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_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. DEPRECATED_REGISTER_RAW_SIZE is the real way to know how
big a register is. */
set_gdbarch_deprecated_register_size (gdbarch, 4);
-
- /* NEW */
+ set_gdbarch_double_bit (gdbarch, 64);
+ /* The default definition of a long double is 2 * TARGET_DOUBLE_BIT,
+ which means we have to set this explicitly. */
+ set_gdbarch_long_double_bit (gdbarch, 64);
set_gdbarch_register_bytes_ok (gdbarch, cris_register_bytes_ok);
- set_gdbarch_software_single_step (gdbarch, cris_software_single_step);
-
-
set_gdbarch_cannot_store_register (gdbarch, cris_cannot_store_register);
set_gdbarch_cannot_fetch_register (gdbarch, cris_cannot_fetch_register);
-
/* The total amount of space needed to store (in an array called registers)
GDB's copy of the machine's register state. Note: We can not use
cris_register_size at this point, since it relies on current_gdbarch
set_gdbarch_deprecated_register_virtual_type (gdbarch, cris_register_virtual_type);
- /* Use generic dummy frames. */
-
- /* Read all about dummy frames in blockframe.c. */
- 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_deprecated_call_dummy_words (gdbarch, 0);
- set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
-
- set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
-
- set_gdbarch_deprecated_push_return_address (gdbarch, cris_push_return_address);
- set_gdbarch_deprecated_pop_frame (gdbarch, cris_pop_frame);
-
- set_gdbarch_deprecated_store_struct_return (gdbarch, cris_store_struct_return);
- set_gdbarch_use_struct_convention (gdbarch, always_use_struct_convention);
+ /* Dummy frame functions. */
+ set_gdbarch_push_dummy_code (gdbarch, cris_push_dummy_code);
+ set_gdbarch_push_dummy_call (gdbarch, cris_push_dummy_call);
+ set_gdbarch_frame_align (gdbarch, cris_frame_align);
- 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_software_single_step (gdbarch, cris_software_single_step);
set_gdbarch_skip_prologue (gdbarch, cris_skip_prologue);
/* The stack grows downward. */
set_gdbarch_breakpoint_from_pc (gdbarch, cris_breakpoint_from_pc);
- set_gdbarch_deprecated_frameless_function_invocation (gdbarch, cris_frameless_function_invocation);
- set_gdbarch_deprecated_frame_chain (gdbarch, cris_frame_chain);
-
- set_gdbarch_deprecated_frame_saved_pc (gdbarch, cris_frame_saved_pc);
- set_gdbarch_deprecated_saved_pc_after_call (gdbarch, cris_saved_pc_after_call);
-
- /* Helpful for backtracing and returning in a call dummy. */
- set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
-
- /* Should be using push_dummy_call. */
- set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
+ /* Prologue analyzer may have to be able to parse an incomplete
+ prologue (PC in prologue, that is). Check infrun.c. */
+ set_gdbarch_unwind_pc (gdbarch, cris_unwind_pc);
+ set_gdbarch_unwind_sp (gdbarch, cris_unwind_sp);
+ set_gdbarch_unwind_dummy_id (gdbarch, cris_unwind_dummy_id);
+
+ /* FIXME: Hook in the DWARF CFI frame unwinder.
+ frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
+ */
+ frame_unwind_append_sniffer (gdbarch, cris_frame_sniffer);
+ frame_base_set_default (gdbarch, &cris_frame_base);
/* Use target_specific function to define link map offsets. */
set_solib_svr4_fetch_link_map_offsets
projects / binutils-gdb.git / commitdiff