gdb/xstormy16-tdep.c

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