gdb/xstormy16-tdep.c

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