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
   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         regcache_cooked_write_unsigned (regcache, argreg++,
 267                         extract_unsigned_integer (val + j,
 268                                                   typelen - j ==
 269                                                   1 ? 1 :
 270                                                   xstormy16_reg_size,
 271                                                   byte_order));
 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) (bit3 always 1, bit2-0 = reg) */
 380       /* 73DS HHHH   mov.w (rD, 0xHHHH), r(S-8) */
 381       else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
 382         {
 383           regnum = inst & 0x0007;
 384           /* Only 12 of 16 bits of the argument are used for the
 385              signed offset. */
 386           offset = (LONGEST) (inst2 & 0x0fff);
 387           if (offset & 0x0800)
 388             offset -= 0x1000;
 389
 390           cache->saved_regs[regnum] = cache->framesize + offset;
 391           next_addr += xstormy16_inst_size;
 392         }
 393
 394       else                      /* Not a prologue instruction. */
 395         break;
 396     }
 397
 398   return next_addr;
 399 }
 400
 401 /* Function: xstormy16_skip_prologue
 402    If the input address is in a function prologue,
 403    returns the address of the end of the prologue;
 404    else returns the input address.
 405
 406    Note: the input address is likely to be the function start,
 407    since this function is mainly used for advancing a breakpoint
 408    to the first line, or stepping to the first line when we have
 409    stepped into a function call.  */
 410
 411 static CORE_ADDR
 412 xstormy16_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 413 {
 414   CORE_ADDR func_addr = 0, func_end = 0;
 415   char *func_name;
 416
 417   if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
 418     {
 419       struct symtab_and_line sal;
 420       struct symbol *sym;
 421       struct xstormy16_frame_cache cache;
 422       CORE_ADDR plg_end;
 423
 424       memset (&cache, 0, sizeof cache);
 425
 426       /* Don't trust line number debug info in frameless functions. */
 427       plg_end = xstormy16_analyze_prologue (gdbarch, func_addr, func_end,
 428                                             &cache, NULL);
 429       if (!cache.uses_fp)
 430         return plg_end;
 431
 432       /* Found a function.  */
 433       sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
 434       /* Don't use line number debug info for assembly source files. */
 435       if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
 436         {
 437           sal = find_pc_line (func_addr, 0);
 438           if (sal.end && sal.end < func_end)
 439             {
 440               /* Found a line number, use it as end of prologue.  */
 441               return sal.end;
 442             }
 443         }
 444       /* No useable line symbol.  Use result of prologue parsing method. */
 445       return plg_end;
 446     }
 447
 448   /* No function symbol -- just return the PC. */
 449
 450   return (CORE_ADDR) pc;
 451 }
 452
 453 /* The epilogue is defined here as the area at the end of a function,
 454    either on the `ret' instruction itself or after an instruction which
 455    destroys the function's stack frame. */
 456 static int
 457 xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 458 {
 459   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 460   CORE_ADDR func_addr = 0, func_end = 0;
 461
 462   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 463     {
 464       ULONGEST inst, inst2;
 465       CORE_ADDR addr = func_end - xstormy16_inst_size;
 466
 467       /* The Xstormy16 epilogue is max. 14 bytes long. */
 468       if (pc < func_end - 7 * xstormy16_inst_size)
 469         return 0;
 470
 471       /* Check if we're on a `ret' instruction.  Otherwise it's
 472          too dangerous to proceed. */
 473       inst = read_memory_unsigned_integer (addr,
 474                                            xstormy16_inst_size, byte_order);
 475       if (inst != 0x0003)
 476         return 0;
 477
 478       while ((addr -= xstormy16_inst_size) >= func_addr)
 479         {
 480           inst = read_memory_unsigned_integer (addr,
 481                                                xstormy16_inst_size, byte_order);
 482           if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
 483             continue;
 484           if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
 485             break;
 486           inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
 487                                                 xstormy16_inst_size, byte_order);
 488           if (inst2 == 0x314f && inst >= 0x8000)        /* add r15, neg. value */
 489             {
 490               addr -= xstormy16_inst_size;
 491               break;
 492             }
 493           return 0;
 494         }
 495       if (pc > addr)
 496         return 1;
 497     }
 498   return 0;
 499 }
 500
 501 const static unsigned char *
 502 xstormy16_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 503                               int *lenptr)
 504 {
 505   static unsigned char breakpoint[] = { 0x06, 0x0 };
 506   *lenptr = sizeof (breakpoint);
 507   return breakpoint;
 508 }
 509
 510 /* Given a pointer to a jump table entry, return the address
 511    of the function it jumps to.  Return 0 if not found. */
 512 static CORE_ADDR
 513 xstormy16_resolve_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
 514 {
 515   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 516   struct obj_section *faddr_sect = find_pc_section (faddr);
 517
 518   if (faddr_sect)
 519     {
 520       LONGEST inst, inst2, addr;
 521       char buf[2 * xstormy16_inst_size];
 522
 523       /* Return faddr if it's not pointing into the jump table. */
 524       if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
 525         return faddr;
 526
 527       if (!target_read_memory (faddr, buf, sizeof buf))
 528         {
 529           inst = extract_unsigned_integer (buf,
 530                                            xstormy16_inst_size, byte_order);
 531           inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
 532                                             xstormy16_inst_size, byte_order);
 533           addr = inst2 << 8 | (inst & 0xff);
 534           return addr;
 535         }
 536     }
 537   return 0;
 538 }
 539
 540 /* Given a function's address, attempt to find (and return) the
 541    address of the corresponding jump table entry.  Return 0 if
 542    not found. */
 543 static CORE_ADDR
 544 xstormy16_find_jmp_table_entry (struct gdbarch *gdbarch, CORE_ADDR faddr)
 545 {
 546   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 547   struct obj_section *faddr_sect = find_pc_section (faddr);
 548
 549   if (faddr_sect)
 550     {
 551       struct obj_section *osect;
 552
 553       /* Return faddr if it's already a pointer to a jump table entry. */
 554       if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
 555         return faddr;
 556
 557       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
 558       {
 559         if (!strcmp (osect->the_bfd_section->name, ".plt"))
 560           break;
 561       }
 562
 563       if (osect < faddr_sect->objfile->sections_end)
 564         {
 565           CORE_ADDR addr, endaddr;
 566
 567           addr = obj_section_addr (osect);
 568           endaddr = obj_section_endaddr (osect);
 569
 570           for (; addr < endaddr; addr += 2 * xstormy16_inst_size)
 571             {
 572               LONGEST inst, inst2, faddr2;
 573               char buf[2 * xstormy16_inst_size];
 574
 575               if (target_read_memory (addr, buf, sizeof buf))
 576                 return 0;
 577               inst = extract_unsigned_integer (buf,
 578                                                xstormy16_inst_size, byte_order);
 579               inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
 580                                                 xstormy16_inst_size, byte_order);
 581               faddr2 = inst2 << 8 | (inst & 0xff);
 582               if (faddr == faddr2)
 583                 return addr;
 584             }
 585         }
 586     }
 587   return 0;
 588 }
 589
 590 static CORE_ADDR
 591 xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 592 {
 593   struct gdbarch *gdbarch = get_frame_arch (frame);
 594   CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);
 595
 596   if (tmp && tmp != pc)
 597     return tmp;
 598   return 0;
 599 }
 600
 601 /* Function pointers are 16 bit.  The address space is 24 bit, using
 602    32 bit addresses.  Pointers to functions on the XStormy16 are implemented
 603    by using 16 bit pointers, which are either direct pointers in case the
 604    function begins below 0x10000, or indirect pointers into a jump table.
 605    The next two functions convert 16 bit pointers into 24 (32) bit addresses
 606    and vice versa.  */
 607
 608 static CORE_ADDR
 609 xstormy16_pointer_to_address (struct gdbarch *gdbarch,
 610                               struct type *type, const gdb_byte *buf)
 611 {
 612   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 613   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 614   CORE_ADDR addr
 615     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
 616
 617   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
 618     {
 619       CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (gdbarch, addr);
 620       if (addr2)
 621         addr = addr2;
 622     }
 623
 624   return addr;
 625 }
 626
 627 static void
 628 xstormy16_address_to_pointer (struct gdbarch *gdbarch,
 629                               struct type *type, gdb_byte *buf, CORE_ADDR addr)
 630 {
 631   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 632   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 633
 634   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
 635     {
 636       CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (gdbarch, addr);
 637       if (addr2)
 638         addr = addr2;
 639     }
 640   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
 641 }
 642
 643 static struct xstormy16_frame_cache *
 644 xstormy16_alloc_frame_cache (void)
 645 {
 646   struct xstormy16_frame_cache *cache;
 647   int i;
 648
 649   cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache);
 650
 651   cache->base = 0;
 652   cache->saved_sp = 0;
 653   cache->pc = 0;
 654   cache->uses_fp = 0;
 655   cache->framesize = 0;
 656   for (i = 0; i < E_NUM_REGS; ++i)
 657     cache->saved_regs[i] = REG_UNAVAIL;
 658
 659   return cache;
 660 }
 661
 662 static struct xstormy16_frame_cache *
 663 xstormy16_frame_cache (struct frame_info *this_frame, void **this_cache)
 664 {
 665   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 666   struct xstormy16_frame_cache *cache;
 667   CORE_ADDR current_pc;
 668   int i;
 669
 670   if (*this_cache)
 671     return *this_cache;
 672
 673   cache = xstormy16_alloc_frame_cache ();
 674   *this_cache = cache;
 675
 676   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
 677   if (cache->base == 0)
 678     return cache;
 679
 680   cache->pc = get_frame_func (this_frame);
 681   current_pc = get_frame_pc (this_frame);
 682   if (cache->pc)
 683     xstormy16_analyze_prologue (gdbarch, cache->pc, current_pc,
 684                                 cache, this_frame);
 685
 686   if (!cache->uses_fp)
 687     cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 688
 689   cache->saved_sp = cache->base - cache->framesize;
 690
 691   for (i = 0; i < E_NUM_REGS; ++i)
 692     if (cache->saved_regs[i] != REG_UNAVAIL)
 693       cache->saved_regs[i] += cache->saved_sp;
 694
 695   return cache;
 696 }
 697
 698 static struct value *
 699 xstormy16_frame_prev_register (struct frame_info *this_frame,
 700                                void **this_cache, int regnum)
 701 {
 702   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
 703                                                                this_cache);
 704   gdb_assert (regnum >= 0);
 705
 706   if (regnum == E_SP_REGNUM && cache->saved_sp)
 707     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 708
 709   if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
 710     return frame_unwind_got_memory (this_frame, regnum,
 711                                     cache->saved_regs[regnum]);
 712
 713   return frame_unwind_got_register (this_frame, regnum, regnum);
 714 }
 715
 716 static void
 717 xstormy16_frame_this_id (struct frame_info *this_frame, void **this_cache,
 718                          struct frame_id *this_id)
 719 {
 720   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
 721                                                                this_cache);
 722
 723   /* This marks the outermost frame.  */
 724   if (cache->base == 0)
 725     return;
 726
 727   *this_id = frame_id_build (cache->saved_sp, cache->pc);
 728 }
 729
 730 static CORE_ADDR
 731 xstormy16_frame_base_address (struct frame_info *this_frame, void **this_cache)
 732 {
 733   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
 734                                                                this_cache);
 735   return cache->base;
 736 }
 737
 738 static const struct frame_unwind xstormy16_frame_unwind = {
 739   NORMAL_FRAME,
 740   xstormy16_frame_this_id,
 741   xstormy16_frame_prev_register,
 742   NULL,
 743   default_frame_sniffer
 744 };
 745
 746 static const struct frame_base xstormy16_frame_base = {
 747   &xstormy16_frame_unwind,
 748   xstormy16_frame_base_address,
 749   xstormy16_frame_base_address,
 750   xstormy16_frame_base_address
 751 };
 752
 753 static CORE_ADDR
 754 xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 755 {
 756   return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
 757 }
 758
 759 static CORE_ADDR
 760 xstormy16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 761 {
 762   return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
 763 }
 764
 765 static struct frame_id
 766 xstormy16_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 767 {
 768   CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 769   return frame_id_build (sp, get_frame_pc (this_frame));
 770 }
 771
 772
 773 /* Function: xstormy16_gdbarch_init
 774    Initializer function for the xstormy16 gdbarch vector.
 775    Called by gdbarch.  Sets up the gdbarch vector(s) for this target. */
 776
 777 static struct gdbarch *
 778 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 779 {
 780   struct gdbarch *gdbarch;
 781
 782   /* find a candidate among the list of pre-declared architectures. */
 783   arches = gdbarch_list_lookup_by_info (arches, &info);
 784   if (arches != NULL)
 785     return (arches->gdbarch);
 786
 787   gdbarch = gdbarch_alloc (&info, NULL);
 788
 789   /*
 790    * Basic register fields and methods, datatype sizes and stuff.
 791    */
 792
 793   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
 794   set_gdbarch_num_pseudo_regs (gdbarch, 0);
 795   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
 796   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
 797   set_gdbarch_register_name (gdbarch, xstormy16_register_name);
 798   set_gdbarch_register_type (gdbarch, xstormy16_register_type);
 799
 800   set_gdbarch_char_signed (gdbarch, 0);
 801   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 802   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 803   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
 804   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 805
 806   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
 807   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 808   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 809
 810   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 811   set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
 812   set_gdbarch_dwarf2_addr_size (gdbarch, 4);
 813
 814   set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
 815   set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
 816
 817   /* Stack grows up. */
 818   set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
 819
 820   /*
 821    * Frame Info
 822    */
 823   set_gdbarch_unwind_sp (gdbarch, xstormy16_unwind_sp);
 824   set_gdbarch_unwind_pc (gdbarch, xstormy16_unwind_pc);
 825   set_gdbarch_dummy_id (gdbarch, xstormy16_dummy_id);
 826   set_gdbarch_frame_align (gdbarch, xstormy16_frame_align);
 827   frame_base_set_default (gdbarch, &xstormy16_frame_base);
 828
 829   set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
 830   set_gdbarch_in_function_epilogue_p (gdbarch,
 831                                       xstormy16_in_function_epilogue_p);
 832
 833   /* These values and methods are used when gdb calls a target function.  */
 834   set_gdbarch_push_dummy_call (gdbarch, xstormy16_push_dummy_call);
 835   set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
 836   set_gdbarch_return_value (gdbarch, xstormy16_return_value);
 837
 838   set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
 839
 840   set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
 841
 842   gdbarch_init_osabi (info, gdbarch);
 843
 844   dwarf2_append_unwinders (gdbarch);
 845   frame_unwind_append_unwinder (gdbarch, &xstormy16_frame_unwind);
 846
 847   return gdbarch;
 848 }
 849
 850 /* Function: _initialize_xstormy16_tdep
 851    Initializer function for the Sanyo Xstormy16a module.
 852    Called by gdb at start-up. */
 853
 854 extern initialize_file_ftype _initialize_xstormy16_tdep; /* -Wmissing-prototypes */
 855
 856 void
 857 _initialize_xstormy16_tdep (void)
 858 {
 859   register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
 860 }