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