gdb/xstormy16-tdep.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.

  3.    Copyright (C) 2001-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 3 of the License, or
  10.    (at your option) any later version.

  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.

  17.    You should have received a copy of the GNU General Public License
  18.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  20. #include "defs.h"
  21. #include "frame.h"
  22. #include "frame-base.h"
  23. #include "frame-unwind.h"
  24. #include "dwarf2-frame.h"
  25. #include "symtab.h"
  26. #include "gdbtypes.h"
  27. #include "gdbcmd.h"
  28. #include "gdbcore.h"
  29. #include "value.h"
  30. #include "dis-asm.h"
  31. #include "inferior.h"
  32. #include "arch-utils.h"
  33. #include "floatformat.h"
  34. #include "regcache.h"
  35. #include "doublest.h"
  36. #include "osabi.h"
  37. #include "objfiles.h"

  39. ‌enum gdb_regnum
  40. {
  41.   /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
  42.      Functions will return their values in register R2-R7 as they fit.
  43.      Otherwise a hidden pointer to an big enough area is given as argument
  44.      to the function in r2.  Further arguments are beginning in r3 then.
  45.      R13 is used as frame pointer when GCC compiles w/o optimization
  46.      R14 is used as "PSW", displaying the CPU status.
  47.      R15 is used implicitely as stack pointer.  */
  48.   E_R0_REGNUM,
  49.   E_R1_REGNUM,
  50.   E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM,
  51.   E_R3_REGNUM,
  52.   E_R4_REGNUM,
  53.   E_R5_REGNUM,
  54.   E_R6_REGNUM,
  55.   E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM,
  56.   E_R8_REGNUM,
  57.   E_R9_REGNUM,
  58.   E_R10_REGNUM,
  59.   E_R11_REGNUM,
  60.   E_R12_REGNUM,
  61.   E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM,
  62.   E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM,
  63.   E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM,
  64.   E_PC_REGNUM,
  65.   E_NUM_REGS
  66. };

  68. /* Use an invalid address value as 'not available' marker.  */
  69. enum { REG_UNAVAIL = (CORE_ADDR) -1 };

  71. ‌struct xstormy16_frame_cache
  72. {
  73.   /* Base address.  */
  74.   CORE_ADDR base;
  75.   CORE_ADDR pc;
  76.   LONGEST framesize;
  77.   int uses_fp;
  78.   CORE_ADDR saved_regs[E_NUM_REGS];
  79.   CORE_ADDR saved_sp;
  80. };

  82. /* Size of instructions, registers, etc.  */
  83. enum
  84. {
  85.   xstormy16_inst_size = 2,
  86.   xstormy16_reg_size = 2,
  87.   xstormy16_pc_size = 4
  88. };

  90. /* Size of return datatype which fits into the remaining return registers.  */
  91. ‌#define E_MAX_RETTYPE_SIZE(regnum)        ((E_LST_ARG_REGNUM - (regnum) + 1) \
  92.                                         * xstormy16_reg_size)

  94. /* Size of return datatype which fits into all return registers.  */
  95. enum
  96. {
  97.   E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM)
  98. };

  100. /* Function: xstormy16_register_name
  101.    Returns the name of the standard Xstormy16 register N.  */

  103. static const char *
  104. ‌xstormy16_register_name (struct gdbarch *gdbarch, int regnum)
  105. {
  106.   static char *register_names[] = {
  107.     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  108.     "r8", "r9", "r10", "r11", "r12", "r13",
  109.     "psw", "sp", "pc"
  110.   };

  112.   if (regnum < 0 || regnum >= E_NUM_REGS)
  113.     internal_error (__FILE__, __LINE__,
  114.                     _("xstormy16_register_name: illegal register number %d"),
  115.                     regnum);
  116.   else
  117.     return register_names[regnum];

  119. }

  121. static struct type *
  122. ‌xstormy16_register_type (struct gdbarch *gdbarch, int regnum)
  123. {
  124.   if (regnum == E_PC_REGNUM)
  125.     return builtin_type (gdbarch)->builtin_uint32;
  126.   else
  127.     return builtin_type (gdbarch)->builtin_uint16;
  128. }

  130. /* Function: xstormy16_type_is_scalar
  131.    Makes the decision if a given type is a scalar types.  Scalar
  132.    types are returned in the registers r2-r7 as they fit.  */

  134. static int
  135. ‌xstormy16_type_is_scalar (struct type *t)
  136. {
  137.   return (TYPE_CODE(t) != TYPE_CODE_STRUCT
  138.           && TYPE_CODE(t) != TYPE_CODE_UNION
  139.           && TYPE_CODE(t) != TYPE_CODE_ARRAY);
  140. }

  142. /* Function: xstormy16_use_struct_convention
  143.    Returns non-zero if the given struct type will be returned using
  144.    a special convention, rather than the normal function return method.
  145.    7sed in the contexts of the "return" command, and of
  146.    target function calls from the debugger.  */

  148. static int
  149. ‌xstormy16_use_struct_convention (struct type *type)
  150. {
  151.   return !xstormy16_type_is_scalar (type)
  152.          || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
  153. }

  155. /* Function: xstormy16_extract_return_value
  156.    Find a function's return value in the appropriate registers (in
  157.    regbuf), and copy it into valbuf.  */

  159. static void
  160. ‌xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
  161.                                 gdb_byte *valbuf)
  162. {
  163.   int len = TYPE_LENGTH (type);
  164.   int i, regnum = E_1ST_ARG_REGNUM;

  166.   for (i = 0; i < len; i += xstormy16_reg_size)
  167.     regcache_raw_read (regcache, regnum++, valbuf + i);
  168. }

  170. /* Function: xstormy16_store_return_value
  171.    Copy the function return value from VALBUF into the
  172.    proper location for a function return.
  173.    Called only in the context of the "return" command.  */

  175. static void
  176. ‌xstormy16_store_return_value (struct type *type, struct regcache *regcache,
  177.                               const gdb_byte *valbuf)
  178. {
  179.   if (TYPE_LENGTH (type) == 1)
  180.     {
  181.       /* Add leading zeros to the value.  */
  182.       gdb_byte buf[xstormy16_reg_size];
  183.       memset (buf, 0, xstormy16_reg_size);
  184.       memcpy (buf, valbuf, 1);
  185.       regcache_raw_write (regcache, E_1ST_ARG_REGNUM, buf);
  186.     }
  187.   else
  188.     {
  189.       int len = TYPE_LENGTH (type);
  190.       int i, regnum = E_1ST_ARG_REGNUM;

  192.       for (i = 0; i < len; i += xstormy16_reg_size)
  193.         regcache_raw_write (regcache, regnum++, valbuf + i);
  194.     }
  195. }

  197. static enum return_value_convention
  198. ‌xstormy16_return_value (struct gdbarch *gdbarch, struct value *function,
  199.                         struct type *type, struct regcache *regcache,
  200.                         gdb_byte *readbuf, const gdb_byte *writebuf)
  201. {
  202.   if (xstormy16_use_struct_convention (type))
  203.     return RETURN_VALUE_STRUCT_CONVENTION;
  204.   if (writebuf)
  205.     xstormy16_store_return_value (type, regcache, writebuf);
  206.   else if (readbuf)
  207.     xstormy16_extract_return_value (type, regcache, readbuf);
  208.   return RETURN_VALUE_REGISTER_CONVENTION;
  209. }

  211. static CORE_ADDR
  212. ‌xstormy16_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
  213. {
  214.   if (addr & 1)
  215.     ++addr;
  216.   return addr;
  217. }

  219. /* Function: xstormy16_push_dummy_call
  220.    Setup the function arguments for GDB to call a function in the inferior.
  221.    Called only in the context of a target function call from the debugger.
  222.    Returns the value of the SP register after the args are pushed.  */

  224. static CORE_ADDR
  225. ‌xstormy16_push_dummy_call (struct gdbarch *gdbarch,
  226.                            struct value *function,
  227.                            struct regcache *regcache,
  228.                            CORE_ADDR bp_addr, int nargs,
  229.                            struct value **args,
  230.                            CORE_ADDR sp, int struct_return,
  231.                            CORE_ADDR struct_addr)
  232. {
  233.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  234.   CORE_ADDR stack_dest = sp;
  235.   int argreg = E_1ST_ARG_REGNUM;
  236.   int i, j;
  237.   int typelen, slacklen;
  238.   const gdb_byte *val;
  239.   gdb_byte buf[xstormy16_pc_size];

  241.   /* If struct_return is true, then the struct return address will
  242.      consume one argument-passing register.  */
  243.   if (struct_return)
  244.     {
  245.       regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr);
  246.       argreg++;
  247.     }

  249.   /* Arguments are passed in R2-R7 as they fit.  If an argument doesn't
  250.      fit in the remaining registers we're switching over to the stack.
  251.      No argument is put on stack partially and as soon as we switched
  252.      over to stack no further argument is put in a register even if it
  253.      would fit in the remaining unused registers.  */
  254.   for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
  255.     {
  256.       typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
  257.       if (typelen > E_MAX_RETTYPE_SIZE (argreg))
  258.         break;

  260.       /* Put argument into registers wordwise.  */
  261.       val = value_contents (args[i]);
  262.       for (j = 0; j < typelen; j += xstormy16_reg_size)
  263.         {
  264.           ULONGEST regval;
  265.           int size = (typelen - j == 1) ? 1 : xstormy16_reg_size;

  267.           regval = extract_unsigned_integer (val + j, size, byte_order);
  268.           regcache_cooked_write_unsigned (regcache, argreg++, regval);
  269.         }
  270.     }

  272.   /* Align SP */
  273.   stack_dest = xstormy16_frame_align (gdbarch, stack_dest);

  275.   /* Loop backwards through remaining arguments and push them on the stack,
  276.      wordaligned.  */
  277.   for (j = nargs - 1; j >= i; j--)
  278.     {
  279.       gdb_byte *val;
  280.       struct cleanup *back_to;
  281.       const gdb_byte *bytes = value_contents (args[j]);

  283.       typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
  284.       slacklen = typelen & 1;
  285.       val = xmalloc (typelen + slacklen);
  286.       back_to = make_cleanup (xfree, val);
  287.       memcpy (val, bytes, typelen);
  288.       memset (val + typelen, 0, slacklen);

  290.       /* Now write this data to the stack.  The stack grows upwards.  */
  291.       write_memory (stack_dest, val, typelen + slacklen);
  292.       stack_dest += typelen + slacklen;
  293.       do_cleanups (back_to);
  294.     }

  296.   store_unsigned_integer (buf, xstormy16_pc_size, byte_order, bp_addr);
  297.   write_memory (stack_dest, buf, xstormy16_pc_size);
  298.   stack_dest += xstormy16_pc_size;

  300.   /* Update stack pointer.  */
  301.   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest);

  303.   /* Return the new stack pointer minus the return address slot since
  304.      that's what DWARF2/GCC uses as the frame's CFA.  */
  305.   return stack_dest - xstormy16_pc_size;
  306. }

  308. /* Function: xstormy16_scan_prologue
  309.    Decode the instructions within the given address range.
  310.    Decide when we must have reached the end of the function prologue.
  311.    If a frame_info pointer is provided, fill in its saved_regs etc.

  313.    Returns the address of the first instruction after the prologue.  */

  315. static CORE_ADDR
  316. ‌xstormy16_analyze_prologue (struct gdbarch *gdbarch,
  317.                             CORE_ADDR start_addr, CORE_ADDR end_addr,
  318.                             struct xstormy16_frame_cache *cache,
  319.                             struct frame_info *this_frame)
  320. {
  321.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  322.   CORE_ADDR next_addr;
  323.   ULONGEST inst, inst2;
  324.   LONGEST offset;
  325.   int regnum;

  327.   /* Initialize framesize with size of PC put on stack by CALLF inst.  */
  328.   cache->saved_regs[E_PC_REGNUM] = 0;
  329.   cache->framesize = xstormy16_pc_size;

  331.   if (start_addr >= end_addr)
  332.     return end_addr;

  334.   for (next_addr = start_addr;
  335.        next_addr < end_addr; next_addr += xstormy16_inst_size)
  336.     {
  337.       inst = read_memory_unsigned_integer (next_addr,
  338.                                            xstormy16_inst_size, byte_order);
  339.       inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
  340.                                             xstormy16_inst_size, byte_order);

  342.       if (inst >= 0x0082 && inst <= 0x008d)        /* push r2 .. push r13 */
  343.         {
  344.           regnum = inst & 0x000f;
  345.           cache->saved_regs[regnum] = cache->framesize;
  346.           cache->framesize += xstormy16_reg_size;
  347.         }

  349.       /* Optional stack allocation for args and local vars <= 4 byte.  */
  350.       else if (inst == 0x301f || inst == 0x303f)       /* inc r15, #0x1/#0x3 */
  351.         {
  352.           cache->framesize += ((inst & 0x0030) >> 4) + 1;
  353.         }

  355.       /* optional stack allocation for args and local vars > 4 && < 16 byte */
  356.       else if ((inst & 0xff0f) == 0x510f)        /* 51Hf   add r15, #0xH */
  357.         {
  358.           cache->framesize += (inst & 0x00f0) >> 4;
  359.         }

  361.       /* Optional stack allocation for args and local vars >= 16 byte.  */
  362.       else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
  363.         {
  364.           cache->framesize += inst2;
  365.           next_addr += xstormy16_inst_size;
  366.         }

  368.       else if (inst == 0x46fd)        /* mov r13, r15 */
  369.         {
  370.           cache->uses_fp = 1;
  371.         }

  373.       /* optional copying of args in r2-r7 to r10-r13.  */
  374.       /* Probably only in optimized case but legal action for prologue.  */
  375.       else if ((inst & 0xff00) == 0x4600        /* 46SD   mov rD, rS */
  376.                && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
  377.                && (inst & 0x000f) >= 0x000a && (inst & 0x000f) <= 0x000d)
  378.         ;

  380.       /* Optional copying of args in r2-r7 to stack.  */
  381.       /* 72DS HHHH   mov.b (rD, 0xHHHH), r(S-8)
  382.          (bit3 always 1, bit2-0 = reg) */
  383.       /* 73DS HHHH   mov.w (rD, 0xHHHH), r(S-8) */
  384.       else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
  385.         {
  386.           regnum = inst & 0x0007;
  387.           /* Only 12 of 16 bits of the argument are used for the
  388.              signed offset.  */
  389.           offset = (LONGEST) (inst2 & 0x0fff);
  390.           if (offset & 0x0800)
  391.             offset -= 0x1000;

  393.           cache->saved_regs[regnum] = cache->framesize + offset;
  394.           next_addr += xstormy16_inst_size;
  395.         }

  397.       else                        /* Not a prologue instruction.  */
  398.         break;
  399.     }

  401.   return next_addr;
  402. }

  404. /* Function: xstormy16_skip_prologue
  405.    If the input address is in a function prologue,
  406.    returns the address of the end of the prologue;
  407.    else returns the input address.

  409.    Note: the input address is likely to be the function start,
  410.    since this function is mainly used for advancing a breakpoint
  411.    to the first line, or stepping to the first line when we have
  412.    stepped into a function call.  */

  414. static CORE_ADDR
  415. ‌xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
  416. {
  417.   CORE_ADDR func_addr = 0, func_end = 0;
  418.   const char *func_name;

  420.   if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
  421.     {
  422.       struct symtab_and_line sal;
  423.       struct symbol *sym;
  424.       struct xstormy16_frame_cache cache;
  425.       CORE_ADDR plg_end;

  427.       memset (&cache, 0, sizeof cache);

  429.       /* Don't trust line number debug info in frameless functions.  */
  430.       plg_end = xstormy16_analyze_prologue (gdbarch, func_addr, func_end,
  431.                                             &cache, NULL);
  432.       if (!cache.uses_fp)
  433.         return plg_end;

  435.       /* Found a function.  */
  436.       sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
  437.       /* Don't use line number debug info for assembly source files.  */
  438.       if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
  439.         {
  440.           sal = find_pc_line (func_addr, 0);
  441.           if (sal.end && sal.end < func_end)
  442.             {
  443.               /* Found a line number, use it as end of prologue.  */
  444.               return sal.end;
  445.             }
  446.         }
  447.       /* No useable line symbol.  Use result of prologue parsing method.  */
  448.       return plg_end;
  449.     }

  451.   /* No function symbol -- just return the PC.  */

  453.   return (CORE_ADDR) pc;
  454. }

  456. /* The epilogue is defined here as the area at the end of a function,
  457.    either on the `ret' instruction itself or after an instruction which
  458.    destroys the function's stack frame.  */
  459. static int
  460. ‌xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
  461. {
  462.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  463.   CORE_ADDR func_addr = 0, func_end = 0;

  465.   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
  466.     {
  467.       ULONGEST inst, inst2;
  468.       CORE_ADDR addr = func_end - xstormy16_inst_size;

  470.       /* The Xstormy16 epilogue is max. 14 bytes long.  */
  471.       if (pc < func_end - 7 * xstormy16_inst_size)
  472.         return 0;

  474.       /* Check if we're on a `ret' instruction.  Otherwise it's
  475.          too dangerous to proceed.  */
  476.       inst = read_memory_unsigned_integer (addr,
  477.                                            xstormy16_inst_size, byte_order);
  478.       if (inst != 0x0003)
  479.         return 0;

  481.       while ((addr -= xstormy16_inst_size) >= func_addr)
  482.         {
  483.           inst = read_memory_unsigned_integer (addr,
  484.                                                xstormy16_inst_size,
  485.                                                byte_order);
  486.           if (inst >= 0x009a && inst <= 0x009d)        /* pop r10...r13 */
  487.             continue;
  488.           if (inst == 0x305f || inst == 0x307f)        /* dec r15, #0x1/#0x3 */
  489.             break;
  490.           inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
  491.                                                 xstormy16_inst_size,
  492.                                                 byte_order);
  493.           if (inst2 == 0x314f && inst >= 0x8000)      /* add r15, neg. value */
  494.             {
  495.               addr -= xstormy16_inst_size;
  496.               break;
  497.             }
  498.           return 0;
  499.         }
  500.       if (pc > addr)
  501.         return 1;
  502.     }
  503.   return 0;
  504. }

  506. static const unsigned char *
  507. ‌xstormy16_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
  508.                               int *lenptr)
  509. {
  510.   static unsigned char breakpoint[] = { 0x06, 0x0 };
  511.   *lenptr = sizeof (breakpoint);
  512.   return breakpoint;
  513. }

  515. /* Given a pointer to a jump table entry, return the address
  516.    of the function it jumps to.  Return 0 if not found.  */
  517. static CORE_ADDR
  518. ‌xstormy16_resolve_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
  519. {
  520.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  521.   struct obj_section *faddr_sect = find_pc_section (faddr);

  523.   if (faddr_sect)
  524.     {
  525.       LONGEST inst, inst2, addr;
  526.       gdb_byte buf[2 * xstormy16_inst_size];

  528.       /* Return faddr if it's not pointing into the jump table.  */
  529.       if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
  530.         return faddr;

  532.       if (!target_read_memory (faddr, buf, sizeof buf))
  533.         {
  534.           inst = extract_unsigned_integer (buf,
  535.                                            xstormy16_inst_size, byte_order);
  536.           inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
  537.                                             xstormy16_inst_size, byte_order);
  538.           addr = inst2 << 8 | (inst & 0xff);
  539.           return addr;
  540.         }
  541.     }
  542.   return 0;
  543. }

  545. /* Given a function's address, attempt to find (and return) the
  546.    address of the corresponding jump table entry.  Return 0 if
  547.    not found.  */
  548. static CORE_ADDR
  549. ‌xstormy16_find_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
  550. {
  551.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  552.   struct obj_section *faddr_sect = find_pc_section (faddr);

  554.   if (faddr_sect)
  555.     {
  556.       struct obj_section *osect;

  558.       /* Return faddr if it's already a pointer to a jump table entry.  */
  559.       if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
  560.         return faddr;

  562.       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
  563.       {
  564.         if (!strcmp (osect->the_bfd_section->name, ".plt"))
  565.           break;
  566.       }

  568.       if (osect < faddr_sect->objfile->sections_end)
  569.         {
  570.           CORE_ADDR addr, endaddr;

  572.           addr = obj_section_addr (osect);
  573.           endaddr = obj_section_endaddr (osect);

  575.           for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
  576.             {
  577.               LONGEST inst, inst2, faddr2;
  578.               gdb_byte buf[2 * xstormy16_inst_size];

  580.               if (target_read_memory (addr, buf, sizeof buf))
  581.                 return 0;
  582.               inst = extract_unsigned_integer (buf,
  583.                                                xstormy16_inst_size,
  584.                                                byte_order);
  585.               inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
  586.                                                 xstormy16_inst_size,
  587.                                                 byte_order);
  588.               faddr2 = inst2 << 8 | (inst & 0xff);
  589.               if (faddr == faddr2)
  590.                 return addr;
  591.             }
  592.         }
  593.     }
  594.   return 0;
  595. }

  597. static CORE_ADDR
  598. ‌xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
  599. {
  600.   struct gdbarch *gdbarch = get_frame_arch (frame);
  601.   CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);

  603.   if (tmp && tmp != pc)
  604.     return tmp;
  605.   return 0;
  606. }

  608. /* Function pointers are 16 bit.  The address space is 24 bit, using
  609.    32 bit addresses.  Pointers to functions on the XStormy16 are implemented
  610.    by using 16 bit pointers, which are either direct pointers in case the
  611.    function begins below 0x10000, or indirect pointers into a jump table.
  612.    The next two functions convert 16 bit pointers into 24 (32) bit addresses
  613.    and vice versa.  */

  615. static CORE_ADDR
  616. ‌xstormy16_pointer_to_address (struct gdbarch *gdbarch,
  617.                               struct type *type, const gdb_byte *buf)
  618. {
  619.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  620.   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
  621.   CORE_ADDR addr
  622.     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);

  624.   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
  625.     {
  626.       CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (gdbarch, addr);
  627.       if (addr2)
  628.         addr = addr2;
  629.     }

  631.   return addr;
  632. }

  634. static void
  635. ‌xstormy16_address_to_pointer (struct gdbarch *gdbarch,
  636.                               struct type *type, gdb_byte *buf, CORE_ADDR addr)
  637. {
  638.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  639.   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));

  641.   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
  642.     {
  643.       CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (gdbarch, addr);
  644.       if (addr2)
  645.         addr = addr2;
  646.     }
  647.   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
  648. }

  650. static struct xstormy16_frame_cache *
  651. ‌xstormy16_alloc_frame_cache (void)
  652. {
  653.   struct xstormy16_frame_cache *cache;
  654.   int i;

  656.   cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache);

  658.   cache->base = 0;
  659.   cache->saved_sp = 0;
  660.   cache->pc = 0;
  661.   cache->uses_fp = 0;
  662.   cache->framesize = 0;
  663.   for (i = 0; i < E_NUM_REGS; ++i)
  664.     cache->saved_regs[i] = REG_UNAVAIL;

  666.   return cache;
  667. }

  669. static struct xstormy16_frame_cache *
  670. ‌xstormy16_frame_cache (struct frame_info *this_frame, void **this_cache)
  671. {
  672.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  673.   struct xstormy16_frame_cache *cache;
  674.   CORE_ADDR current_pc;
  675.   int i;

  677.   if (*this_cache)
  678.     return *this_cache;

  680.   cache = xstormy16_alloc_frame_cache ();
  681.   *this_cache = cache;

  683.   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
  684.   if (cache->base == 0)
  685.     return cache;

  687.   cache->pc = get_frame_func (this_frame);
  688.   current_pc = get_frame_pc (this_frame);
  689.   if (cache->pc)
  690.     xstormy16_analyze_prologue (gdbarch, cache->pc, current_pc,
  691.                                 cache, this_frame);

  693.   if (!cache->uses_fp)
  694.     cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);

  696.   cache->saved_sp = cache->base - cache->framesize;

  698.   for (i = 0; i < E_NUM_REGS; ++i)
  699.     if (cache->saved_regs[i] != REG_UNAVAIL)
  700.       cache->saved_regs[i] += cache->saved_sp;

  702.   return cache;
  703. }

  705. static struct value *
  706. ‌xstormy16_frame_prev_register (struct frame_info *this_frame,
  707.                                void **this_cache, int regnum)
  708. {
  709.   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
  710.                                                                this_cache);
  711.   gdb_assert (regnum >= 0);

  713.   if (regnum == E_SP_REGNUM && cache->saved_sp)
  714.     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);

  716.   if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
  717.     return frame_unwind_got_memory (this_frame, regnum,
  718.                                     cache->saved_regs[regnum]);

  720.   return frame_unwind_got_register (this_frame, regnum, regnum);
  721. }

  723. static void
  724. ‌xstormy16_frame_this_id (struct frame_info *this_frame, void **this_cache,
  725.                          struct frame_id *this_id)
  726. {
  727.   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
  728.                                                                this_cache);

  730.   /* This marks the outermost frame.  */
  731.   if (cache->base == 0)
  732.     return;

  734.   *this_id = frame_id_build (cache->saved_sp, cache->pc);
  735. }

  737. static CORE_ADDR
  738. ‌xstormy16_frame_base_address (struct frame_info *this_frame, void **this_cache)
  739. {
  740.   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
  741.                                                                this_cache);
  742.   return cache->base;
  743. }

  745. ‌static const struct frame_unwind xstormy16_frame_unwind = {
  746.   NORMAL_FRAME,
  747.   default_frame_unwind_stop_reason,
  748.   xstormy16_frame_this_id,
  749.   xstormy16_frame_prev_register,
  750.   NULL,
  751.   default_frame_sniffer
  752. };

  754. ‌static const struct frame_base xstormy16_frame_base = {
  755.   &xstormy16_frame_unwind,
  756.   xstormy16_frame_base_address,
  757.   xstormy16_frame_base_address,
  758.   xstormy16_frame_base_address
  759. };

  761. static CORE_ADDR
  762. ‌xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
  763. {
  764.   return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
  765. }

  767. static CORE_ADDR
  768. ‌xstormy16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
  769. {
  770.   return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
  771. }

  773. static struct frame_id
  774. ‌xstormy16_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
  775. {
  776.   CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
  777.   return frame_id_build (sp, get_frame_pc (this_frame));
  778. }


  781. /* Function: xstormy16_gdbarch_init
  782.    Initializer function for the xstormy16 gdbarch vector.
  783.    Called by gdbarch.  Sets up the gdbarch vector(s) for this target.  */

  785. static struct gdbarch *
  786. ‌xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
  787. {
  788.   struct gdbarch *gdbarch;

  790.   /* find a candidate among the list of pre-declared architectures.  */
  791.   arches = gdbarch_list_lookup_by_info (arches, &info);
  792.   if (arches != NULL)
  793.     return (arches->gdbarch);

  795.   gdbarch = gdbarch_alloc (&info, NULL);

  797.   /*
  798.    * Basic register fields and methods, datatype sizes and stuff.
  799.    */

  801.   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
  802.   set_gdbarch_num_pseudo_regs (gdbarch, 0);
  803.   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
  804.   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
  805.   set_gdbarch_register_name (gdbarch, xstormy16_register_name);
  806.   set_gdbarch_register_type (gdbarch, xstormy16_register_type);

  808.   set_gdbarch_char_signed (gdbarch, 0);
  809.   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
  810.   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
  811.   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
  812.   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);

  814.   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
  815.   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
  816.   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);

  818.   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
  819.   set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
  820.   set_gdbarch_dwarf2_addr_size (gdbarch, 4);

  822.   set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
  823.   set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);

  825.   /* Stack grows up.  */
  826.   set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);

  828.   /*
  829.    * Frame Info
  830.    */
  831.   set_gdbarch_unwind_sp (gdbarch, xstormy16_unwind_sp);
  832.   set_gdbarch_unwind_pc (gdbarch, xstormy16_unwind_pc);
  833.   set_gdbarch_dummy_id (gdbarch, xstormy16_dummy_id);
  834.   set_gdbarch_frame_align (gdbarch, xstormy16_frame_align);
  835.   frame_base_set_default (gdbarch, &xstormy16_frame_base);

  837.   set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
  838.   set_gdbarch_in_function_epilogue_p (gdbarch,
  839.                                       xstormy16_in_function_epilogue_p);

  841.   /* These values and methods are used when gdb calls a target function.  */
  842.   set_gdbarch_push_dummy_call (gdbarch, xstormy16_push_dummy_call);
  843.   set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
  844.   set_gdbarch_return_value (gdbarch, xstormy16_return_value);

  846.   set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);

  848.   set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);

  850.   gdbarch_init_osabi (info, gdbarch);

  852.   dwarf2_append_unwinders (gdbarch);
  853.   frame_unwind_append_unwinder (gdbarch, &xstormy16_frame_unwind);

  855.   return gdbarch;
  856. }

  858. /* Function: _initialize_xstormy16_tdep
  859.    Initializer function for the Sanyo Xstormy16a module.
  860.    Called by gdb at start-up.  */

  862. /* -Wmissing-prototypes */
  863. extern initialize_file_ftype _initialize_xstormy16_tdep;

  865. void
  866. ‌_initialize_xstormy16_tdep (void)
  867. {
  868.   register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
  869. }