diff options
| -rw-r--r-- | gdb/ChangeLog | 7 | ||||
| -rw-r--r-- | gdb/Makefile.in | 7 | ||||
| -rw-r--r-- | gdb/config/xstormy16/xstormy16.mt | 5 | ||||
| -rw-r--r-- | gdb/configure.tgt | 3 | ||||
| -rw-r--r-- | gdb/xstormy16-tdep.c | 1133 |
5 files changed, 1154 insertions, 1 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 6a76696..3e11259 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,10 @@ +2001-12-13 Corinna Vinschen <vinschen@redhat.com> + + * Makefile.in: Add support for xstormy16. + * configure.tgt: Ditto. + * xstormy16-tdep.c: New file. + * config/xstormy16/xstormy16.mt: New file. + 2001-12-13 Andreas Schwab <schwab@suse.de> * MAINTAINERS (write-after-approval): Add myself. diff --git a/gdb/Makefile.in b/gdb/Makefile.in index adec505..554d0a5 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -1221,7 +1221,9 @@ ALLDEPFILES = 29k-share/udi/udip2soc.c 29k-share/udi/udr.c \ vax-tdep.c \ vx-share/xdr_ld.c vx-share/xdr_ptrace.c vx-share/xdr_rdb.c \ win32-nat.c \ - xcoffread.c xcoffsolib.c z8k-tdep.c + xcoffread.c xcoffsolib.c \ + xstormy16-tdep.c \ + z8k-tdep.c udip2soc.o: $(srcdir)/29k-share/udi/udip2soc.c $(udiheaders) $(CC) -c $(INTERNAL_CFLAGS) $(srcdir)/29k-share/udi/udip2soc.c @@ -2042,6 +2044,9 @@ sparc-tdep.o: sparc-tdep.c $(floatformat_h) $(defs_h) $(gdbcore_h) \ sparcl-tdep.o: sparcl-tdep.c $(defs_h) $(gdbcore_h) $(target_h) $(regcache_h) +xstormy16-tdep.o: xstormy16-tdep.c $(defs_h) $(value_h) $(inferior_h) \ + $(symfile_h) $(arch_utils_h) $(regcache_h) $(gdbcore_h) + dsrec.o: dsrec.c $(defs_h) srec.h stabsread.o: stabsread.c $(bfd_h) $(INCLUDE_DIR)/aout/stab.def \ diff --git a/gdb/config/xstormy16/xstormy16.mt b/gdb/config/xstormy16/xstormy16.mt new file mode 100644 index 0000000..c4b5751 --- /dev/null +++ b/gdb/config/xstormy16/xstormy16.mt @@ -0,0 +1,5 @@ +# Target: Sanyo Xstormy16a processor +TDEPFILES = xstormy16-tdep.o +# No simulator objects or libraries are needed -- target uses SID. +# SIM_OBS = remote-sim.o +# SIM = ../sim/xstormy16/libsim.a diff --git a/gdb/configure.tgt b/gdb/configure.tgt index 2e3de38..815511a 100644 --- a/gdb/configure.tgt +++ b/gdb/configure.tgt @@ -278,6 +278,8 @@ sparc86x-*-*) gdb_target=sparclite ;; sparc64-*-linux*) gdb_target=sp64linux ;; sparc64-*-*) gdb_target=sp64 ;; +xstormy16-*-*) gdb_target=xstormy16 ;; + vax-*-*) gdb_target=vax ;; fr30-*-*) gdb_target=fr30 @@ -303,4 +305,5 @@ cris) gdb_multi_arch=yes ;; d10v) gdb_multi_arch=yes ;; m68hc11) gdb_multi_arch=yes ;; mn10300) gdb_multi_arch=yes ;; +xstormy16) gdb_multi_arch=yes ;; esac diff --git a/gdb/xstormy16-tdep.c b/gdb/xstormy16-tdep.c new file mode 100644 index 0000000..bfadc7b --- /dev/null +++ b/gdb/xstormy16-tdep.c @@ -0,0 +1,1133 @@ +/* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor. + Copyright 2001, Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#include "defs.h" +#include "value.h" +#include "inferior.h" +#include "symfile.h" +#include "arch-utils.h" +#include "regcache.h" +#include "gdbcore.h" +#include "objfiles.h" + +struct gdbarch_tdep +{ + /* gdbarch target dependent data here. Currently unused for Xstormy16. */ +}; + +/* Extra info which is saved in each frame_info. */ +struct frame_extra_info +{ + int framesize; + int frameless_p; +}; + +enum gdb_regnum +{ + /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC. + Functions will return their values in register R2-R7 as they fit. + Otherwise a hidden pointer to an big enough area is given as argument + to the function in r2. Further arguments are beginning in r3 then. + R13 is used as frame pointer when GCC compiles w/o optimization + R14 is used as "PSW", displaying the CPU status. + R15 is used implicitely as stack pointer. */ + E_R0_REGNUM, + E_R1_REGNUM, + E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM, + E_R3_REGNUM, + E_R4_REGNUM, + E_R5_REGNUM, + E_R6_REGNUM, + E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM, + E_R8_REGNUM, + E_R9_REGNUM, + E_R10_REGNUM, + E_R11_REGNUM, + E_R12_REGNUM, + E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM, + E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM, + E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM, + E_PC_REGNUM, + E_NUM_REGS +}; + +/* Size of instructions, registers, etc. */ +enum +{ + xstormy16_inst_size = 2, + xstormy16_reg_size = 2, + xstormy16_pc_size = 4 +}; + +/* Size of return datatype which fits into the remaining return registers. */ +#define E_MAX_RETTYPE_SIZE(regnum) ((E_LST_ARG_REGNUM - (regnum) + 1) \ + * xstormy16_reg_size) + +/* Size of return datatype which fits into all return registers. */ +enum +{ + E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM) +}; + + +/* Size of all registers as a whole. */ +enum +{ + E_ALL_REGS_SIZE = (E_NUM_REGS - 1) * xstormy16_reg_size + xstormy16_pc_size +}; + +/* Function: xstormy16_register_name + Returns the name of the standard Xstormy16 register N. */ + +static char * +xstormy16_register_name (int regnum) +{ + static char *register_names[] = { + "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", + "r8", "r9", "r10", "r11", "r12", "r13", + "psw", "sp", "pc" + }; + + if (regnum < 0 || + regnum >= sizeof (register_names) / sizeof (register_names[0])) + internal_error (__FILE__, __LINE__, + "xstormy16_register_name: illegal register number %d", + regnum); + else + return register_names[regnum]; + +} + +/* Function: xstormy16_register_byte + Returns the byte position in the register cache for register N. */ + +static int +xstormy16_register_byte (int regnum) +{ + if (regnum < 0 || regnum >= E_NUM_REGS) + internal_error (__FILE__, __LINE__, + "xstormy16_register_byte: illegal register number %d", + regnum); + else + /* All registers occupy 2 bytes in the regcache except for PC + which is the last one. Therefore the byte position is still + simply a multiple of 2. */ + return regnum * xstormy16_reg_size; +} + +/* Function: xstormy16_register_raw_size + Returns the number of bytes occupied by the register on the target. */ + +static int +xstormy16_register_raw_size (int regnum) +{ + if (regnum < 0 || regnum >= E_NUM_REGS) + internal_error (__FILE__, __LINE__, + "xstormy16_register_raw_size: illegal register number %d", + regnum); + /* Only the PC has 4 Byte, all other registers 2 Byte. */ + else if (regnum == E_PC_REGNUM) + return xstormy16_pc_size; + else + return xstormy16_reg_size; +} + +/* Function: xstormy16_register_virtual_size + Returns the number of bytes occupied by the register as represented + internally by gdb. */ + +static int +xstormy16_register_virtual_size (int regnum) +{ + return xstormy16_register_raw_size (regnum); +} + +/* Function: xstormy16_reg_virtual_type + Returns the default type for register N. */ + +static struct type * +xstormy16_reg_virtual_type (int regnum) +{ + if (regnum < 0 || regnum >= E_NUM_REGS) + internal_error (__FILE__, __LINE__, + "xstormy16_register_virtual_type: illegal register number %d", + regnum); + else if (regnum == E_PC_REGNUM) + return builtin_type_uint32; + else + return builtin_type_uint16; +} + +/* Function: xstormy16_get_saved_register + Find a register's saved value on the call stack. */ + +static void +xstormy16_get_saved_register (char *raw_buffer, + int *optimized, + CORE_ADDR *addrp, + struct frame_info *fi, + int regnum, enum lval_type *lval) +{ + generic_get_saved_register (raw_buffer, optimized, addrp, fi, regnum, lval); +} + +/* Function: xstormy16_type_is_scalar + Makes the decision if a given type is a scalar types. Scalar + types are returned in the registers r2-r7 as they fit. */ + +static int +xstormy16_type_is_scalar (struct type *t) +{ + return (TYPE_CODE(t) != TYPE_CODE_STRUCT + && TYPE_CODE(t) != TYPE_CODE_UNION + && TYPE_CODE(t) != TYPE_CODE_ARRAY); +} + +/* Function: xstormy16_extract_return_value + Copy the function's return value into VALBUF. + This function is called only in the context of "target function calls", + ie. when the debugger forces a function to be called in the child, and + when the debugger forces a function to return prematurely via the + "return" command. */ + +static void +xstormy16_extract_return_value (struct type *type, char *regbuf, char *valbuf) +{ + CORE_ADDR return_buffer; + int offset = 0; + + if (xstormy16_type_is_scalar (type) + && TYPE_LENGTH (type) <= E_MAX_RETTYPE_SIZE_IN_REGS) + { + /* Scalar return values of <= 12 bytes are returned in + E_1ST_ARG_REGNUM to E_LST_ARG_REGNUM. */ + memcpy (valbuf, + ®buf[REGISTER_BYTE (E_1ST_ARG_REGNUM)] + offset, + TYPE_LENGTH (type)); + } + else + { + /* Aggregates and return values > 12 bytes are returned in memory, + pointed to by R2. */ + return_buffer = + extract_address (regbuf + REGISTER_BYTE (E_PTR_RET_REGNUM), + REGISTER_RAW_SIZE (E_PTR_RET_REGNUM)); + + read_memory (return_buffer, valbuf, TYPE_LENGTH (type)); + } +} + +/* Function: xstormy16_push_arguments + Setup the function arguments for GDB to call a function in the inferior. + Called only in the context of a target function call from the debugger. + Returns the value of the SP register after the args are pushed. +*/ + +static CORE_ADDR +xstormy16_push_arguments (int nargs, struct value **args, CORE_ADDR sp, + int struct_return, CORE_ADDR struct_addr) +{ + CORE_ADDR stack_dest = sp; + int argreg = E_1ST_ARG_REGNUM; + int i, j; + int typelen, slacklen; + char *val; + + /* If struct_return is true, then the struct return address will + consume one argument-passing register. */ + if (struct_return) + argreg++; + + /* Arguments are passed in R2-R7 as they fit. If an argument doesn't + fit in the remaining registers we're switching over to the stack. + No argument is put on stack partially and as soon as we switched + over to stack no further argument is put in a register even if it + would fit in the remaining unused registers. */ + for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++) + { + typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i])); + if (typelen > E_MAX_RETTYPE_SIZE (argreg)) + break; + + /* Put argument into registers wordwise. */ + val = VALUE_CONTENTS (args[i]); + for (j = 0; j < typelen; j += xstormy16_reg_size) + write_register (argreg++, + extract_unsigned_integer (val + j, + typelen - j == + 1 ? 1 : + xstormy16_reg_size)); + } + + /* Align SP */ + if (stack_dest & 1) + ++stack_dest; + + /* Loop backwards through remaining arguments and push them on the stack, + wordaligned. */ + for (j = nargs - 1; j >= i; j--) + { + typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[j])); + slacklen = typelen & 1; + val = alloca (typelen + slacklen); + memcpy (val, VALUE_CONTENTS (args[j]), typelen); + memset (val + typelen, 0, slacklen); + + /* Now write this data to the stack. The stack grows upwards. */ + write_memory (stack_dest, val, typelen + slacklen); + stack_dest += typelen + slacklen; + } + + /* And that should do it. Return the new stack pointer. */ + return stack_dest; +} + +/* Function: xstormy16_push_return_address (pc) + Setup the return address for GDB to call a function in the inferior. + Called only in the context of a target function call from the debugger. + Returns the value of the SP register when the operation is finished + (which may or may not be the same as before). +*/ + +CORE_ADDR +xstormy16_push_return_address (CORE_ADDR pc, CORE_ADDR sp) +{ + unsigned char buf[xstormy16_pc_size]; + + store_unsigned_integer (buf, xstormy16_pc_size, CALL_DUMMY_ADDRESS ()); + write_memory (sp, buf, xstormy16_pc_size); + return sp + xstormy16_pc_size; +} + +/* Function: xstormy16_pop_frame + Destroy the innermost (Top-Of-Stack) stack frame, restoring the + machine state that was in effect before the frame was created. + Used in the contexts of the "return" command, and of + target function calls from the debugger. +*/ + +static void +xstormy16_pop_frame (void) +{ + struct frame_info *fi = get_current_frame (); + int i; + + if (fi == NULL) + return; /* paranoia */ + + if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) + { + generic_pop_dummy_frame (); + } + else + { + /* Restore the saved regs. */ + for (i = 0; i < NUM_REGS; i++) + if (fi->saved_regs[i]) + { + if (i == SP_REGNUM) + write_register (i, fi->saved_regs[i]); + else if (i == E_PC_REGNUM) + write_register (i, read_memory_integer (fi->saved_regs[i], + xstormy16_pc_size)); + else + write_register (i, read_memory_integer (fi->saved_regs[i], + xstormy16_reg_size)); + } + /* Restore the PC */ + write_register (PC_REGNUM, FRAME_SAVED_PC (fi)); + flush_cached_frames (); + } + return; +} + +/* Function: xstormy16_store_struct_return + Copy the (struct) function return value to its destined location. + Called only in the context of a target function call from the debugger. +*/ + +static void +xstormy16_store_struct_return (CORE_ADDR addr, CORE_ADDR sp) +{ + write_register (E_PTR_RET_REGNUM, addr); +} + +/* Function: xstormy16_store_return_value + Copy the function return value from VALBUF into the + proper location for a function return. + Called only in the context of the "return" command. +*/ + +static void +xstormy16_store_return_value (struct type *type, char *valbuf) +{ + CORE_ADDR return_buffer; + char buf[xstormy16_reg_size]; + + if (xstormy16_type_is_scalar (type) && TYPE_LENGTH (type) == 1) + { + /* Add leading zeros to the value. */ + memset (buf, 0, xstormy16_reg_size); + memcpy (buf, valbuf, 1); + write_register_gen (E_1ST_ARG_REGNUM, buf); + } + else if (xstormy16_type_is_scalar (type) && + TYPE_LENGTH (type) <= E_MAX_RETTYPE_SIZE_IN_REGS) + write_register_bytes (REGISTER_BYTE (E_1ST_ARG_REGNUM), + valbuf, TYPE_LENGTH (type)); + else + { + return_buffer = read_register (E_PTR_RET_REGNUM); + write_memory (return_buffer, valbuf, TYPE_LENGTH (type)); + } +} + +/* Function: xstormy16_extract_struct_value_address + Returns the address in which a function should return a struct value. + Used in the contexts of the "return" command, and of + target function calls from the debugger. +*/ + +static CORE_ADDR +xstormy16_extract_struct_value_address (char *regbuf) +{ + return extract_address (regbuf + + xstormy16_register_byte (E_PTR_RET_REGNUM), + xstormy16_reg_size); +} + +/* Function: xstormy16_use_struct_convention + Returns non-zero if the given struct type will be returned using + a special convention, rather than the normal function return method. + 7sed in the contexts of the "return" command, and of + target function calls from the debugger. +*/ + +static int +xstormy16_use_struct_convention (int gcc_p, struct type *type) +{ + return !xstormy16_type_is_scalar (type) + || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS; +} + +/* Function: frame_saved_register + Returns the value that regnum had in frame fi + (saved in fi or in one of its children). +*/ + +static CORE_ADDR +xstormy16_frame_saved_register (struct frame_info *fi, int regnum) +{ + int size = xstormy16_register_raw_size (regnum); + char *buf = (char *) alloca (size); + + generic_get_saved_register (buf, NULL, NULL, fi, regnum, NULL); + return (CORE_ADDR) extract_unsigned_integer (buf, size); +} + +/* Function: xstormy16_scan_prologue + Decode the instructions within the given address range. + Decide when we must have reached the end of the function prologue. + If a frame_info pointer is provided, fill in its saved_regs etc. + + Returns the address of the first instruction after the prologue. +*/ + +static CORE_ADDR +xstormy16_scan_prologue (CORE_ADDR start_addr, + CORE_ADDR end_addr, struct frame_info *fi) +{ + CORE_ADDR sp = 0, fp = 0; + CORE_ADDR next_addr; + ULONGEST inst, inst2; + LONGEST offset; + int regnum; + + if (fi) + { + /* In a call dummy, don't touch the frame. */ + if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) + return start_addr; + + /* Grab the frame-relative values of SP and FP, needed below. + The frame_saved_register function will find them on the + stack or in the registers as appropriate. */ + sp = xstormy16_frame_saved_register (fi, E_SP_REGNUM); + fp = xstormy16_frame_saved_register (fi, E_FP_REGNUM); + + /* Initialize framesize with size of PC put on stack by CALLF inst. */ + fi->extra_info->framesize = xstormy16_pc_size; + } + for (next_addr = start_addr; + next_addr < end_addr; next_addr += xstormy16_inst_size) + { + inst = read_memory_unsigned_integer (next_addr, xstormy16_inst_size); + inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size, + xstormy16_inst_size); + + if (inst >= 0x0082 && inst <= 0x008d) /* push r2 .. push r13 */ + { + if (fi) + { + regnum = inst & 0x000f; + fi->saved_regs[regnum] = fi->extra_info->framesize; + fi->extra_info->framesize += xstormy16_reg_size; + } + } + + /* optional stack allocation for args and local vars <= 4 byte */ + else if (inst == 0x301f || inst == 0x303f) /* inc r15, #0x1/#0x3 */ + { + if (fi) /* Record the frame size. */ + fi->extra_info->framesize += ((inst & 0x0030) >> 4) + 1; + } + + /* optional stack allocation for args and local vars > 4 && < 16 byte */ + else if ((inst & 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */ + { + if (fi) /* Record the frame size. */ + fi->extra_info->framesize += (inst & 0x00f0) >> 4; + } + + /* optional stack allocation for args and local vars >= 16 byte */ + else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */ + { + if (fi) /* Record the frame size. */ + fi->extra_info->framesize += inst2; + next_addr += xstormy16_inst_size; + } + + else if (inst == 0x46fd) /* mov r13, r15 */ + { + if (fi) /* Record that the frame pointer is in use. */ + fi->extra_info->frameless_p = 0; + } + + /* optional copying of args in r2-r7 to r10-r13 */ + /* Probably only in optimized case but legal action for prologue */ + else if ((inst & 0xff00) == 0x4600 /* 46SD mov rD, rS */ + && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070 + && (inst & 0x000f) >= 0x00a0 && (inst & 0x000f) <= 0x000d) + ; + + /* optional copying of args in r2-r7 to stack */ + /* 72DS HHHH mov.b (rD, 0xHHHH), r(S-8) (bit3 always 1, bit2-0 = reg) */ + /* 73DS HHHH mov.w (rD, 0xHHHH), r(S-8) */ + else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2) + { + if (fi) + { + regnum = inst & 0x0007; + /* Only 12 of 16 bits of the argument are used for the + signed offset. */ + offset = (LONGEST) (inst2 & 0x0fff); + if (offset & 0x0800) + offset -= 0x1000; + + fi->saved_regs[regnum] = fi->extra_info->framesize + offset; + } + next_addr += xstormy16_inst_size; + } + +#if 0 + /* 2001-08-10: Not part of the prologue anymore due to change in + ABI. r8 and r9 are not used for argument passing anymore. */ + + /* optional copying of r8, r9 to stack */ + /* 46S7; 73Df HHHH mov.w r7,rS; mov.w (rD, 0xHHHH), r7 D=8,9; S=13,15 */ + /* 46S7; 72df HHHH mov.w r7,rS; mov.b (rD, 0xHHHH), r7 D=8,9; S=13,15 */ + else if ((inst & 0xffef) == 0x4687 && (inst2 & 0xfedf) == 0x72df) + { + next_addr += xstormy16_inst_size; + if (fi) + { + regnum = (inst & 0x00f0) >> 4; + inst = inst2; + inst2 = read_memory_unsigned_integer (next_addr + + xstormy16_inst_size, + xstormy16_inst_size); + /* Only 12 of 16 bits of the argument are used for the + signed offset. */ + offset = (LONGEST) (inst2 & 0x0fff); + if (offset & 0x0800) + offset -= 0x1000; + + fi->saved_regs[regnum] = fi->extra_info->framesize + offset; + } + next_addr += xstormy16_inst_size; + } +#endif + + else /* Not a prologue instruction. */ + break; + } + + if (fi) + { + /* Special handling for the "saved" address of the SP: + The SP is of course never saved on the stack at all, so + by convention what we put here is simply the previous + _value_ of the SP (as opposed to an address where the + previous value would have been pushed). */ + if (fi->extra_info->frameless_p) + { + fi->saved_regs[E_SP_REGNUM] = sp - fi->extra_info->framesize; + fi->frame = sp; + } + else + { + fi->saved_regs[E_SP_REGNUM] = fp - fi->extra_info->framesize; + fi->frame = fp; + } + + /* So far only offsets to the beginning of the frame are + saved in the saved_regs. Now we now the relation between + sp, fp and framesize. We know the beginning of the frame + so we can translate the register offsets to real addresses. */ + for (regnum = 0; regnum < E_SP_REGNUM; ++regnum) + if (fi->saved_regs[regnum]) + fi->saved_regs[regnum] += fi->saved_regs[E_SP_REGNUM]; + + /* Save address of PC on stack. */ + fi->saved_regs[E_PC_REGNUM] = fi->saved_regs[E_SP_REGNUM]; + } + + return next_addr; +} + +/* Function: xstormy16_skip_prologue + If the input address is in a function prologue, + returns the address of the end of the prologue; + else returns the input address. + + Note: the input address is likely to be the function start, + since this function is mainly used for advancing a breakpoint + to the first line, or stepping to the first line when we have + stepped into a function call. */ + +static CORE_ADDR +xstormy16_skip_prologue (CORE_ADDR pc) +{ + CORE_ADDR func_addr = 0, func_end = 0; + char *func_name; + + if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end)) + { + struct symtab_and_line sal; + struct symbol *sym; + + /* Found a function. */ + sym = lookup_symbol (func_name, NULL, VAR_NAMESPACE, NULL, NULL); + if (sym && SYMBOL_LANGUAGE (sym) != language_asm) + { + /* Don't use this trick for assembly source files. */ + sal = find_pc_line (func_addr, 0); + if (sal.end && sal.end < func_end) + { + /* Found a line number, use it as end of prologue. */ + return sal.end; + } + } + /* No useable line symbol. Use prologue parsing method. */ + return xstormy16_scan_prologue (func_addr, func_end, NULL); + } + + /* No function symbol -- just return the PC. */ + + return (CORE_ADDR) pc; +} + +/* The epilogue is defined here as the area at the end of a function, + either on the `ret' instruction itself or after an instruction which + destroys the function's stack frame. */ +static int +xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc) +{ + CORE_ADDR addr, func_addr = 0, func_end = 0; + + if (find_pc_partial_function (pc, NULL, &func_addr, &func_end)) + { + ULONGEST inst, inst2; + CORE_ADDR addr = func_end - xstormy16_inst_size; + + /* The Xstormy16 epilogue is max. 14 bytes long. */ + if (pc < func_end - 7 * xstormy16_inst_size) + return 0; + + /* Check if we're on a `ret' instruction. Otherwise it's + too dangerous to proceed. */ + inst = read_memory_unsigned_integer (addr, xstormy16_inst_size); + if (inst != 0x0003) + return 0; + + while ((addr -= xstormy16_inst_size) >= func_addr) + { + inst = read_memory_unsigned_integer (addr, xstormy16_inst_size); + if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */ + continue; + if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */ + break; + inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size, + xstormy16_inst_size); + if (inst2 == 0x314f && inst >= 0x8000) /* add r15, neg. value */ + { + addr -= xstormy16_inst_size; + break; + } + return 0; + } + if (pc > addr) + return 1; + } + return 0; +} + +/* Function: xstormy16_frame_init_saved_regs + Set up the 'saved_regs' array. + This is a data structure containing the addresses on the stack + where each register has been saved, for each stack frame. + Registers that have not been saved will have zero here. + The stack register is special: rather than the address where the + stack register has been saved, saved_regs[SP_REGNUM] will have the + actual value of the previous frame's stack register. + + This function may be called in any context where the saved register + values may be needed (backtrace, frame_info, get_saved_register). + On many targets, it is called directly by init_extra_frame_info, + in part because the information may be needed immediately by + frame_chain. +*/ + +static void +xstormy16_frame_init_saved_regs (struct frame_info *fi) +{ + CORE_ADDR func_addr, func_end; + + if (!fi->saved_regs) + { + frame_saved_regs_zalloc (fi); + + /* Find the beginning of this function, so we can analyze its + prologue. */ + if (find_pc_partial_function (fi->pc, NULL, &func_addr, &func_end)) + xstormy16_scan_prologue (func_addr, fi->pc, fi); + /* Else we're out of luck (can't debug completely stripped code). + FIXME. */ + } +} + +/* Function: xstormy16_frame_saved_pc + Returns the return address for the selected frame. + Called by frame_info, frame_chain_valid, and sometimes by + get_prev_frame. +*/ + +static CORE_ADDR +xstormy16_frame_saved_pc (struct frame_info *fi) +{ + CORE_ADDR saved_pc; + + if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) + { + saved_pc = generic_read_register_dummy (fi->pc, fi->frame, E_PC_REGNUM); + } + else + { + saved_pc = read_memory_unsigned_integer (fi->saved_regs[E_PC_REGNUM], + xstormy16_pc_size); + } + + return saved_pc; +} + +/* Function: xstormy16_init_extra_frame_info + This is the constructor function for the frame_info struct, + called whenever a new frame_info is created (from create_new_frame, + and from get_prev_frame). +*/ + +static void +xstormy16_init_extra_frame_info (int fromleaf, struct frame_info *fi) +{ + if (!fi->extra_info) + { + fi->extra_info = (struct frame_extra_info *) + frame_obstack_alloc (sizeof (struct frame_extra_info)); + fi->extra_info->framesize = 0; + fi->extra_info->frameless_p = 1; /* Default frameless, detect framed */ + + /* By default, the fi->frame is set to the value of the FP reg by gdb. + This may not always be right; we may be in a frameless function, + or we may be in the prologue, before the FP has been set up. + Unfortunately, we can't make this determination without first + calling scan_prologue, and we can't do that unles we know the + fi->pc. */ + + if (!fi->pc) + { + /* Sometimes we are called from get_prev_frame without + the PC being set up first. Long history, don't ask. + Fortunately this will never happen from the outermost + frame, so we should be able to get the saved pc from + the next frame. */ + if (fi->next) + fi->pc = xstormy16_frame_saved_pc (fi->next); + } + + /* Take care of the saved_regs right here (non-lazy). */ + xstormy16_frame_init_saved_regs (fi); + } +} + +/* Function: xstormy16_frame_chain + Returns a pointer to the stack frame of the calling function. + Called only from get_prev_frame. Needed for backtrace, "up", etc. +*/ + +static CORE_ADDR +xstormy16_frame_chain (struct frame_info *fi) +{ + if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame)) + { + /* Call dummy's frame is the same as caller's. */ + return fi->frame; + } + else + { + /* Return computed offset from this frame's fp. */ + return fi->frame - fi->extra_info->framesize; + } +} + +static int +xstormy16_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe) +{ + return chain < 0x8000 && FRAME_SAVED_PC (thisframe) >= 0x8000 && + (thisframe->extra_info->frameless_p || + thisframe->frame - thisframe->extra_info->framesize == chain); +} + +/* Function: xstormy16_saved_pc_after_call + Returns the previous PC immediately after a function call. + This function is meant to bypass the regular get_saved_register + mechanism, ie. it is meant to work even if the frame isn't complete. + Called by step_over_function, and sometimes by get_prev_frame. +*/ + +static CORE_ADDR +xstormy16_saved_pc_after_call (struct frame_info *ignore) +{ + CORE_ADDR sp, pc, tmp; + + sp = read_register (E_SP_REGNUM) - xstormy16_pc_size; + pc = read_memory_integer (sp, xstormy16_pc_size); + + /* Skip over jump table entry if necessary. */ + if ((tmp = SKIP_TRAMPOLINE_CODE (pc))) + pc = tmp; + + return pc; +} + +static unsigned char * +xstormy16_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr) +{ + static unsigned char breakpoint[] = { 0x06, 0x0 }; + *lenptr = sizeof (breakpoint); + return breakpoint; +} + +/* Given a pointer to a jump table entry, return the address + of the function it jumps to. Return 0 if not found. */ +static CORE_ADDR +xstormy16_resolve_jmp_table_entry (CORE_ADDR faddr) +{ + struct obj_section *faddr_sect = find_pc_section (faddr); + + if (faddr_sect) + { + LONGEST inst, inst2, addr; + char buf[2 * xstormy16_inst_size]; + + /* Return faddr if it's not pointing into the jump table. */ + if (strcmp (faddr_sect->the_bfd_section->name, ".plt")) + return faddr; + + if (!target_read_memory (faddr, buf, sizeof buf)) + { + inst = extract_unsigned_integer (buf, xstormy16_inst_size); + inst2 = extract_unsigned_integer (buf + xstormy16_inst_size, + xstormy16_inst_size); + addr = inst2 << 8 | (inst & 0xff); + return addr; + } + } + return 0; +} + +/* Given a function's address, attempt to find (and return) the + address of the corresponding jump table entry. Return 0 if + not found. */ +static CORE_ADDR +xstormy16_find_jmp_table_entry (CORE_ADDR faddr) +{ + struct obj_section *faddr_sect = find_pc_section (faddr); + + if (faddr_sect) + { + struct obj_section *osect; + + /* Return faddr if it's already a pointer to a jump table entry. */ + if (!strcmp (faddr_sect->the_bfd_section->name, ".plt")) + return faddr; + + ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect) + { + if (!strcmp (osect->the_bfd_section->name, ".plt")) + break; + } + + if (osect < faddr_sect->objfile->sections_end) + { + CORE_ADDR addr; + for (addr = osect->addr; + addr < osect->endaddr; addr += 2 * xstormy16_inst_size) + { + int status; + LONGEST inst, inst2, faddr2; + char buf[2 * xstormy16_inst_size]; + + if (target_read_memory (addr, buf, sizeof buf)) + return 0; + inst = extract_unsigned_integer (buf, xstormy16_inst_size); + inst2 = extract_unsigned_integer (buf + xstormy16_inst_size, + xstormy16_inst_size); + faddr2 = inst2 << 8 | (inst & 0xff); + if (faddr == faddr2) + return addr; + } + } + } + return 0; +} + +static CORE_ADDR +xstormy16_skip_trampoline_code (CORE_ADDR pc) +{ + int tmp = xstormy16_resolve_jmp_table_entry (pc); + + if (tmp && tmp != pc) + return tmp; + return 0; +} + +static int +xstormy16_in_solib_call_trampoline (CORE_ADDR pc, char *name) +{ + return xstormy16_skip_trampoline_code (pc) != 0; +} + +static CORE_ADDR +xstormy16_pointer_to_address (struct type *type, void *buf) +{ + enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type)); + CORE_ADDR addr = extract_address (buf, TYPE_LENGTH (type)); + + if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD) + { + CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (addr); + if (addr2) + addr = addr2; + } + + return addr; +} + +static void +xstormy16_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr) +{ + enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type)); + + if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD) + { + CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (addr); + if (addr2) + addr = addr2; + } + store_address (buf, TYPE_LENGTH (type), addr); +} + +static CORE_ADDR +xstormy16_stack_align (CORE_ADDR addr) +{ + if (addr & 1) + ++addr; + return addr; +} + +void +xstormy16_save_dummy_frame_tos (CORE_ADDR sp) +{ + generic_save_dummy_frame_tos (sp - xstormy16_pc_size); +} + +/* Function: xstormy16_gdbarch_init + Initializer function for the xstormy16 gdbarch vector. + Called by gdbarch. Sets up the gdbarch vector(s) for this target. */ + +static struct gdbarch * +xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) +{ + static LONGEST call_dummy_words[1] = { 0 }; + struct gdbarch_tdep *tdep = NULL; + struct gdbarch *gdbarch; + + /* find a candidate among the list of pre-declared architectures. */ + arches = gdbarch_list_lookup_by_info (arches, &info); + if (arches != NULL) + return (arches->gdbarch); + +#if 0 + tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep)); +#endif + + gdbarch = gdbarch_alloc (&info, 0); + + /* + * Basic register fields and methods. + */ + + set_gdbarch_num_regs (gdbarch, E_NUM_REGS); + set_gdbarch_num_pseudo_regs (gdbarch, 0); + set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM); + set_gdbarch_fp_regnum (gdbarch, E_FP_REGNUM); + set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM); + set_gdbarch_register_name (gdbarch, xstormy16_register_name); + set_gdbarch_register_size (gdbarch, xstormy16_reg_size); + set_gdbarch_register_bytes (gdbarch, E_ALL_REGS_SIZE); + set_gdbarch_register_byte (gdbarch, xstormy16_register_byte); + set_gdbarch_register_raw_size (gdbarch, xstormy16_register_raw_size); + set_gdbarch_max_register_raw_size (gdbarch, xstormy16_pc_size); + set_gdbarch_register_virtual_size (gdbarch, xstormy16_register_raw_size); + set_gdbarch_max_register_virtual_size (gdbarch, 4); + set_gdbarch_register_virtual_type (gdbarch, xstormy16_reg_virtual_type); + + /* + * Frame Info + */ + set_gdbarch_init_extra_frame_info (gdbarch, + xstormy16_init_extra_frame_info); + set_gdbarch_frame_init_saved_regs (gdbarch, + xstormy16_frame_init_saved_regs); + set_gdbarch_frame_chain (gdbarch, xstormy16_frame_chain); + set_gdbarch_get_saved_register (gdbarch, xstormy16_get_saved_register); + set_gdbarch_saved_pc_after_call (gdbarch, xstormy16_saved_pc_after_call); + set_gdbarch_frame_saved_pc (gdbarch, xstormy16_frame_saved_pc); + set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue); + set_gdbarch_frame_chain_valid (gdbarch, xstormy16_frame_chain_valid); + set_gdbarch_frame_args_address (gdbarch, default_frame_address); + set_gdbarch_frame_locals_address (gdbarch, default_frame_address); + + set_gdbarch_in_function_epilogue_p (gdbarch, + xstormy16_in_function_epilogue_p); + + /* + * Miscelany + */ + /* Stack grows up. */ + set_gdbarch_inner_than (gdbarch, core_addr_greaterthan); + /* PC stops zero byte after a trap instruction + (which means: exactly on trap instruction). */ + set_gdbarch_decr_pc_after_break (gdbarch, 0); + /* This value is almost never non-zero... */ + set_gdbarch_function_start_offset (gdbarch, 0); + /* This value is almost never non-zero... */ + set_gdbarch_frame_args_skip (gdbarch, 0); + /* OK to default this value to 'unknown'. */ + set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown); + + /* W/o prototype, coerce float args to double. */ + set_gdbarch_coerce_float_to_double (gdbarch, + standard_coerce_float_to_double); + + /* + * Call Dummies + * + * These values and methods are used when gdb calls a target function. */ + set_gdbarch_use_generic_dummy_frames (gdbarch, 1); + set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame); + set_gdbarch_push_return_address (gdbarch, xstormy16_push_return_address); + set_gdbarch_extract_return_value (gdbarch, xstormy16_extract_return_value); + set_gdbarch_push_arguments (gdbarch, xstormy16_push_arguments); + set_gdbarch_pop_frame (gdbarch, xstormy16_pop_frame); + set_gdbarch_store_struct_return (gdbarch, xstormy16_store_struct_return); + set_gdbarch_store_return_value (gdbarch, xstormy16_store_return_value); + set_gdbarch_extract_struct_value_address (gdbarch, + xstormy16_extract_struct_value_address); + set_gdbarch_use_struct_convention (gdbarch, + xstormy16_use_struct_convention); + set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT); + set_gdbarch_call_dummy_address (gdbarch, entry_point_address); + set_gdbarch_call_dummy_start_offset (gdbarch, 0); + set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0); + set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1); + set_gdbarch_call_dummy_length (gdbarch, 0); + set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy); + set_gdbarch_call_dummy_p (gdbarch, 1); + set_gdbarch_call_dummy_words (gdbarch, call_dummy_words); + set_gdbarch_sizeof_call_dummy_words (gdbarch, 0); + set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0); + /* set_gdbarch_call_dummy_stack_adjust */ + set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy); + set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc); + + set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT); + set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT); + set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT); + set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT); + + set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer); + set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address); + + set_gdbarch_stack_align (gdbarch, xstormy16_stack_align); + set_gdbarch_extra_stack_alignment_needed (gdbarch, 0); + + set_gdbarch_save_dummy_frame_tos (gdbarch, xstormy16_save_dummy_frame_tos); + + set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code); + + set_gdbarch_in_solib_call_trampoline (gdbarch, + xstormy16_in_solib_call_trampoline); + + return gdbarch; +} + +/* Function: _initialize_xstormy16_tdep + Initializer function for the Sanyo Xstormy16a module. + Called by gdb at start-up. */ + +void +_initialize_xstormy16_tdep (void) +{ + extern int print_insn_xstormy16 (); + + register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init); + tm_print_insn = print_insn_xstormy16; +} |