gdb/xstormy16-tdep.c

   1 /* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
   2
   3    Copyright (C) 2001-2017 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 "arch-utils.h"
  33 #include "floatformat.h"
  34 #include "regcache.h"
  35 #include "doublest.h"
  36 #include "osabi.h"
  37 #include "objfiles.h"
  38 #include "common/byte-vector.h"
  39
  40 enum gdb_regnum
  41 {
  42   /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
  43      Functions will return their values in register R2-R7 as they fit.
  44      Otherwise a hidden pointer to an big enough area is given as argument
  45      to the function in r2.  Further arguments are beginning in r3 then.
  46      R13 is used as frame pointer when GCC compiles w/o optimization
  47      R14 is used as "PSW", displaying the CPU status.
  48      R15 is used implicitely as stack pointer.  */
  49   E_R0_REGNUM,
  50   E_R1_REGNUM,
  51   E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM,
  52   E_R3_REGNUM,
  53   E_R4_REGNUM,
  54   E_R5_REGNUM,
  55   E_R6_REGNUM,
  56   E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM,
  57   E_R8_REGNUM,
  58   E_R9_REGNUM,
  59   E_R10_REGNUM,
  60   E_R11_REGNUM,
  61   E_R12_REGNUM,
  62   E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM,
  63   E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM,
  64   E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM,
  65   E_PC_REGNUM,
  66   E_NUM_REGS
  67 };
  68
  69 /* Use an invalid address value as 'not available' marker.  */
  70 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
  71
  72 struct xstormy16_frame_cache
  73 {
  74   /* Base address.  */
  75   CORE_ADDR base;
  76   CORE_ADDR pc;
  77   LONGEST framesize;
  78   int uses_fp;
  79   CORE_ADDR saved_regs[E_NUM_REGS];
  80   CORE_ADDR saved_sp;
  81 };
  82
  83 /* Size of instructions, registers, etc.  */
  84 enum
  85 {
  86   xstormy16_inst_size = 2,
  87   xstormy16_reg_size = 2,
  88   xstormy16_pc_size = 4
  89 };
  90
  91 /* Size of return datatype which fits into the remaining return registers.  */
  92 #define E_MAX_RETTYPE_SIZE(regnum)      ((E_LST_ARG_REGNUM - (regnum) + 1) \
  93                                         * xstormy16_reg_size)
  94
  95 /* Size of return datatype which fits into all return registers.  */
  96 enum
  97 {
  98   E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM)
  99 };
 100
 101 /* Function: xstormy16_register_name
 102    Returns the name of the standard Xstormy16 register N.  */
 103
 104 static const char *
 105 xstormy16_register_name (struct gdbarch *gdbarch, int regnum)
 106 {
 107   static const char *register_names[] = {
 108     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 109     "r8", "r9", "r10", "r11", "r12", "r13",
 110     "psw", "sp", "pc"
 111   };
 112
 113   if (regnum < 0 || regnum >= E_NUM_REGS)
 114     internal_error (__FILE__, __LINE__,
 115                     _("xstormy16_register_name: illegal register number %d"),
 116                     regnum);
 117   else
 118     return register_names[regnum];
 119
 120 }
 121
 122 static struct type *
 123 xstormy16_register_type (struct gdbarch *gdbarch, int regnum)
 124 {
 125   if (regnum == E_PC_REGNUM)
 126     return builtin_type (gdbarch)->builtin_uint32;
 127   else
 128     return builtin_type (gdbarch)->builtin_uint16;
 129 }
 130
 131 /* Function: xstormy16_type_is_scalar
 132    Makes the decision if a given type is a scalar types.  Scalar
 133    types are returned in the registers r2-r7 as they fit.  */
 134
 135 static int
 136 xstormy16_type_is_scalar (struct type *t)
 137 {
 138   return (TYPE_CODE(t) != TYPE_CODE_STRUCT
 139           && TYPE_CODE(t) != TYPE_CODE_UNION
 140           && TYPE_CODE(t) != TYPE_CODE_ARRAY);
 141 }
 142
 143 /* Function: xstormy16_use_struct_convention
 144    Returns non-zero if the given struct type will be returned using
 145    a special convention, rather than the normal function return method.
 146    7sed in the contexts of the "return" command, and of
 147    target function calls from the debugger.  */
 148
 149 static int
 150 xstormy16_use_struct_convention (struct type *type)
 151 {
 152   return !xstormy16_type_is_scalar (type)
 153          || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
 154 }
 155
 156 /* Function: xstormy16_extract_return_value
 157    Find a function's return value in the appropriate registers (in
 158    regbuf), and copy it into valbuf.  */
 159
 160 static void
 161 xstormy16_extract_return_value (struct type *type, struct regcache *regcache,
 162                                 gdb_byte *valbuf)
 163 {
 164   int len = TYPE_LENGTH (type);
 165   int i, regnum = E_1ST_ARG_REGNUM;
 166
 167   for (i = 0; i < len; i += xstormy16_reg_size)
 168     regcache_raw_read (regcache, regnum++, valbuf + i);
 169 }
 170
 171 /* Function: xstormy16_store_return_value
 172    Copy the function return value from VALBUF into the
 173    proper location for a function return.
 174    Called only in the context of the "return" command.  */
 175
 176 static void
 177 xstormy16_store_return_value (struct type *type, struct regcache *regcache,
 178                               const gdb_byte *valbuf)
 179 {
 180   if (TYPE_LENGTH (type) == 1)
 181     {
 182       /* Add leading zeros to the value.  */
 183       gdb_byte buf[xstormy16_reg_size];
 184       memset (buf, 0, xstormy16_reg_size);
 185       memcpy (buf, valbuf, 1);
 186       regcache_raw_write (regcache, E_1ST_ARG_REGNUM, buf);
 187     }
 188   else
 189     {
 190       int len = TYPE_LENGTH (type);
 191       int i, regnum = E_1ST_ARG_REGNUM;
 192
 193       for (i = 0; i < len; i += xstormy16_reg_size)
 194         regcache_raw_write (regcache, regnum++, valbuf + i);
 195     }
 196 }
 197
 198 static enum return_value_convention
 199 xstormy16_return_value (struct gdbarch *gdbarch, struct value *function,
 200                         struct type *type, struct regcache *regcache,
 201                         gdb_byte *readbuf, const gdb_byte *writebuf)
 202 {
 203   if (xstormy16_use_struct_convention (type))
 204     return RETURN_VALUE_STRUCT_CONVENTION;
 205   if (writebuf)
 206     xstormy16_store_return_value (type, regcache, writebuf);
 207   else if (readbuf)
 208     xstormy16_extract_return_value (type, regcache, readbuf);
 209   return RETURN_VALUE_REGISTER_CONVENTION;
 210 }
 211
 212 static CORE_ADDR
 213 xstormy16_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
 214 {
 215   if (addr & 1)
 216     ++addr;
 217   return addr;
 218 }
 219
 220 /* Function: xstormy16_push_dummy_call
 221    Setup the function arguments for GDB to call a function in the inferior.
 222    Called only in the context of a target function call from the debugger.
 223    Returns the value of the SP register after the args are pushed.  */
 224
 225 static CORE_ADDR
 226 xstormy16_push_dummy_call (struct gdbarch *gdbarch,
 227                            struct value *function,
 228                            struct regcache *regcache,
 229                            CORE_ADDR bp_addr, int nargs,
 230                            struct value **args,
 231                            CORE_ADDR sp, int struct_return,
 232                            CORE_ADDR struct_addr)
 233 {
 234   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 235   CORE_ADDR stack_dest = sp;
 236   int argreg = E_1ST_ARG_REGNUM;
 237   int i, j;
 238   int typelen, slacklen;
 239   const gdb_byte *val;
 240   gdb_byte buf[xstormy16_pc_size];
 241
 242   /* If struct_return is true, then the struct return address will
 243      consume one argument-passing register.  */
 244   if (struct_return)
 245     {
 246       regcache_cooked_write_unsigned (regcache, E_PTR_RET_REGNUM, struct_addr);
 247       argreg++;
 248     }
 249
 250   /* Arguments are passed in R2-R7 as they fit.  If an argument doesn't
 251      fit in the remaining registers we're switching over to the stack.
 252      No argument is put on stack partially and as soon as we switched
 253      over to stack no further argument is put in a register even if it
 254      would fit in the remaining unused registers.  */
 255   for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
 256     {
 257       typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
 258       if (typelen > E_MAX_RETTYPE_SIZE (argreg))
 259         break;
 260
 261       /* Put argument into registers wordwise.  */
 262       val = value_contents (args[i]);
 263       for (j = 0; j < typelen; j += xstormy16_reg_size)
 264         {
 265           ULONGEST regval;
 266           int size = (typelen - j == 1) ? 1 : xstormy16_reg_size;
 267
 268           regval = extract_unsigned_integer (val + j, size, byte_order);
 269           regcache_cooked_write_unsigned (regcache, argreg++, regval);
 270         }
 271     }
 272
 273   /* Align SP */
 274   stack_dest = xstormy16_frame_align (gdbarch, stack_dest);
 275
 276   /* Loop backwards through remaining arguments and push them on the stack,
 277      wordaligned.  */
 278   for (j = nargs - 1; j >= i; j--)
 279     {
 280       const gdb_byte *bytes = value_contents (args[j]);
 281
 282       typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
 283       slacklen = typelen & 1;
 284       gdb::byte_vector val (typelen + slacklen);
 285       memcpy (val.data (), bytes, typelen);
 286       memset (val.data () + typelen, 0, slacklen);
 287
 288       /* Now write this data to the stack.  The stack grows upwards.  */
 289       write_memory (stack_dest, val.data (), typelen + slacklen);
 290       stack_dest += typelen + slacklen;
 291     }
 292
 293   store_unsigned_integer (buf, xstormy16_pc_size, byte_order, bp_addr);
 294   write_memory (stack_dest, buf, xstormy16_pc_size);
 295   stack_dest += xstormy16_pc_size;
 296
 297   /* Update stack pointer.  */
 298   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, stack_dest);
 299
 300   /* Return the new stack pointer minus the return address slot since
 301      that's what DWARF2/GCC uses as the frame's CFA.  */
 302   return stack_dest - xstormy16_pc_size;
 303 }
 304
 305 /* Function: xstormy16_scan_prologue
 306    Decode the instructions within the given address range.
 307    Decide when we must have reached the end of the function prologue.
 308    If a frame_info pointer is provided, fill in its saved_regs etc.
 309
 310    Returns the address of the first instruction after the prologue.  */
 311
 312 static CORE_ADDR
 313 xstormy16_analyze_prologue (struct gdbarch *gdbarch,
 314                             CORE_ADDR start_addr, CORE_ADDR end_addr,
 315                             struct xstormy16_frame_cache *cache,
 316                             struct frame_info *this_frame)
 317 {
 318   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 319   CORE_ADDR next_addr;
 320   ULONGEST inst, inst2;
 321   LONGEST offset;
 322   int regnum;
 323
 324   /* Initialize framesize with size of PC put on stack by CALLF inst.  */
 325   cache->saved_regs[E_PC_REGNUM] = 0;
 326   cache->framesize = xstormy16_pc_size;
 327
 328   if (start_addr >= end_addr)
 329     return end_addr;
 330
 331   for (next_addr = start_addr;
 332        next_addr < end_addr; next_addr += xstormy16_inst_size)
 333     {
 334       inst = read_memory_unsigned_integer (next_addr,
 335                                            xstormy16_inst_size, byte_order);
 336       inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
 337                                             xstormy16_inst_size, byte_order);
 338
 339       if (inst >= 0x0082 && inst <= 0x008d)     /* push r2 .. push r13 */
 340         {
 341           regnum = inst & 0x000f;
 342           cache->saved_regs[regnum] = cache->framesize;
 343           cache->framesize += xstormy16_reg_size;
 344         }
 345
 346       /* Optional stack allocation for args and local vars <= 4 byte.  */
 347       else if (inst == 0x301f || inst == 0x303f)       /* inc r15, #0x1/#0x3 */
 348         {
 349           cache->framesize += ((inst & 0x0030) >> 4) + 1;
 350         }
 351
 352       /* optional stack allocation for args and local vars > 4 && < 16 byte */
 353       else if ((inst & 0xff0f) == 0x510f)       /* 51Hf   add r15, #0xH */
 354         {
 355           cache->framesize += (inst & 0x00f0) >> 4;
 356         }
 357
 358       /* Optional stack allocation for args and local vars >= 16 byte.  */
 359       else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
 360         {
 361           cache->framesize += inst2;
 362           next_addr += xstormy16_inst_size;
 363         }
 364
 365       else if (inst == 0x46fd)  /* mov r13, r15 */
 366         {
 367           cache->uses_fp = 1;
 368         }
 369
 370       /* optional copying of args in r2-r7 to r10-r13.  */
 371       /* Probably only in optimized case but legal action for prologue.  */
 372       else if ((inst & 0xff00) == 0x4600        /* 46SD   mov rD, rS */
 373                && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
 374                && (inst & 0x000f) >= 0x000a && (inst & 0x000f) <= 0x000d)
 375         ;
 376
 377       /* Optional copying of args in r2-r7 to stack.  */
 378       /* 72DS HHHH   mov.b (rD, 0xHHHH), r(S-8)
 379          (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   const 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).symbol;
 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 /* Implement the stack_frame_destroyed_p gdbarch method.
 454
 455    The epilogue is defined here as the area at the end of a function,
 456    either on the `ret' instruction itself or after an instruction which
 457    destroys the function's stack frame.  */
 458
 459 static int
 460 xstormy16_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 461 {
 462   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 463   CORE_ADDR func_addr = 0, func_end = 0;
 464
 465   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 466     {
 467       ULONGEST inst, inst2;
 468       CORE_ADDR addr = func_end - xstormy16_inst_size;
 469
 470       /* The Xstormy16 epilogue is max. 14 bytes long.  */
 471       if (pc < func_end - 7 * xstormy16_inst_size)
 472         return 0;
 473
 474       /* Check if we're on a `ret' instruction.  Otherwise it's
 475          too dangerous to proceed.  */
 476       inst = read_memory_unsigned_integer (addr,
 477                                            xstormy16_inst_size, byte_order);
 478       if (inst != 0x0003)
 479         return 0;
 480
 481       while ((addr -= xstormy16_inst_size) >= func_addr)
 482         {
 483           inst = read_memory_unsigned_integer (addr,
 484                                                xstormy16_inst_size,
 485                                                byte_order);
 486           if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
 487             continue;
 488           if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
 489             break;
 490           inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
 491                                                 xstormy16_inst_size,
 492                                                 byte_order);
 493           if (inst2 == 0x314f && inst >= 0x8000)      /* add r15, neg. value */
 494             {
 495               addr -= xstormy16_inst_size;
 496               break;
 497             }
 498           return 0;
 499         }
 500       if (pc > addr)
 501         return 1;
 502     }
 503   return 0;
 504 }
 505
 506 constexpr gdb_byte xstormy16_break_insn[] = { 0x06, 0x0 };
 507
 508 typedef BP_MANIPULATION (xstormy16_break_insn) xstormy16_breakpoint;
 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       gdb_byte 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               gdb_byte 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,
 579                                                byte_order);
 580               inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
 581                                                 xstormy16_inst_size,
 582                                                 byte_order);
 583               faddr2 = inst2 << 8 | (inst & 0xff);
 584               if (faddr == faddr2)
 585                 return addr;
 586             }
 587         }
 588     }
 589   return 0;
 590 }
 591
 592 static CORE_ADDR
 593 xstormy16_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 594 {
 595   struct gdbarch *gdbarch = get_frame_arch (frame);
 596   CORE_ADDR tmp = xstormy16_resolve_jmp_table_entry (gdbarch, pc);
 597
 598   if (tmp && tmp != pc)
 599     return tmp;
 600   return 0;
 601 }
 602
 603 /* Function pointers are 16 bit.  The address space is 24 bit, using
 604    32 bit addresses.  Pointers to functions on the XStormy16 are implemented
 605    by using 16 bit pointers, which are either direct pointers in case the
 606    function begins below 0x10000, or indirect pointers into a jump table.
 607    The next two functions convert 16 bit pointers into 24 (32) bit addresses
 608    and vice versa.  */
 609
 610 static CORE_ADDR
 611 xstormy16_pointer_to_address (struct gdbarch *gdbarch,
 612                               struct type *type, const gdb_byte *buf)
 613 {
 614   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 615   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 616   CORE_ADDR addr
 617     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
 618
 619   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
 620     {
 621       CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (gdbarch, addr);
 622       if (addr2)
 623         addr = addr2;
 624     }
 625
 626   return addr;
 627 }
 628
 629 static void
 630 xstormy16_address_to_pointer (struct gdbarch *gdbarch,
 631                               struct type *type, gdb_byte *buf, CORE_ADDR addr)
 632 {
 633   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 634   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 635
 636   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
 637     {
 638       CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (gdbarch, addr);
 639       if (addr2)
 640         addr = addr2;
 641     }
 642   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
 643 }
 644
 645 static struct xstormy16_frame_cache *
 646 xstormy16_alloc_frame_cache (void)
 647 {
 648   struct xstormy16_frame_cache *cache;
 649   int i;
 650
 651   cache = FRAME_OBSTACK_ZALLOC (struct xstormy16_frame_cache);
 652
 653   cache->base = 0;
 654   cache->saved_sp = 0;
 655   cache->pc = 0;
 656   cache->uses_fp = 0;
 657   cache->framesize = 0;
 658   for (i = 0; i < E_NUM_REGS; ++i)
 659     cache->saved_regs[i] = REG_UNAVAIL;
 660
 661   return cache;
 662 }
 663
 664 static struct xstormy16_frame_cache *
 665 xstormy16_frame_cache (struct frame_info *this_frame, void **this_cache)
 666 {
 667   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 668   struct xstormy16_frame_cache *cache;
 669   CORE_ADDR current_pc;
 670   int i;
 671
 672   if (*this_cache)
 673     return (struct xstormy16_frame_cache *) *this_cache;
 674
 675   cache = xstormy16_alloc_frame_cache ();
 676   *this_cache = cache;
 677
 678   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
 679   if (cache->base == 0)
 680     return cache;
 681
 682   cache->pc = get_frame_func (this_frame);
 683   current_pc = get_frame_pc (this_frame);
 684   if (cache->pc)
 685     xstormy16_analyze_prologue (gdbarch, cache->pc, current_pc,
 686                                 cache, this_frame);
 687
 688   if (!cache->uses_fp)
 689     cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 690
 691   cache->saved_sp = cache->base - cache->framesize;
 692
 693   for (i = 0; i < E_NUM_REGS; ++i)
 694     if (cache->saved_regs[i] != REG_UNAVAIL)
 695       cache->saved_regs[i] += cache->saved_sp;
 696
 697   return cache;
 698 }
 699
 700 static struct value *
 701 xstormy16_frame_prev_register (struct frame_info *this_frame,
 702                                void **this_cache, int regnum)
 703 {
 704   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
 705                                                                this_cache);
 706   gdb_assert (regnum >= 0);
 707
 708   if (regnum == E_SP_REGNUM && cache->saved_sp)
 709     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 710
 711   if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
 712     return frame_unwind_got_memory (this_frame, regnum,
 713                                     cache->saved_regs[regnum]);
 714
 715   return frame_unwind_got_register (this_frame, regnum, regnum);
 716 }
 717
 718 static void
 719 xstormy16_frame_this_id (struct frame_info *this_frame, void **this_cache,
 720                          struct frame_id *this_id)
 721 {
 722   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
 723                                                                this_cache);
 724
 725   /* This marks the outermost frame.  */
 726   if (cache->base == 0)
 727     return;
 728
 729   *this_id = frame_id_build (cache->saved_sp, cache->pc);
 730 }
 731
 732 static CORE_ADDR
 733 xstormy16_frame_base_address (struct frame_info *this_frame, void **this_cache)
 734 {
 735   struct xstormy16_frame_cache *cache = xstormy16_frame_cache (this_frame,
 736                                                                this_cache);
 737   return cache->base;
 738 }
 739
 740 static const struct frame_unwind xstormy16_frame_unwind = {
 741   NORMAL_FRAME,
 742   default_frame_unwind_stop_reason,
 743   xstormy16_frame_this_id,
 744   xstormy16_frame_prev_register,
 745   NULL,
 746   default_frame_sniffer
 747 };
 748
 749 static const struct frame_base xstormy16_frame_base = {
 750   &xstormy16_frame_unwind,
 751   xstormy16_frame_base_address,
 752   xstormy16_frame_base_address,
 753   xstormy16_frame_base_address
 754 };
 755
 756 static CORE_ADDR
 757 xstormy16_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 758 {
 759   return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
 760 }
 761
 762 static CORE_ADDR
 763 xstormy16_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 764 {
 765   return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
 766 }
 767
 768 static struct frame_id
 769 xstormy16_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 770 {
 771   CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 772   return frame_id_build (sp, get_frame_pc (this_frame));
 773 }
 774
 775
 776 /* Function: xstormy16_gdbarch_init
 777    Initializer function for the xstormy16 gdbarch vector.
 778    Called by gdbarch.  Sets up the gdbarch vector(s) for this target.  */
 779
 780 static struct gdbarch *
 781 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 782 {
 783   struct gdbarch *gdbarch;
 784
 785   /* find a candidate among the list of pre-declared architectures.  */
 786   arches = gdbarch_list_lookup_by_info (arches, &info);
 787   if (arches != NULL)
 788     return (arches->gdbarch);
 789
 790   gdbarch = gdbarch_alloc (&info, NULL);
 791
 792   /*
 793    * Basic register fields and methods, datatype sizes and stuff.
 794    */
 795
 796   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
 797   set_gdbarch_num_pseudo_regs (gdbarch, 0);
 798   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
 799   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
 800   set_gdbarch_register_name (gdbarch, xstormy16_register_name);
 801   set_gdbarch_register_type (gdbarch, xstormy16_register_type);
 802
 803   set_gdbarch_char_signed (gdbarch, 0);
 804   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 805   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 806   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
 807   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
 808
 809   set_gdbarch_wchar_bit (gdbarch, 2 * TARGET_CHAR_BIT);
 810   set_gdbarch_wchar_signed (gdbarch, 1);
 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_stack_frame_destroyed_p (gdbarch,
 837                                        xstormy16_stack_frame_destroyed_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_kind_from_pc (gdbarch,
 842                                        xstormy16_breakpoint::kind_from_pc);
 843   set_gdbarch_sw_breakpoint_from_kind (gdbarch,
 844                                        xstormy16_breakpoint::bp_from_kind);
 845   set_gdbarch_return_value (gdbarch, xstormy16_return_value);
 846
 847   set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
 848
 849   gdbarch_init_osabi (info, gdbarch);
 850
 851   dwarf2_append_unwinders (gdbarch);
 852   frame_unwind_append_unwinder (gdbarch, &xstormy16_frame_unwind);
 853
 854   return gdbarch;
 855 }
 856
 857 /* Function: _initialize_xstormy16_tdep
 858    Initializer function for the Sanyo Xstormy16a module.
 859    Called by gdb at start-up.  */
 860
 861 void
 862 _initialize_xstormy16_tdep (void)
 863 {
 864   register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
 865 }