gdb/xstormy16-tdep.c

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