gdb/xstormy16-tdep.c

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