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