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, 2010, 2011
   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 (gdbarch)->builtin_uint32;
 129   else
 130     return builtin_type (gdbarch)->builtin_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   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 237   CORE_ADDR stack_dest = sp;
 238   int argreg = E_1ST_ARG_REGNUM;
 239   int i, j;
 240   int typelen, slacklen;
 241   const gdb_byte *val;
 242   char buf[xstormy16_pc_size];
 243
 244   /* If struct_return is true, then the struct return address will
 245      consume one argument-passing register.  */
 246   if (struct_return)
 247     {
 248       regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr);
 249       argreg++;
 250     }
 251
 252   /* Arguments are passed in R2-R7 as they fit.  If an argument doesn't
 253      fit in the remaining registers we're switching over to the stack.
 254      No argument is put on stack partially and as soon as we switched
 255      over to stack no further argument is put in a register even if it
 256      would fit in the remaining unused registers.  */
 257   for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
 258     {
 259       typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
 260       if (typelen > E_MAX_RETTYPE_SIZE (argreg))
 261         break;
 262
 263       /* Put argument into registers wordwise.  */
 264       val = value_contents (args[i]);
 265       for (j = 0; j < typelen; j += xstormy16_reg_size)
 266         {
 267           ULONGEST regval;
 268           int size = (typelen - j == 1) ? 1 : xstormy16_reg_size;
 269
 270           regval = extract_unsigned_integer (val + j, size, byte_order);
 271           regcache_cooked_write_unsigned (regcache, argreg++, regval);
 272         }
 273     }
 274
 275   /* Align SP */
 276   stack_dest = xstormy16_frame_align (gdbarch, stack_dest);
 277
 278   /* Loop backwards through remaining arguments and push them on the stack,
 279      wordaligned.  */
 280   for (j = nargs - 1; j >= i; j--)
 281     {
 282       char *val;
 283
 284       typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
 285       slacklen = typelen & 1;
 286       val = alloca (typelen + slacklen);
 287       memcpy (val, value_contents (args[j]), 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     }
 294
 295   store_unsigned_integer (buf, xstormy16_pc_size, byte_order, bp_addr);
 296   write_memory (stack_dest, buf, xstormy16_pc_size);
 297   stack_dest += xstormy16_pc_size;
 298
 299   /* Update stack pointer.  */
 300   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest);
 301
 302   /* Return the new stack pointer minus the return address slot since
 303      that's what DWARF2/GCC uses as the frame's CFA.  */
 304   return stack_dest - xstormy16_pc_size;
 305 }
 306
 307 /* Function: xstormy16_scan_prologue
 308    Decode the instructions within the given address range.
 309    Decide when we must have reached the end of the function prologue.
 310    If a frame_info pointer is provided, fill in its saved_regs etc.
 311
 312    Returns the address of the first instruction after the prologue.  */
 313
 314 static CORE_ADDR
 315 xstormy16_analyze_prologue (struct gdbarch *gdbarch,
 316                             CORE_ADDR start_addr, CORE_ADDR end_addr,
 317                             struct xstormy16_frame_cache *cache,
 318                             struct frame_info *this_frame)
 319 {
 320   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 321   CORE_ADDR next_addr;
 322   ULONGEST inst, inst2;
 323   LONGEST offset;
 324   int regnum;
 325
 326   /* Initialize framesize with size of PC put on stack by CALLF inst.  */
 327   cache->saved_regs[E_PC_REGNUM] = 0;
 328   cache->framesize = xstormy16_pc_size;
 329
 330   if (start_addr >= end_addr)
 331     return end_addr;
 332
 333   for (next_addr = start_addr;
 334        next_addr < end_addr; next_addr += xstormy16_inst_size)
 335     {
 336       inst = read_memory_unsigned_integer (next_addr,
 337                                            xstormy16_inst_size, byte_order);
 338       inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
 339                                             xstormy16_inst_size, byte_order);
 340
 341       if (inst >= 0x0082 && inst <= 0x008d)     /* push r2 .. push r13 */
 342         {
 343           regnum = inst & 0x000f;
 344           cache->saved_regs[regnum] = cache->framesize;
 345           cache->framesize += xstormy16_reg_size;
 346         }
 347
 348       /* Optional stack allocation for args and local vars <= 4 byte.  */
 349       else if (inst == 0x301f || inst == 0x303f)       /* inc r15, #0x1/#0x3 */
 350         {
 351           cache->framesize += ((inst & 0x0030) >> 4) + 1;
 352         }
 353
 354       /* optional stack allocation for args and local vars > 4 && < 16 byte */
 355       else if ((inst & 0xff0f) == 0x510f)       /* 51Hf   add r15, #0xH */
 356         {
 357           cache->framesize += (inst & 0x00f0) >> 4;
 358         }
 359
 360       /* Optional stack allocation for args and local vars >= 16 byte.  */
 361       else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
 362         {
 363           cache->framesize += inst2;
 364           next_addr += xstormy16_inst_size;
 365         }
 366
 367       else if (inst == 0x46fd)  /* mov r13, r15 */
 368         {
 369           cache->uses_fp = 1;
 370         }
 371
 372       /* optional copying of args in r2-r7 to r10-r13.  */
 373       /* Probably only in optimized case but legal action for prologue.  */
 374       else if ((inst & 0xff00) == 0x4600        /* 46SD   mov rD, rS */
 375                && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
 376                && (inst & 0x000f) >= 0x00a0 && (inst & 0x000f) <= 0x000d)
 377         ;
 378
 379       /* Optional copying of args in r2-r7 to stack.  */
 380       /* 72DS HHHH   mov.b (rD, 0xHHHH), r(S-8)
 381          (bit3 always 1, bit2-0 = reg) */
 382       /* 73DS HHHH   mov.w (rD, 0xHHHH), r(S-8) */
 383       else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
 384         {
 385           regnum = inst & 0x0007;
 386           /* Only 12 of 16 bits of the argument are used for the
 387              signed offset.  */
 388           offset = (LONGEST) (inst2 & 0x0fff);
 389           if (offset & 0x0800)
 390             offset -= 0x1000;
 391
 392           cache->saved_regs[regnum] = cache->framesize + offset;
 393           next_addr += xstormy16_inst_size;
 394         }
 395
 396       else                      /* Not a prologue instruction.  */
 397         break;
 398     }
 399
 400   return next_addr;
 401 }
 402
 403 /* Function: xstormy16_skip_prologue
 404    If the input address is in a function prologue,
 405    returns the address of the end of the prologue;
 406    else returns the input address.
 407
 408    Note: the input address is likely to be the function start,
 409    since this function is mainly used for advancing a breakpoint
 410    to the first line, or stepping to the first line when we have
 411    stepped into a function call.  */
 412
 413 static CORE_ADDR
 414 xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 415 {
 416   CORE_ADDR func_addr = 0, func_end = 0;
 417   char *func_name;
 418
 419   if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
 420     {
 421       struct symtab_and_line sal;
 422       struct symbol *sym;
 423       struct xstormy16_frame_cache cache;
 424       CORE_ADDR plg_end;
 425
 426       memset (&cache, 0, sizeof cache);
 427
 428       /* Don't trust line number debug info in frameless functions.  */
 429       plg_end = xstormy16_analyze_prologue (gdbarch, func_addr, func_end,
 430                                             &cache, NULL);
 431       if (!cache.uses_fp)
 432         return plg_end;
 433
 434       /* Found a function.  */
 435       sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
 436       /* Don't use line number debug info for assembly source files.  */
 437       if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
 438         {
 439           sal = find_pc_line (func_addr, 0);
 440           if (sal.end && sal.end < func_end)
 441             {
 442               /* Found a line number, use it as end of prologue.  */
 443               return sal.end;
 444             }
 445         }
 446       /* No useable line symbol.  Use result of prologue parsing method.  */
 447       return plg_end;
 448     }
 449
 450   /* No function symbol -- just return the PC.  */
 451
 452   return (CORE_ADDR) pc;
 453 }
 454
 455 /* The epilogue is defined here as the area at the end of a function,
 456    either on the `ret' instruction itself or after an instruction which
 457    destroys the function's stack frame.  */
 458 static int
 459 xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 460 {
 461   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 462   CORE_ADDR func_addr = 0, func_end = 0;
 463
 464   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 465     {
 466       ULONGEST inst, inst2;
 467       CORE_ADDR addr = func_end - xstormy16_inst_size;
 468
 469       /* The Xstormy16 epilogue is max. 14 bytes long.  */
 470       if (pc < func_end - 7 * xstormy16_inst_size)
 471         return 0;
 472
 473       /* Check if we're on a `ret' instruction.  Otherwise it's
 474          too dangerous to proceed.  */
 475       inst = read_memory_unsigned_integer (addr,
 476                                            xstormy16_inst_size, byte_order);
 477       if (inst != 0x0003)
 478         return 0;
 479
 480       while ((addr -= xstormy16_inst_size) >= func_addr)
 481         {
 482           inst = read_memory_unsigned_integer (addr,
 483                                                xstormy16_inst_size,
 484                                                byte_order);
 485           if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
 486             continue;
 487           if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
 488             break;
 489           inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
 490                                                 xstormy16_inst_size,
 491                                                 byte_order);
 492           if (inst2 == 0x314f && inst >= 0x8000)      /* add r15, neg. value */
 493             {
 494               addr -= xstormy16_inst_size;
 495               break;
 496             }
 497           return 0;
 498         }
 499       if (pc > addr)
 500         return 1;
 501     }
 502   return 0;
 503 }
 504
 505 const static unsigned char *
 506 xstormy16_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 507                               int *lenptr)
 508 {
 509   static unsigned char breakpoint[] = { 0x06, 0x0 };
 510   *lenptr = sizeof (breakpoint);
 511   return breakpoint;
 512 }
 513
 514 /* Given a pointer to a jump table entry, return the address
 515    of the function it jumps to.  Return 0 if not found.  */
 516 static CORE_ADDR
 517 xstormy16_resolve_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
 518 {
 519   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 520   struct obj_section *faddr_sect = find_pc_section (faddr);
 521
 522   if (faddr_sect)
 523     {
 524       LONGEST inst, inst2, addr;
 525       char buf[2 * xstormy16_inst_size];
 526
 527       /* Return faddr if it's not pointing into the jump table.  */
 528       if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
 529         return faddr;
 530
 531       if (!target_read_memory (faddr, buf, sizeof buf))
 532         {
 533           inst = extract_unsigned_integer (buf,
 534                                            xstormy16_inst_size, byte_order);
 535           inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
 536                                             xstormy16_inst_size, byte_order);
 537           addr = inst2 << 8 | (inst & 0xff);
 538           return addr;
 539         }
 540     }
 541   return 0;
 542 }
 543
 544 /* Given a function's address, attempt to find (and return) the
 545    address of the corresponding jump table entry.  Return 0 if
 546    not found.  */
 547 static CORE_ADDR
 548 xstormy16_find_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
 549 {
 550   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 551   struct obj_section *faddr_sect = find_pc_section (faddr);
 552
 553   if (faddr_sect)
 554     {
 555       struct obj_section *osect;
 556
 557       /* Return faddr if it's already a pointer to a jump table entry.  */
 558       if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
 559         return faddr;
 560
 561       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
 562       {
 563         if (!strcmp (osect->the_bfd_section->name, ".plt"))
 564           break;
 565       }
 566
 567       if (osect < faddr_sect->objfile->sections_end)
 568         {
 569           CORE_ADDR addr, endaddr;
 570
 571           addr = obj_section_addr (osect);
 572           endaddr = obj_section_endaddr (osect);
 573
 574           for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
 575             {
 576               LONGEST inst, inst2, faddr2;
 577               char buf[2 * xstormy16_inst_size];
 578
 579               if (target_read_memory (addr, buf, sizeof buf))
 580                 return 0;
 581               inst = extract_unsigned_integer (buf,
 582                                                xstormy16_inst_size,
 583                                                byte_order);
 584               inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
 585                                                 xstormy16_inst_size,
 586                                                 byte_order);
 587               faddr2 = inst2 << 8 | (inst & 0xff);
 588               if (faddr == faddr2)
 589                 return addr;
 590             }
 591         }
 592     }
 593   return 0;
 594 }
 595
 596 static CORE_ADDR
 597 xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 598 {
 599   struct gdbarch *gdbarch = get_frame_arch (frame);
 600   CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);
 601
 602   if (tmp && tmp != pc)
 603     return tmp;
 604   return 0;
 605 }
 606
 607 /* Function pointers are 16 bit.  The address space is 24 bit, using
 608    32 bit addresses.  Pointers to functions on the XStormy16 are implemented
 609    by using 16 bit pointers, which are either direct pointers in case the
 610    function begins below 0x10000, or indirect pointers into a jump table.
 611    The next two functions convert 16 bit pointers into 24 (32) bit addresses
 612    and vice versa.  */
 613
 614 static CORE_ADDR
 615 xstormy16_pointer_to_address (struct gdbarch *gdbarch,
 616                               struct type *type, const gdb_byte *buf)
 617 {
 618   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 619   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 620   CORE_ADDR addr
 621     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
 622
 623   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
 624     {
 625       CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (gdbarch, addr);
 626       if (addr2)
 627         addr = addr2;
 628     }
 629
 630   return addr;
 631 }
 632
 633 static void
 634 xstormy16_address_to_pointer (struct gdbarch *gdbarch,
 635                               struct type *type, gdb_byte *buf, CORE_ADDR addr)
 636 {
 637   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 638   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 639
 640   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
 641     {
 642       CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (gdbarch, addr);
 643       if (addr2)
 644         addr = addr2;
 645     }
 646   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
 647 }
 648
 649 static struct xstormy16_frame_cache *
 650 xstormy16_alloc_frame_cache (void)
 651 {
 652   struct xstormy16_frame_cache *cache;
 653   int i;
 654
 655   cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache);
 656
 657   cache->base = 0;
 658   cache->saved_sp = 0;
 659   cache->pc = 0;
 660   cache->uses_fp = 0;
 661   cache->framesize = 0;
 662   for (i = 0; i < E_NUM_REGS; ++i)
 663     cache->saved_regs[i] = REG_UNAVAIL;
 664
 665   return cache;
 666 }
 667
 668 static struct xstormy16_frame_cache *
 669 xstormy16_frame_cache (struct frame_info *this_frame, void **this_cache)
 670 {
 671   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 672   struct xstormy16_frame_cache *cache;
 673   CORE_ADDR current_pc;
 674   int i;
 675
 676   if (*this_cache)
 677     return *this_cache;
 678
 679   cache = xstormy16_alloc_frame_cache ();
 680   *this_cache = cache;
 681
 682   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
 683   if (cache->base == 0)
 684     return cache;
 685
 686   cache->pc = get_frame_func (this_frame);
 687   current_pc = get_frame_pc (this_frame);
 688   if (cache->pc)
 689     xstormy16_analyze_prologue (gdbarch, cache->pc, current_pc,
 690                                 cache, this_frame);
 691
 692   if (!cache->uses_fp)
 693     cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 694
 695   cache->saved_sp = cache->base - cache->framesize;
 696
 697   for (i = 0; i < E_NUM_REGS; ++i)
 698     if (cache->saved_regs[i] != REG_UNAVAIL)
 699       cache->saved_regs[i] += cache->saved_sp;
 700
 701   return cache;
 702 }
 703
 704 static struct value *
 705 xstormy16_frame_prev_register (struct frame_info *this_frame,
 706                                void **this_cache, int regnum)
 707 {
 708   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
 709                                                                this_cache);
 710   gdb_assert (regnum >= 0);
 711
 712   if (regnum == E_SP_REGNUM && cache->saved_sp)
 713     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 714
 715   if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
 716     return frame_unwind_got_memory (this_frame, regnum,
 717                                     cache->saved_regs[regnum]);
 718
 719   return frame_unwind_got_register (this_frame, regnum, regnum);
 720 }
 721
 722 static void
 723 xstormy16_frame_this_id (struct frame_info *this_frame, void **this_cache,
 724                          struct frame_id *this_id)
 725 {
 726   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
 727                                                                this_cache);
 728
 729   /* This marks the outermost frame.  */
 730   if (cache->base == 0)
 731     return;
 732
 733   *this_id = frame_id_build (cache->saved_sp, cache->pc);
 734 }
 735
 736 static CORE_ADDR
 737 xstormy16_frame_base_address (struct frame_info *this_frame, void **this_cache)
 738 {
 739   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
 740                                                                this_cache);
 741   return cache->base;
 742 }
 743
 744 static const struct frame_unwind xstormy16_frame_unwind = {
 745   NORMAL_FRAME,
 746   default_frame_unwind_stop_reason,
 747   xstormy16_frame_this_id,
 748   xstormy16_frame_prev_register,
 749   NULL,
 750   default_frame_sniffer
 751 };
 752
 753 static const struct frame_base xstormy16_frame_base = {
 754   &xstormy16_frame_unwind,
 755   xstormy16_frame_base_address,
 756   xstormy16_frame_base_address,
 757   xstormy16_frame_base_address
 758 };
 759
 760 static CORE_ADDR
 761 xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 762 {
 763   return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
 764 }
 765
 766 static CORE_ADDR
 767 xstormy16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 768 {
 769   return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
 770 }
 771
 772 static struct frame_id
 773 xstormy16_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 774 {
 775   CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 776   return frame_id_build (sp, get_frame_pc (this_frame));
 777 }
 778
 779
 780 /* Function: xstormy16_gdbarch_init
 781    Initializer function for the xstormy16 gdbarch vector.
 782    Called by gdbarch.  Sets up the gdbarch vector(s) for this target.  */
 783
 784 static struct gdbarch *
 785 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 786 {
 787   struct gdbarch *gdbarch;
 788
 789   /* find a candidate among the list of pre-declared architectures.  */
 790   arches = gdbarch_list_lookup_by_info (arches, &info);
 791   if (arches != NULL)
 792     return (arches->gdbarch);
 793
 794   gdbarch = gdbarch_alloc (&info, NULL);
 795
 796   /*
 797    * Basic register fields and methods, datatype sizes and stuff.
 798    */
 799
 800   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
 801   set_gdbarch_num_pseudo_regs (gdbarch, 0);
 802   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
 803   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
 804   set_gdbarch_register_name (gdbarch, xstormy16_register_name);
 805   set_gdbarch_register_type (gdbarch, xstormy16_register_type);
 806
 807   set_gdbarch_char_signed (gdbarch, 0);
 808   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 809   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 810   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
 811   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 812
 813   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
 814   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 815   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 816
 817   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 818   set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
 819   set_gdbarch_dwarf2_addr_size (gdbarch, 4);
 820
 821   set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
 822   set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
 823
 824   /* Stack grows up.  */
 825   set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
 826
 827   /*
 828    * Frame Info
 829    */
 830   set_gdbarch_unwind_sp (gdbarch, xstormy16_unwind_sp);
 831   set_gdbarch_unwind_pc (gdbarch, xstormy16_unwind_pc);
 832   set_gdbarch_dummy_id (gdbarch, xstormy16_dummy_id);
 833   set_gdbarch_frame_align (gdbarch, xstormy16_frame_align);
 834   frame_base_set_default (gdbarch, &xstormy16_frame_base);
 835
 836   set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
 837   set_gdbarch_in_function_epilogue_p (gdbarch,
 838                                       xstormy16_in_function_epilogue_p);
 839
 840   /* These values and methods are used when gdb calls a target function.  */
 841   set_gdbarch_push_dummy_call (gdbarch, xstormy16_push_dummy_call);
 842   set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
 843   set_gdbarch_return_value (gdbarch, xstormy16_return_value);
 844
 845   set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
 846
 847   set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
 848
 849   gdbarch_init_osabi (info, gdbarch);
 850
 851   dwarf2_append_unwinders (gdbarch);
 852   frame_unwind_append_unwinder (gdbarch, &xstormy16_frame_unwind);
 853
 854   return gdbarch;
 855 }
 856
 857 /* Function: _initialize_xstormy16_tdep
 858    Initializer function for the Sanyo Xstormy16a module.
 859    Called by gdb at start-up.  */
 860
 861 /* -Wmissing-prototypes */
 862 extern initialize_file_ftype _initialize_xstormy16_tdep;
 863
 864 void
 865 _initialize_xstormy16_tdep (void)
 866 {
 867   register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
 868 }