From 2e4b588910bf6c89c55a2f833c6cbdeb5f6926d0 Mon Sep 17 00:00:00 2001 From: Orjan Friberg Date: Fri, 27 Feb 2004 12:39:26 +0000 Subject: [PATCH] 2004-02-26 Orjan Friberg * cris-tdep.c (frame_unwind.h, frame-base.h, trad-frame.h) (dwarf2-frame.h): Include. (enum cris_regnums): New enum CRIS_FP_REGNUM. Remove static variables related to ABI setting. (struct gdbarch_tdep): Remove cris_abi member. (struct frame_extra_info): Remove. (cris_unwind_cache, stack_item): New structs. (cris_frame_unwind, cris_frame_base): New variables. (push_stack_item, pop_stack_item) (cris_frame_unwind_cache, cris_frame_this_id) (cris_frame_prev_register, cris_unwind_dummy_id, cris_frame_align) (cris_push_dummy_code, cris_push_dummy_call, cris_frame_sniffer) (cris_frame_base_address, cris_scan_prologue, cris_unwind_pc) (cris_unwind_sp, cris_store_return_value, cris_extract_return_value) (cris_reg_struct_has_addr): New functions. (cris_examine, cris_frame_init_saved_regs, cris_frame_chain) (cris_frame_saved_pc, cris_saved_pc_after_call, (cris_store_struct_return, cris_frameless_function_invocation) (cris_pop_frame, cris_skip_prologue_main) (cris_abi_original_store_return_value) (cris_abi_v2_store_return_value) (cris_abi_original_extract_return_value) (cris_abi_v2_extract_return_value) (cris_abi_original_reg_struct_has_addr) (cris_abi_v2_reg_struct_has_addr) (cris_abi_original_push_arguments, cris_abi_v2_push_arguments) (cris_push_return_address, cris_abi_update): Remove. (_initialize_cris_tdep): Remove ABI command. (cris_dump_tdep): Ditto. (cris_gdbarch_init): Remove ABI command. Set store_return_value, extract_return_value, push_dummy_code, push_dummy_call, frame_align, unwind_pc, unwind_sp, unwind_dummy_id, frame_unwind_append_sniffer, frame_base_set_default. Clear deprecated init_frame_pc, push_arguments, store_return_value, extract_return_value, fp_regnum, pc_in_call_dummy, call_dummy_words, sizeof_call_dummy_words, get_saved_register, push_return_address, pop_frame, store_struct_return, frame_init_saved_regs, init_extra_frame_info, frameless_function_invocation, frame_chain, frame_saved_pc, saved_pc_after_call, save_dummy_frame_tos, dummy_write_sp. --- gdb/ChangeLog | 43 ++ gdb/cris-tdep.c | 1461 ++++++++++++++++++++++--------------------------------- 2 files changed, 628 insertions(+), 876 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 9c4a0ae..7813857 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,46 @@ +2004-02-26 Orjan Friberg + + * cris-tdep.c (frame_unwind.h, frame-base.h, trad-frame.h) + (dwarf2-frame.h): Include. + (enum cris_regnums): New enum CRIS_FP_REGNUM. + Remove static variables related to ABI setting. + (struct gdbarch_tdep): Remove cris_abi member. + (struct frame_extra_info): Remove. + (cris_unwind_cache, stack_item): New structs. + (cris_frame_unwind, cris_frame_base): New variables. + (push_stack_item, pop_stack_item) + (cris_frame_unwind_cache, cris_frame_this_id) + (cris_frame_prev_register, cris_unwind_dummy_id, cris_frame_align) + (cris_push_dummy_code, cris_push_dummy_call, cris_frame_sniffer) + (cris_frame_base_address, cris_scan_prologue, cris_unwind_pc) + (cris_unwind_sp, cris_store_return_value, cris_extract_return_value) + (cris_reg_struct_has_addr): New functions. + (cris_examine, cris_frame_init_saved_regs, cris_frame_chain) + (cris_frame_saved_pc, cris_saved_pc_after_call, + (cris_store_struct_return, cris_frameless_function_invocation) + (cris_pop_frame, cris_skip_prologue_main) + (cris_abi_original_store_return_value) + (cris_abi_v2_store_return_value) + (cris_abi_original_extract_return_value) + (cris_abi_v2_extract_return_value) + (cris_abi_original_reg_struct_has_addr) + (cris_abi_v2_reg_struct_has_addr) + (cris_abi_original_push_arguments, cris_abi_v2_push_arguments) + (cris_push_return_address, cris_abi_update): Remove. + (_initialize_cris_tdep): Remove ABI command. + (cris_dump_tdep): Ditto. + (cris_gdbarch_init): Remove ABI command. + Set store_return_value, extract_return_value, push_dummy_code, + push_dummy_call, frame_align, unwind_pc, unwind_sp, unwind_dummy_id, + frame_unwind_append_sniffer, frame_base_set_default. + Clear deprecated init_frame_pc, push_arguments, store_return_value, + extract_return_value, fp_regnum, pc_in_call_dummy, call_dummy_words, + sizeof_call_dummy_words, get_saved_register, push_return_address, + pop_frame, store_struct_return, frame_init_saved_regs, + init_extra_frame_info, frameless_function_invocation, frame_chain, + frame_saved_pc, saved_pc_after_call, save_dummy_frame_tos, + dummy_write_sp. + 2004-02-26 Jeff Johnston * valprint.h (print_hex_chars, print_char_chars): New prototypes. diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c index 7558f2d..14bac09 100644 --- a/gdb/cris-tdep.c +++ b/gdb/cris-tdep.c @@ -23,6 +23,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #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" @@ -57,7 +61,7 @@ enum cris_num_regs }; /* 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. @@ -69,13 +73,11 @@ enum cris_num_regs 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, @@ -127,35 +129,11 @@ static const char *cris_mode_enums[] = 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. */ @@ -172,10 +150,27 @@ cris_mode (void) 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. */ @@ -345,8 +340,6 @@ cris_get_signed_offset (unsigned short insn) 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 *); @@ -358,11 +351,305 @@ static void cris_version_update (char *ignore_args, int from_tty, 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 @@ -440,8 +727,8 @@ static CORE_ADDR bfd_lookup_symbol (bfd *, const char *); 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; @@ -462,60 +749,58 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi, /* move.d r,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 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 @@ -523,7 +808,10 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi, && cris_get_opcode (insn) == 0x000A) { /* subq ,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 @@ -531,10 +819,6 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi, && cris_get_operand1 (insn) == SP_REGNUM) { /* movem r,[sp] */ - if (frameless_p) - { - return ip; - } regsave = cris_get_operand2 (insn); } else if (cris_get_operand2 (insn) == SP_REGNUM @@ -545,24 +829,23 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi, register. Used for CRIS v8 i.e. ETRAX 100 and newer if is between 64 and 128. movem r,[sp=sp-] */ - 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; } } @@ -571,10 +854,6 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi, && 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 @@ -587,19 +866,19 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi, 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 @@ -611,19 +890,19 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi, 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 @@ -636,92 +915,124 @@ cris_examine (CORE_ADDR ip, CORE_ADDR limit, struct frame_info *fi, 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 @@ -737,15 +1048,6 @@ cris_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) 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. */ @@ -909,612 +1211,145 @@ cris_register_virtual_type (int regno) /* 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 @@ -3769,12 +3604,6 @@ _initialize_cris_tdep (void) 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 " @@ -3796,9 +3625,6 @@ cris_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file) 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); - } } @@ -3856,33 +3682,6 @@ cris_mode_update (char *ignore_args, int from_tty, } } -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 @@ -3926,8 +3725,6 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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) @@ -3958,51 +3755,9 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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. */ @@ -4011,8 +3766,7 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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; } @@ -4020,13 +3774,8 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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) @@ -4043,57 +3792,31 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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 @@ -4147,26 +3870,12 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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. */ @@ -4174,17 +3883,17 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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 -- 2.7.4