gdb/xstormy16-tdep.c

   1 /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
   2
   3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "frame-base.h"
  24 #include "frame-unwind.h"
  25 #include "dwarf2-frame.h"
  26 #include "symtab.h"
  27 #include "gdbtypes.h"
  28 #include "gdbcmd.h"
  29 #include "gdbcore.h"
  30 #include "value.h"
  31 #include "dis-asm.h"
  32 #include "inferior.h"
  33 #include "gdb_string.h"
  34 #include "gdb_assert.h"
  35 #include "arch-utils.h"
  36 #include "floatformat.h"
  37 #include "regcache.h"
  38 #include "doublest.h"
  39 #include "osabi.h"
  40 #include "objfiles.h"
  41
  42 enum gdb_regnum
  43 {
  44   /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
  45      Functions will return their values in register R2-R7 as they fit.
  46      Otherwise a hidden pointer to an big enough area is given as argument
  47      to the function in r2. Further arguments are beginning in r3 then.
  48      R13 is used as frame pointer when GCC compiles w/o optimization
  49      R14 is used as "PSW", displaying the CPU status.
  50      R15 is used implicitely as stack pointer. */
  51   E_R0_REGNUM,
  52   E_R1_REGNUM,
  53   E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM,
  54   E_R3_REGNUM,
  55   E_R4_REGNUM,
  56   E_R5_REGNUM,
  57   E_R6_REGNUM,
  58   E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM,
  59   E_R8_REGNUM,
  60   E_R9_REGNUM,
  61   E_R10_REGNUM,
  62   E_R11_REGNUM,
  63   E_R12_REGNUM,
  64   E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM,
  65   E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM,
  66   E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM,
  67   E_PC_REGNUM,
  68   E_NUM_REGS
  69 };
  70
  71 /* Use an invalid address value as 'not available' marker.  */
  72 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
  73
  74 struct xstormy16_frame_cache
  75 {
  76   /* Base address.  */
  77   CORE_ADDR base;
  78   CORE_ADDR pc;
  79   LONGEST framesize;
  80   int uses_fp;
  81   CORE_ADDR saved_regs[E_NUM_REGS];
  82   CORE_ADDR saved_sp;
  83 };
  84
  85 /* Size of instructions, registers, etc. */
  86 enum
  87 {
  88   xstormy16_inst_size = 2,
  89   xstormy16_reg_size = 2,
  90   xstormy16_pc_size = 4
  91 };
  92
  93 /* Size of return datatype which fits into the remaining return registers. */
  94 #define E_MAX_RETTYPE_SIZE(regnum)      ((E_LST_ARG_REGNUM - (regnum) + 1) \
  95                                         * xstormy16_reg_size)
  96
  97 /* Size of return datatype which fits into all return registers. */
  98 enum
  99 {
 100   E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM)
 101 };
 102
 103 /* Function: xstormy16_register_name
 104    Returns the name of the standard Xstormy16 register N.  */
 105
 106 static const char *
 107 xstormy16_register_name (struct gdbarch *gdbarch, int regnum)
 108 {
 109   static char *register_names[] = {
 110     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 111     "r8", "r9", "r10", "r11", "r12", "r13",
 112     "psw", "sp", "pc"
 113   };
 114
 115   if (regnum < 0 || regnum >= E_NUM_REGS)
 116     internal_error (__FILE__, __LINE__,
 117                     _("xstormy16_register_name: illegal register number %d"),
 118                     regnum);
 119   else
 120     return register_names[regnum];
 121
 122 }
 123
 124 static struct type *
 125 xstormy16_register_type (struct gdbarch *gdbarch, int regnum)
 126 {
 127   if (regnum == E_PC_REGNUM)
 128     return builtin_type_uint32;
 129   else
 130     return builtin_type_uint16;
 131 }
 132
 133 /* Function: xstormy16_type_is_scalar
 134    Makes the decision if a given type is a scalar types.  Scalar
 135    types are returned in the registers r2-r7 as they fit.  */
 136
 137 static int
 138 xstormy16_type_is_scalar (struct type *t)
 139 {
 140   return (TYPE_CODE(t) != TYPE_CODE_STRUCT
 141           && TYPE_CODE(t) != TYPE_CODE_UNION
 142           && TYPE_CODE(t) != TYPE_CODE_ARRAY);
 143 }
 144
 145 /* Function: xstormy16_use_struct_convention
 146    Returns non-zero if the given struct type will be returned using
 147    a special convention, rather than the normal function return method.
 148    7sed in the contexts of the "return" command, and of
 149    target function calls from the debugger.  */
 150
 151 static int
 152 xstormy16_use_struct_convention (struct type *type)
 153 {
 154   return !xstormy16_type_is_scalar (type)
 155          || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
 156 }
 157
 158 /* Function: xstormy16_extract_return_value
 159    Find a function's return value in the appropriate registers (in
 160    regbuf), and copy it into valbuf.  */
 161
 162 static void
 163 xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
 164                                 void *valbuf)
 165 {
 166   int len = TYPE_LENGTH (type);
 167   int i, regnum = E_1ST_ARG_REGNUM;
 168
 169   for (i = 0; i < len; i += xstormy16_reg_size)
 170     regcache_raw_read (regcache, regnum++, (char *) valbuf + i);
 171 }
 172
 173 /* Function: xstormy16_store_return_value
 174    Copy the function return value from VALBUF into the
 175    proper location for a function return.
 176    Called only in the context of the "return" command.  */
 177
 178 static void
 179 xstormy16_store_return_value (struct type *type, struct regcache *regcache,
 180                               const void *valbuf)
 181 {
 182   if (TYPE_LENGTH (type) == 1)
 183     {
 184       /* Add leading zeros to the value. */
 185       char buf[xstormy16_reg_size];
 186       memset (buf, 0, xstormy16_reg_size);
 187       memcpy (buf, valbuf, 1);
 188       regcache_raw_write (regcache, E_1ST_ARG_REGNUM, buf);
 189     }
 190   else
 191     {
 192       int len = TYPE_LENGTH (type);
 193       int i, regnum = E_1ST_ARG_REGNUM;
 194
 195       for (i = 0; i < len; i += xstormy16_reg_size)
 196         regcache_raw_write (regcache, regnum++, (char *) valbuf + i);
 197     }
 198 }
 199
 200 static enum return_value_convention
 201 xstormy16_return_value (struct gdbarch *gdbarch, struct type *func_type,
 202                         struct type *type, struct regcache *regcache,
 203                         gdb_byte *readbuf, const gdb_byte *writebuf)
 204 {
 205   if (xstormy16_use_struct_convention (type))
 206     return RETURN_VALUE_STRUCT_CONVENTION;
 207   if (writebuf)
 208     xstormy16_store_return_value (type, regcache, writebuf);
 209   else if (readbuf)
 210     xstormy16_extract_return_value (type, regcache, readbuf);
 211   return RETURN_VALUE_REGISTER_CONVENTION;
 212 }
 213
 214 static CORE_ADDR
 215 xstormy16_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
 216 {
 217   if (addr & 1)
 218     ++addr;
 219   return addr;
 220 }
 221
 222 /* Function: xstormy16_push_dummy_call
 223    Setup the function arguments for GDB to call a function in the inferior.
 224    Called only in the context of a target function call from the debugger.
 225    Returns the value of the SP register after the args are pushed.  */
 226
 227 static CORE_ADDR
 228 xstormy16_push_dummy_call (struct gdbarch *gdbarch,
 229                            struct value *function,
 230                            struct regcache *regcache,
 231                            CORE_ADDR bp_addr, int nargs,
 232                            struct value **args,
 233                            CORE_ADDR sp, int struct_return,
 234                            CORE_ADDR struct_addr)
 235 {
 236   CORE_ADDR stack_dest = sp;
 237   int argreg = E_1ST_ARG_REGNUM;
 238   int i, j;
 239   int typelen, slacklen;
 240   const gdb_byte *val;
 241   char buf[xstormy16_pc_size];
 242
 243   /* If struct_return is true, then the struct return address will
 244      consume one argument-passing register.  */
 245   if (struct_return)
 246     {
 247       regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr);
 248       argreg++;
 249     }
 250
 251   /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
 252      fit in the remaining registers we're switching over to the stack.
 253      No argument is put on stack partially and as soon as we switched
 254      over to stack no further argument is put in a register even if it
 255      would fit in the remaining unused registers.  */
 256   for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
 257     {
 258       typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
 259       if (typelen > E_MAX_RETTYPE_SIZE (argreg))
 260         break;
 261
 262       /* Put argument into registers wordwise. */
 263       val = value_contents (args[i]);
 264       for (j = 0; j < typelen; j += xstormy16_reg_size)
 265         regcache_cooked_write_unsigned (regcache, argreg++,
 266                         extract_unsigned_integer (val + j,
 267                                                   typelen - j ==
 268                                                   1 ? 1 :
 269                                                   xstormy16_reg_size));
 270     }
 271
 272   /* Align SP */
 273   stack_dest = xstormy16_frame_align (gdbarch, stack_dest);
 274
 275   /* Loop backwards through remaining arguments and push them on the stack,
 276      wordaligned.  */
 277   for (j = nargs - 1; j >= i; j--)
 278     {
 279       char *val;
 280
 281       typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
 282       slacklen = typelen & 1;
 283       val = alloca (typelen + slacklen);
 284       memcpy (val, value_contents (args[j]), typelen);
 285       memset (val + typelen, 0, slacklen);
 286
 287       /* Now write this data to the stack. The stack grows upwards. */
 288       write_memory (stack_dest, val, typelen + slacklen);
 289       stack_dest += typelen + slacklen;
 290     }
 291
 292   store_unsigned_integer (buf, xstormy16_pc_size, bp_addr);
 293   write_memory (stack_dest, buf, xstormy16_pc_size);
 294   stack_dest += xstormy16_pc_size;
 295
 296   /* Update stack pointer.  */
 297   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest);
 298
 299   /* Return the new stack pointer minus the return address slot since
 300      that's what DWARF2/GCC uses as the frame's CFA.  */
 301   return stack_dest - xstormy16_pc_size;
 302 }
 303
 304 /* Function: xstormy16_scan_prologue
 305    Decode the instructions within the given address range.
 306    Decide when we must have reached the end of the function prologue.
 307    If a frame_info pointer is provided, fill in its saved_regs etc.
 308
 309    Returns the address of the first instruction after the prologue.  */
 310
 311 static CORE_ADDR
 312 xstormy16_analyze_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
 313                             struct xstormy16_frame_cache *cache,
 314                             struct frame_info *this_frame)
 315 {
 316   CORE_ADDR next_addr;
 317   ULONGEST inst, inst2;
 318   LONGEST offset;
 319   int regnum;
 320
 321   /* Initialize framesize with size of PC put on stack by CALLF inst. */
 322   cache->saved_regs[E_PC_REGNUM] = 0;
 323   cache->framesize = xstormy16_pc_size;
 324
 325   if (start_addr >= end_addr)
 326     return end_addr;
 327
 328   for (next_addr = start_addr;
 329        next_addr < end_addr; next_addr += xstormy16_inst_size)
 330     {
 331       inst = read_memory_unsigned_integer (next_addr, xstormy16_inst_size);
 332       inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
 333                                             xstormy16_inst_size);
 334
 335       if (inst >= 0x0082 && inst <= 0x008d)     /* push r2 .. push r13 */
 336         {
 337           regnum = inst & 0x000f;
 338           cache->saved_regs[regnum] = cache->framesize;
 339           cache->framesize += xstormy16_reg_size;
 340         }
 341
 342       /* optional stack allocation for args and local vars <= 4 byte */
 343       else if (inst == 0x301f || inst == 0x303f)        /* inc r15, #0x1/#0x3 */
 344         {
 345           cache->framesize += ((inst & 0x0030) >> 4) + 1;
 346         }
 347
 348       /* optional stack allocation for args and local vars > 4 && < 16 byte */
 349       else if ((inst & 0xff0f) == 0x510f)       /* 51Hf   add r15, #0xH */
 350         {
 351           cache->framesize += (inst & 0x00f0) >> 4;
 352         }
 353
 354       /* optional stack allocation for args and local vars >= 16 byte */
 355       else if (inst == 0x314f && inst2 >= 0x0010)       /* 314f HHHH  add r15, #0xH */
 356         {
 357           cache->framesize += inst2;
 358           next_addr += xstormy16_inst_size;
 359         }
 360
 361       else if (inst == 0x46fd)  /* mov r13, r15 */
 362         {
 363           cache->uses_fp = 1;
 364         }
 365
 366       /* optional copying of args in r2-r7 to r10-r13 */
 367       /* Probably only in optimized case but legal action for prologue */
 368       else if ((inst & 0xff00) == 0x4600        /* 46SD   mov rD, rS */
 369                && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
 370                && (inst & 0x000f) >= 0x00a0 && (inst & 0x000f) <= 0x000d)
 371         ;
 372
 373       /* optional copying of args in r2-r7 to stack */
 374       /* 72DS HHHH   mov.b (rD, 0xHHHH), r(S-8) (bit3 always 1, bit2-0 = reg) */
 375       /* 73DS HHHH   mov.w (rD, 0xHHHH), r(S-8) */
 376       else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
 377         {
 378           regnum = inst & 0x0007;
 379           /* Only 12 of 16 bits of the argument are used for the
 380              signed offset. */
 381           offset = (LONGEST) (inst2 & 0x0fff);
 382           if (offset & 0x0800)
 383             offset -= 0x1000;
 384
 385           cache->saved_regs[regnum] = cache->framesize + offset;
 386           next_addr += xstormy16_inst_size;
 387         }
 388
 389       else                      /* Not a prologue instruction. */
 390         break;
 391     }
 392
 393   return next_addr;
 394 }
 395
 396 /* Function: xstormy16_skip_prologue
 397    If the input address is in a function prologue,
 398    returns the address of the end of the prologue;
 399    else returns the input address.
 400
 401    Note: the input address is likely to be the function start,
 402    since this function is mainly used for advancing a breakpoint
 403    to the first line, or stepping to the first line when we have
 404    stepped into a function call.  */
 405
 406 static CORE_ADDR
 407 xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 408 {
 409   CORE_ADDR func_addr = 0, func_end = 0;
 410   char *func_name;
 411
 412   if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
 413     {
 414       struct symtab_and_line sal;
 415       struct symbol *sym;
 416       struct xstormy16_frame_cache cache;
 417       CORE_ADDR plg_end;
 418
 419       memset (&cache, 0, sizeof cache);
 420
 421       /* Don't trust line number debug info in frameless functions. */
 422       plg_end = xstormy16_analyze_prologue (func_addr, func_end, &cache, NULL);
 423       if (!cache.uses_fp)
 424         return plg_end;
 425
 426       /* Found a function.  */
 427       sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
 428       /* Don't use line number debug info for assembly source files. */
 429       if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
 430         {
 431           sal = find_pc_line (func_addr, 0);
 432           if (sal.end && sal.end < func_end)
 433             {
 434               /* Found a line number, use it as end of prologue.  */
 435               return sal.end;
 436             }
 437         }
 438       /* No useable line symbol.  Use result of prologue parsing method. */
 439       return plg_end;
 440     }
 441
 442   /* No function symbol -- just return the PC. */
 443
 444   return (CORE_ADDR) pc;
 445 }
 446
 447 /* The epilogue is defined here as the area at the end of a function,
 448    either on the `ret' instruction itself or after an instruction which
 449    destroys the function's stack frame. */
 450 static int
 451 xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 452 {
 453   CORE_ADDR func_addr = 0, func_end = 0;
 454
 455   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 456     {
 457       ULONGEST inst, inst2;
 458       CORE_ADDR addr = func_end - xstormy16_inst_size;
 459
 460       /* The Xstormy16 epilogue is max. 14 bytes long. */
 461       if (pc < func_end - 7 * xstormy16_inst_size)
 462         return 0;
 463
 464       /* Check if we're on a `ret' instruction.  Otherwise it's
 465          too dangerous to proceed. */
 466       inst = read_memory_unsigned_integer (addr, xstormy16_inst_size);
 467       if (inst != 0x0003)
 468         return 0;
 469
 470       while ((addr -= xstormy16_inst_size) >= func_addr)
 471         {
 472           inst = read_memory_unsigned_integer (addr, xstormy16_inst_size);
 473           if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
 474             continue;
 475           if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
 476             break;
 477           inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
 478                                                 xstormy16_inst_size);
 479           if (inst2 == 0x314f && inst >= 0x8000)        /* add r15, neg. value */
 480             {
 481               addr -= xstormy16_inst_size;
 482               break;
 483             }
 484           return 0;
 485         }
 486       if (pc > addr)
 487         return 1;
 488     }
 489   return 0;
 490 }
 491
 492 const static unsigned char *
 493 xstormy16_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 494                               int *lenptr)
 495 {
 496   static unsigned char breakpoint[] = { 0x06, 0x0 };
 497   *lenptr = sizeof (breakpoint);
 498   return breakpoint;
 499 }
 500
 501 /* Given a pointer to a jump table entry, return the address
 502    of the function it jumps to.  Return 0 if not found. */
 503 static CORE_ADDR
 504 xstormy16_resolve_jmp_table_entry (CORE_ADDR faddr)
 505 {
 506   struct obj_section *faddr_sect = find_pc_section (faddr);
 507
 508   if (faddr_sect)
 509     {
 510       LONGEST inst, inst2, addr;
 511       char buf[2 * xstormy16_inst_size];
 512
 513       /* Return faddr if it's not pointing into the jump table. */
 514       if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
 515         return faddr;
 516
 517       if (!target_read_memory (faddr, buf, sizeof buf))
 518         {
 519           inst = extract_unsigned_integer (buf, xstormy16_inst_size);
 520           inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
 521                                             xstormy16_inst_size);
 522           addr = inst2 << 8 | (inst & 0xff);
 523           return addr;
 524         }
 525     }
 526   return 0;
 527 }
 528
 529 /* Given a function's address, attempt to find (and return) the
 530    address of the corresponding jump table entry.  Return 0 if
 531    not found. */
 532 static CORE_ADDR
 533 xstormy16_find_jmp_table_entry (CORE_ADDR faddr)
 534 {
 535   struct obj_section *faddr_sect = find_pc_section (faddr);
 536
 537   if (faddr_sect)
 538     {
 539       struct obj_section *osect;
 540
 541       /* Return faddr if it's already a pointer to a jump table entry. */
 542       if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
 543         return faddr;
 544
 545       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
 546       {
 547         if (!strcmp (osect->the_bfd_section->name, ".plt"))
 548           break;
 549       }
 550
 551       if (osect < faddr_sect->objfile->sections_end)
 552         {
 553           CORE_ADDR addr, endaddr;
 554
 555           addr = obj_section_addr (osect);
 556           endaddr = obj_section_endaddr (osect);
 557
 558           for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
 559             {
 560               LONGEST inst, inst2, faddr2;
 561               char buf[2 * xstormy16_inst_size];
 562
 563               if (target_read_memory (addr, buf, sizeof buf))
 564                 return 0;
 565               inst = extract_unsigned_integer (buf, xstormy16_inst_size);
 566               inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
 567                                                 xstormy16_inst_size);
 568               faddr2 = inst2 << 8 | (inst & 0xff);
 569               if (faddr == faddr2)
 570                 return addr;
 571             }
 572         }
 573     }
 574   return 0;
 575 }
 576
 577 static CORE_ADDR
 578 xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 579 {
 580   CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (pc);
 581
 582   if (tmp && tmp != pc)
 583     return tmp;
 584   return 0;
 585 }
 586
 587 /* Function pointers are 16 bit.  The address space is 24 bit, using
 588    32 bit addresses.  Pointers to functions on the XStormy16 are implemented
 589    by using 16 bit pointers, which are either direct pointers in case the
 590    function begins below 0x10000, or indirect pointers into a jump table.
 591    The next two functions convert 16 bit pointers into 24 (32) bit addresses
 592    and vice versa.  */
 593
 594 static CORE_ADDR
 595 xstormy16_pointer_to_address (struct gdbarch *gdbarch,
 596                               struct type *type, const gdb_byte *buf)
 597 {
 598   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 599   CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
 600
 601   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
 602     {
 603       CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (addr);
 604       if (addr2)
 605         addr = addr2;
 606     }
 607
 608   return addr;
 609 }
 610
 611 static void
 612 xstormy16_address_to_pointer (struct gdbarch *gdbarch,
 613                               struct type *type, gdb_byte *buf, CORE_ADDR addr)
 614 {
 615   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 616
 617   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
 618     {
 619       CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (addr);
 620       if (addr2)
 621         addr = addr2;
 622     }
 623   store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
 624 }
 625
 626 static struct xstormy16_frame_cache *
 627 xstormy16_alloc_frame_cache (void)
 628 {
 629   struct xstormy16_frame_cache *cache;
 630   int i;
 631
 632   cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache);
 633
 634   cache->base = 0;
 635   cache->saved_sp = 0;
 636   cache->pc = 0;
 637   cache->uses_fp = 0;
 638   cache->framesize = 0;
 639   for (i = 0; i < E_NUM_REGS; ++i)
 640     cache->saved_regs[i] = REG_UNAVAIL;
 641
 642   return cache;
 643 }
 644
 645 static struct xstormy16_frame_cache *
 646 xstormy16_frame_cache (struct frame_info *this_frame, void **this_cache)
 647 {
 648   struct xstormy16_frame_cache *cache;
 649   CORE_ADDR current_pc;
 650   int i;
 651
 652   if (*this_cache)
 653     return *this_cache;
 654
 655   cache = xstormy16_alloc_frame_cache ();
 656   *this_cache = cache;
 657
 658   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
 659   if (cache->base == 0)
 660     return cache;
 661
 662   cache->pc = get_frame_func (this_frame);
 663   current_pc = get_frame_pc (this_frame);
 664   if (cache->pc)
 665     xstormy16_analyze_prologue (cache->pc, current_pc, cache, this_frame);
 666
 667   if (!cache->uses_fp)
 668     cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 669
 670   cache->saved_sp = cache->base - cache->framesize;
 671
 672   for (i = 0; i < E_NUM_REGS; ++i)
 673     if (cache->saved_regs[i] != REG_UNAVAIL)
 674       cache->saved_regs[i] += cache->saved_sp;
 675
 676   return cache;
 677 }
 678
 679 static struct value *
 680 xstormy16_frame_prev_register (struct frame_info *this_frame,
 681                                void **this_cache, int regnum)
 682 {
 683   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
 684                                                                this_cache);
 685   gdb_assert (regnum >= 0);
 686
 687   if (regnum == E_SP_REGNUM && cache->saved_sp)
 688     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 689
 690   if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
 691     return frame_unwind_got_memory (this_frame, regnum,
 692                                     cache->saved_regs[regnum]);
 693
 694   return frame_unwind_got_register (this_frame, regnum, regnum);
 695 }
 696
 697 static void
 698 xstormy16_frame_this_id (struct frame_info *this_frame, void **this_cache,
 699                          struct frame_id *this_id)
 700 {
 701   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
 702                                                                this_cache);
 703
 704   /* This marks the outermost frame.  */
 705   if (cache->base == 0)
 706     return;
 707
 708   *this_id = frame_id_build (cache->saved_sp, cache->pc);
 709 }
 710
 711 static CORE_ADDR
 712 xstormy16_frame_base_address (struct frame_info *this_frame, void **this_cache)
 713 {
 714   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
 715                                                                this_cache);
 716   return cache->base;
 717 }
 718
 719 static const struct frame_unwind xstormy16_frame_unwind = {
 720   NORMAL_FRAME,
 721   xstormy16_frame_this_id,
 722   xstormy16_frame_prev_register,
 723   NULL,
 724   default_frame_sniffer
 725 };
 726
 727 static const struct frame_base xstormy16_frame_base = {
 728   &xstormy16_frame_unwind,
 729   xstormy16_frame_base_address,
 730   xstormy16_frame_base_address,
 731   xstormy16_frame_base_address
 732 };
 733
 734 static CORE_ADDR
 735 xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 736 {
 737   return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
 738 }
 739
 740 static CORE_ADDR
 741 xstormy16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 742 {
 743   return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
 744 }
 745
 746 static struct frame_id
 747 xstormy16_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 748 {
 749   CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 750   return frame_id_build (sp, get_frame_pc (this_frame));
 751 }
 752
 753
 754 /* Function: xstormy16_gdbarch_init
 755    Initializer function for the xstormy16 gdbarch vector.
 756    Called by gdbarch.  Sets up the gdbarch vector(s) for this target. */
 757
 758 static struct gdbarch *
 759 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 760 {
 761   struct gdbarch *gdbarch;
 762
 763   /* find a candidate among the list of pre-declared architectures. */
 764   arches = gdbarch_list_lookup_by_info (arches, &info);
 765   if (arches != NULL)
 766     return (arches->gdbarch);
 767
 768   gdbarch = gdbarch_alloc (&info, NULL);
 769
 770   /*
 771    * Basic register fields and methods, datatype sizes and stuff.
 772    */
 773
 774   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
 775   set_gdbarch_num_pseudo_regs (gdbarch, 0);
 776   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
 777   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
 778   set_gdbarch_register_name (gdbarch, xstormy16_register_name);
 779   set_gdbarch_register_type (gdbarch, xstormy16_register_type);
 780
 781   set_gdbarch_char_signed (gdbarch, 0);
 782   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 783   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 784   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
 785   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 786
 787   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
 788   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 789   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 790
 791   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 792   set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
 793
 794   set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
 795   set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
 796
 797   /* Stack grows up. */
 798   set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
 799
 800   /*
 801    * Frame Info
 802    */
 803   set_gdbarch_unwind_sp (gdbarch, xstormy16_unwind_sp);
 804   set_gdbarch_unwind_pc (gdbarch, xstormy16_unwind_pc);
 805   set_gdbarch_dummy_id (gdbarch, xstormy16_dummy_id);
 806   set_gdbarch_frame_align (gdbarch, xstormy16_frame_align);
 807   frame_base_set_default (gdbarch, &xstormy16_frame_base);
 808
 809   set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
 810   set_gdbarch_in_function_epilogue_p (gdbarch,
 811                                       xstormy16_in_function_epilogue_p);
 812
 813   /* These values and methods are used when gdb calls a target function.  */
 814   set_gdbarch_push_dummy_call (gdbarch, xstormy16_push_dummy_call);
 815   set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
 816   set_gdbarch_return_value (gdbarch, xstormy16_return_value);
 817
 818   set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
 819
 820   set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
 821
 822   gdbarch_init_osabi (info, gdbarch);
 823
 824   dwarf2_append_unwinders (gdbarch);
 825   frame_unwind_append_unwinder (gdbarch, &xstormy16_frame_unwind);
 826
 827   return gdbarch;
 828 }
 829
 830 /* Function: _initialize_xstormy16_tdep
 831    Initializer function for the Sanyo Xstormy16a module.
 832    Called by gdb at start-up. */
 833
 834 extern initialize_file_ftype _initialize_xstormy16_tdep; /* -Wmissing-prototypes */
 835
 836 void
 837 _initialize_xstormy16_tdep (void)
 838 {
 839   register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
 840 }