gdb/xstormy16-tdep.c

   1 /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
   2
   3    Copyright (C) 2001-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   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.
  11
  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.
  16
  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/>.  */
  19
  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"
  38
  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 };
  67
  68 /* Use an invalid address value as 'not available' marker.  */
  69 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
  70
  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 };
  81
  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 };
  89
  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)
  93
  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 };
  99
 100 /* Function: xstormy16_register_name
 101    Returns the name of the standard Xstormy16 register N.  */
 102
 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   };
 111
 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];
 118
 119 }
 120
 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 }
 129
 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.  */
 133
 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 }
 141
 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.  */
 147
 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 }
 154
 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.  */
 158
 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;
 165
 166   for (i = 0; i < len; i += xstormy16_reg_size)
 167     regcache_raw_read (regcache, regnum++, valbuf + i);
 168 }
 169
 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.  */
 174
 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;
 191
 192       for (i = 0; i < len; i += xstormy16_reg_size)
 193         regcache_raw_write (regcache, regnum++, valbuf + i);
 194     }
 195 }
 196
 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 }
 210
 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 }
 218
 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.  */
 223
 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];
 240
 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     }
 248
 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;
 259
 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;
 266
 267           regval = extract_unsigned_integer (val + j, size, byte_order);
 268           regcache_cooked_write_unsigned (regcache, argreg++, regval);
 269         }
 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       gdb_byte *val;
 280       struct cleanup *back_to;
 281       const gdb_byte *bytes = value_contents (args[j]);
 282
 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);
 289
 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     }
 295
 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;
 299
 300   /* Update stack pointer.  */
 301   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest);
 302
 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 }
 307
 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.
 312
 313    Returns the address of the first instruction after the prologue.  */
 314
 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;
 326
 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;
 330
 331   if (start_addr >= end_addr)
 332     return end_addr;
 333
 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);
 341
 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         }
 348
 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         }
 354
 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         }
 360
 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         }
 367
 368       else if (inst == 0x46fd)  /* mov r13, r15 */
 369         {
 370           cache->uses_fp = 1;
 371         }
 372
 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         ;
 379
 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;
 392
 393           cache->saved_regs[regnum] = cache->framesize + offset;
 394           next_addr += xstormy16_inst_size;
 395         }
 396
 397       else                      /* Not a prologue instruction.  */
 398         break;
 399     }
 400
 401   return next_addr;
 402 }
 403
 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.
 408
 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.  */
 413
 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;
 419
 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;
 426
 427       memset (&cache, 0, sizeof cache);
 428
 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;
 434
 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     }
 450
 451   /* No function symbol -- just return the PC.  */
 452
 453   return (CORE_ADDR) pc;
 454 }
 455
 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;
 464
 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;
 469
 470       /* The Xstormy16 epilogue is max. 14 bytes long.  */
 471       if (pc < func_end - 7 * xstormy16_inst_size)
 472         return 0;
 473
 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;
 480
 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 }
 505
 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 }
 514
 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);
 522
 523   if (faddr_sect)
 524     {
 525       LONGEST inst, inst2, addr;
 526       gdb_byte buf[2 * xstormy16_inst_size];
 527
 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;
 531
 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 }
 544
 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);
 553
 554   if (faddr_sect)
 555     {
 556       struct obj_section *osect;
 557
 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;
 561
 562       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
 563       {
 564         if (!strcmp (osect->the_bfd_section->name, ".plt"))
 565           break;
 566       }
 567
 568       if (osect < faddr_sect->objfile->sections_end)
 569         {
 570           CORE_ADDR addr, endaddr;
 571
 572           addr = obj_section_addr (osect);
 573           endaddr = obj_section_endaddr (osect);
 574
 575           for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
 576             {
 577               LONGEST inst, inst2, faddr2;
 578               gdb_byte buf[2 * xstormy16_inst_size];
 579
 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 }
 596
 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);
 602
 603   if (tmp && tmp != pc)
 604     return tmp;
 605   return 0;
 606 }
 607
 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.  */
 614
 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);
 623
 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     }
 630
 631   return addr;
 632 }
 633
 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));
 640
 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 }
 649
 650 static struct xstormy16_frame_cache *
 651 xstormy16_alloc_frame_cache (void)
 652 {
 653   struct xstormy16_frame_cache *cache;
 654   int i;
 655
 656   cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache);
 657
 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;
 665
 666   return cache;
 667 }
 668
 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;
 676
 677   if (*this_cache)
 678     return *this_cache;
 679
 680   cache = xstormy16_alloc_frame_cache ();
 681   *this_cache = cache;
 682
 683   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
 684   if (cache->base == 0)
 685     return cache;
 686
 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);
 692
 693   if (!cache->uses_fp)
 694     cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 695
 696   cache->saved_sp = cache->base - cache->framesize;
 697
 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;
 701
 702   return cache;
 703 }
 704
 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);
 712
 713   if (regnum == E_SP_REGNUM && cache->saved_sp)
 714     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 715
 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]);
 719
 720   return frame_unwind_got_register (this_frame, regnum, regnum);
 721 }
 722
 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);
 729
 730   /* This marks the outermost frame.  */
 731   if (cache->base == 0)
 732     return;
 733
 734   *this_id = frame_id_build (cache->saved_sp, cache->pc);
 735 }
 736
 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 }
 744
 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 };
 753
 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 };
 760
 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 }
 766
 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 }
 772
 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 }
 779
 780
 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.  */
 784
 785 static struct gdbarch *
 786 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 787 {
 788   struct gdbarch *gdbarch;
 789
 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);
 794
 795   gdbarch = gdbarch_alloc (&info, NULL);
 796
 797   /*
 798    * Basic register fields and methods, datatype sizes and stuff.
 799    */
 800
 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);
 807
 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);
 813
 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);
 817
 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);
 821
 822   set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
 823   set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
 824
 825   /* Stack grows up.  */
 826   set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
 827
 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);
 836
 837   set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
 838   set_gdbarch_in_function_epilogue_p (gdbarch,
 839                                       xstormy16_in_function_epilogue_p);
 840
 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);
 845
 846   set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
 847
 848   set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
 849
 850   gdbarch_init_osabi (info, gdbarch);
 851
 852   dwarf2_append_unwinders (gdbarch);
 853   frame_unwind_append_unwinder (gdbarch, &xstormy16_frame_unwind);
 854
 855   return gdbarch;
 856 }
 857
 858 /* Function: _initialize_xstormy16_tdep
 859    Initializer function for the Sanyo Xstormy16a module.
 860    Called by gdb at start-up.  */
 861
 862 /* -Wmissing-prototypes */
 863 extern initialize_file_ftype _initialize_xstormy16_tdep;
 864
 865 void
 866 _initialize_xstormy16_tdep (void)
 867 {
 868   register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
 869 }