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 "value.h"
  24 #include "inferior.h"
  25 #include "symfile.h"
  26 #include "arch-utils.h"
  27 #include "regcache.h"
  28 #include "gdbcore.h"
  29 #include "objfiles.h"
  30 #include "dis-asm.h"
  31
  32 struct gdbarch_tdep
  33 {
  34   /* gdbarch target dependent data here. Currently unused for Xstormy16. */
  35 };
  36
  37 /* Extra info which is saved in each frame_info. */
  38 struct frame_extra_info
  39 {
  40   int framesize;
  41   int frameless_p;
  42 };
  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 /* Size of instructions, registers, etc. */
  74 enum
  75 {
  76   xstormy16_inst_size = 2,
  77   xstormy16_reg_size = 2,
  78   xstormy16_pc_size = 4
  79 };
  80
  81 /* Size of return datatype which fits into the remaining return registers. */
  82 #define E_MAX_RETTYPE_SIZE(regnum)      ((E_LST_ARG_REGNUM - (regnum) + 1) \
  83                                         * xstormy16_reg_size)
  84
  85 /* Size of return datatype which fits into all return registers. */
  86 enum
  87 {
  88   E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM)
  89 };
  90
  91
  92 /* Size of all registers as a whole. */
  93 enum
  94 {
  95   E_ALL_REGS_SIZE = (E_NUM_REGS - 1) * xstormy16_reg_size + xstormy16_pc_size
  96 };
  97
  98 /* Function: xstormy16_register_name
  99    Returns the name of the standard Xstormy16 register N. */
 100
 101 static const char *
 102 xstormy16_register_name (int regnum)
 103 {
 104   static char *register_names[] = {
 105     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 106     "r8", "r9", "r10", "r11", "r12", "r13",
 107     "psw", "sp", "pc"
 108   };
 109
 110   if (regnum < 0 ||
 111       regnum >= sizeof (register_names) / sizeof (register_names[0]))
 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 /* Function: xstormy16_register_byte
 121    Returns the byte position in the register cache for register N. */
 122
 123 static int
 124 xstormy16_register_byte (int regnum)
 125 {
 126   if (regnum < 0 || regnum >= E_NUM_REGS)
 127     internal_error (__FILE__, __LINE__,
 128                     "xstormy16_register_byte: illegal register number %d",
 129                     regnum);
 130   else
 131     /* All registers occupy 2 bytes in the regcache except for PC
 132        which is the last one. Therefore the byte position is still
 133        simply a multiple of 2. */
 134     return regnum * xstormy16_reg_size;
 135 }
 136
 137 /* Function: xstormy16_register_raw_size
 138    Returns the number of bytes occupied by the register on the target. */
 139
 140 static int
 141 xstormy16_register_raw_size (int regnum)
 142 {
 143   if (regnum < 0 || regnum >= E_NUM_REGS)
 144     internal_error (__FILE__, __LINE__,
 145                     "xstormy16_register_raw_size: illegal register number %d",
 146                     regnum);
 147   /* Only the PC has 4 Byte, all other registers 2 Byte. */
 148   else if (regnum == E_PC_REGNUM)
 149     return xstormy16_pc_size;
 150   else
 151     return xstormy16_reg_size;
 152 }
 153
 154 /* Function: xstormy16_register_virtual_size
 155    Returns the number of bytes occupied by the register as represented
 156    internally by gdb. */
 157
 158 static int
 159 xstormy16_register_virtual_size (int regnum)
 160 {
 161   return xstormy16_register_raw_size (regnum);
 162 }
 163
 164 /* Function: xstormy16_reg_virtual_type
 165    Returns the default type for register N. */
 166
 167 static struct type *
 168 xstormy16_reg_virtual_type (int regnum)
 169 {
 170   if (regnum < 0 || regnum >= E_NUM_REGS)
 171     internal_error (__FILE__, __LINE__,
 172                     "xstormy16_register_virtual_type: illegal register number %d",
 173                     regnum);
 174   else if (regnum == E_PC_REGNUM)
 175     return builtin_type_uint32;
 176   else
 177     return builtin_type_uint16;
 178 }
 179
 180 /* Function: xstormy16_get_saved_register
 181    Find a register's saved value on the call stack. */
 182
 183 static void
 184 xstormy16_get_saved_register (char *raw_buffer,
 185                               int *optimized,
 186                               CORE_ADDR *addrp,
 187                               struct frame_info *fi,
 188                               int regnum, enum lval_type *lval)
 189 {
 190   deprecated_generic_get_saved_register (raw_buffer, optimized, addrp, fi, regnum, lval);
 191 }
 192
 193 /* Function: xstormy16_type_is_scalar
 194    Makes the decision if a given type is a scalar types.  Scalar
 195    types are returned in the registers r2-r7 as they fit. */
 196
 197 static int
 198 xstormy16_type_is_scalar (struct type *t)
 199 {
 200   return (TYPE_CODE(t) != TYPE_CODE_STRUCT
 201           && TYPE_CODE(t) != TYPE_CODE_UNION
 202           && TYPE_CODE(t) != TYPE_CODE_ARRAY);
 203 }
 204
 205 /* Function: xstormy16_extract_return_value
 206    Copy the function's return value into VALBUF.
 207    This function is called only in the context of "target function calls",
 208    ie. when the debugger forces a function to be called in the child, and
 209    when the debugger forces a function to return prematurely via the
 210    "return" command. */
 211
 212 static void
 213 xstormy16_extract_return_value (struct type *type, char *regbuf, char *valbuf)
 214 {
 215   CORE_ADDR return_buffer;
 216   int offset = 0;
 217
 218   if (xstormy16_type_is_scalar (type)
 219       && TYPE_LENGTH (type) <= E_MAX_RETTYPE_SIZE_IN_REGS)
 220     {
 221       /* Scalar return values of <= 12 bytes are returned in
 222          E_1ST_ARG_REGNUM to E_LST_ARG_REGNUM. */
 223       memcpy (valbuf,
 224               &regbuf[DEPRECATED_REGISTER_BYTE (E_1ST_ARG_REGNUM)] + offset,
 225               TYPE_LENGTH (type));
 226     }
 227   else
 228     {
 229       /* Aggregates and return values > 12 bytes are returned in memory,
 230          pointed to by R2. */
 231       return_buffer =
 232         extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (E_PTR_RET_REGNUM),
 233                                   DEPRECATED_REGISTER_RAW_SIZE (E_PTR_RET_REGNUM));
 234
 235       read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
 236     }
 237 }
 238
 239 /* Function: xstormy16_push_arguments
 240    Setup the function arguments for GDB to call a function in the inferior.
 241    Called only in the context of a target function call from the debugger.
 242    Returns the value of the SP register after the args are pushed.
 243 */
 244
 245 static CORE_ADDR
 246 xstormy16_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 247                           int struct_return, CORE_ADDR struct_addr)
 248 {
 249   CORE_ADDR stack_dest = sp;
 250   int argreg = E_1ST_ARG_REGNUM;
 251   int i, j;
 252   int typelen, slacklen;
 253   char *val;
 254
 255   /* If struct_return is true, then the struct return address will
 256      consume one argument-passing register.  */
 257   if (struct_return)
 258     argreg++;
 259
 260   /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
 261      fit in the remaining registers we're switching over to the stack.
 262      No argument is put on stack partially and as soon as we switched
 263      over to stack no further argument is put in a register even if it
 264      would fit in the remaining unused registers. */
 265   for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
 266     {
 267       typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
 268       if (typelen > E_MAX_RETTYPE_SIZE (argreg))
 269         break;
 270
 271       /* Put argument into registers wordwise. */
 272       val = VALUE_CONTENTS (args[i]);
 273       for (j = 0; j < typelen; j += xstormy16_reg_size)
 274         write_register (argreg++,
 275                         extract_unsigned_integer (val + j,
 276                                                   typelen - j ==
 277                                                   1 ? 1 :
 278                                                   xstormy16_reg_size));
 279     }
 280
 281   /* Align SP */
 282   if (stack_dest & 1)
 283     ++stack_dest;
 284
 285   /* Loop backwards through remaining arguments and push them on the stack,
 286      wordaligned. */
 287   for (j = nargs - 1; j >= i; j--)
 288     {
 289       typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[j]));
 290       slacklen = typelen & 1;
 291       val = alloca (typelen + slacklen);
 292       memcpy (val, VALUE_CONTENTS (args[j]), typelen);
 293       memset (val + typelen, 0, slacklen);
 294
 295       /* Now write this data to the stack. The stack grows upwards. */
 296       write_memory (stack_dest, val, typelen + slacklen);
 297       stack_dest += typelen + slacklen;
 298     }
 299
 300   /* And that should do it.  Return the new stack pointer. */
 301   return stack_dest;
 302 }
 303
 304 /* Function: xstormy16_push_return_address (pc)
 305    Setup the return address for GDB to call a function in the inferior.
 306    Called only in the context of a target function call from the debugger.
 307    Returns the value of the SP register when the operation is finished
 308    (which may or may not be the same as before).
 309 */
 310
 311 static CORE_ADDR
 312 xstormy16_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
 313 {
 314   unsigned char buf[xstormy16_pc_size];
 315
 316   store_unsigned_integer (buf, xstormy16_pc_size, entry_point_address ());
 317   write_memory (sp, buf, xstormy16_pc_size);
 318   return sp + xstormy16_pc_size;
 319 }
 320
 321 /* Function: xstormy16_pop_frame
 322    Destroy the innermost (Top-Of-Stack) stack frame, restoring the
 323    machine state that was in effect before the frame was created.
 324    Used in the contexts of the "return" command, and of
 325    target function calls from the debugger.
 326 */
 327
 328 static void
 329 xstormy16_pop_frame (void)
 330 {
 331   struct frame_info *fi = get_current_frame ();
 332   int i;
 333
 334   if (fi == NULL)
 335     return;                     /* paranoia */
 336
 337   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
 338                                    get_frame_base (fi)))
 339     {
 340       generic_pop_dummy_frame ();
 341     }
 342   else
 343     {
 344       /* Restore the saved regs. */
 345       for (i = 0; i < NUM_REGS; i++)
 346         if (deprecated_get_frame_saved_regs (fi)[i])
 347           {
 348             if (i == SP_REGNUM)
 349               write_register (i, deprecated_get_frame_saved_regs (fi)[i]);
 350             else if (i == E_PC_REGNUM)
 351               write_register (i, read_memory_integer (deprecated_get_frame_saved_regs (fi)[i],
 352                                                       xstormy16_pc_size));
 353             else
 354               write_register (i, read_memory_integer (deprecated_get_frame_saved_regs (fi)[i],
 355                                                       xstormy16_reg_size));
 356           }
 357       /* Restore the PC */
 358       write_register (PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (fi));
 359       flush_cached_frames ();
 360     }
 361   return;
 362 }
 363
 364 /* Function: xstormy16_store_struct_return
 365    Copy the (struct) function return value to its destined location.
 366    Called only in the context of a target function call from the debugger.
 367 */
 368
 369 static void
 370 xstormy16_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 371 {
 372   write_register (E_PTR_RET_REGNUM, addr);
 373 }
 374
 375 /* Function: xstormy16_store_return_value
 376    Copy the function return value from VALBUF into the
 377    proper location for a function return.
 378    Called only in the context of the "return" command.
 379 */
 380
 381 static void
 382 xstormy16_store_return_value (struct type *type, char *valbuf)
 383 {
 384   CORE_ADDR return_buffer;
 385   char buf[xstormy16_reg_size];
 386
 387   if (xstormy16_type_is_scalar (type) && TYPE_LENGTH (type) == 1)
 388     {
 389       /* Add leading zeros to the value. */
 390       memset (buf, 0, xstormy16_reg_size);
 391       memcpy (buf, valbuf, 1);
 392       deprecated_write_register_gen (E_1ST_ARG_REGNUM, buf);
 393     }
 394   else if (xstormy16_type_is_scalar (type) &&
 395            TYPE_LENGTH (type) <= E_MAX_RETTYPE_SIZE_IN_REGS)
 396     deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (E_1ST_ARG_REGNUM),
 397                                      valbuf, TYPE_LENGTH (type));
 398   else
 399     {
 400       return_buffer = read_register (E_PTR_RET_REGNUM);
 401       write_memory (return_buffer, valbuf, TYPE_LENGTH (type));
 402     }
 403 }
 404
 405 /* Function: xstormy16_extract_struct_value_address
 406    Returns the address in which a function should return a struct value.
 407    Used in the contexts of the "return" command, and of
 408    target function calls from the debugger.
 409 */
 410
 411 static CORE_ADDR
 412 xstormy16_extract_struct_value_address (struct regcache *regcache)
 413 {
 414   /* FIXME: cagney/2004-01-17: Does the ABI guarantee that the return
 415      address regster is preserved across function calls?  Probably
 416      not, making this function wrong.  */
 417   ULONGEST val;
 418   regcache_raw_read_unsigned (regcache, E_PTR_RET_REGNUM, &val);
 419   return val;
 420 }
 421
 422 /* Function: xstormy16_use_struct_convention
 423    Returns non-zero if the given struct type will be returned using
 424    a special convention, rather than the normal function return method.
 425    7sed in the contexts of the "return" command, and of
 426    target function calls from the debugger.
 427 */
 428
 429 static int
 430 xstormy16_use_struct_convention (int gcc_p, struct type *type)
 431 {
 432   return !xstormy16_type_is_scalar (type)
 433     || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
 434 }
 435
 436 /* Function: frame_saved_register
 437    Returns the value that regnum had in frame fi
 438    (saved in fi or in one of its children).
 439 */
 440
 441 static CORE_ADDR
 442 xstormy16_frame_saved_register (struct frame_info *fi, int regnum)
 443 {
 444   int size = xstormy16_register_raw_size (regnum);
 445   char *buf = (char *) alloca (size);
 446
 447   deprecated_generic_get_saved_register (buf, NULL, NULL, fi, regnum, NULL);
 448   return (CORE_ADDR) extract_unsigned_integer (buf, size);
 449 }
 450
 451 /* Function: xstormy16_scan_prologue
 452    Decode the instructions within the given address range.
 453    Decide when we must have reached the end of the function prologue.
 454    If a frame_info pointer is provided, fill in its saved_regs etc.
 455
 456    Returns the address of the first instruction after the prologue.
 457 */
 458
 459 static CORE_ADDR
 460 xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
 461                          struct frame_info *fi, int *frameless)
 462 {
 463   CORE_ADDR sp = 0, fp = 0;
 464   CORE_ADDR next_addr;
 465   ULONGEST inst, inst2;
 466   LONGEST offset;
 467   int regnum;
 468
 469   if (frameless)
 470     *frameless = 1;
 471   if (fi)
 472     {
 473       /* In a call dummy, don't touch the frame. */
 474       if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
 475                                        get_frame_base (fi)))
 476         return start_addr;
 477
 478       /* Grab the frame-relative values of SP and FP, needed below.
 479          The frame_saved_register function will find them on the
 480          stack or in the registers as appropriate. */
 481       sp = xstormy16_frame_saved_register (fi, E_SP_REGNUM);
 482       fp = xstormy16_frame_saved_register (fi, E_FP_REGNUM);
 483
 484       /* Initialize framesize with size of PC put on stack by CALLF inst. */
 485       get_frame_extra_info (fi)->framesize = xstormy16_pc_size;
 486     }
 487   for (next_addr = start_addr;
 488        next_addr < end_addr; next_addr += xstormy16_inst_size)
 489     {
 490       inst = read_memory_unsigned_integer (next_addr, xstormy16_inst_size);
 491       inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
 492                                             xstormy16_inst_size);
 493
 494       if (inst >= 0x0082 && inst <= 0x008d)     /* push r2 .. push r13 */
 495         {
 496           if (fi)
 497             {
 498               regnum = inst & 0x000f;
 499               deprecated_get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize;
 500               get_frame_extra_info (fi)->framesize += xstormy16_reg_size;
 501             }
 502         }
 503
 504       /* optional stack allocation for args and local vars <= 4 byte */
 505       else if (inst == 0x301f || inst == 0x303f)        /* inc r15, #0x1/#0x3 */
 506         {
 507           if (fi)               /* Record the frame size. */
 508             get_frame_extra_info (fi)->framesize += ((inst & 0x0030) >> 4) + 1;
 509         }
 510
 511       /* optional stack allocation for args and local vars > 4 && < 16 byte */
 512       else if ((inst & 0xff0f) == 0x510f)       /* 51Hf   add r15, #0xH */
 513         {
 514           if (fi)               /* Record the frame size. */
 515             get_frame_extra_info (fi)->framesize += (inst & 0x00f0) >> 4;
 516         }
 517
 518       /* optional stack allocation for args and local vars >= 16 byte */
 519       else if (inst == 0x314f && inst2 >= 0x0010)       /* 314f HHHH  add r15, #0xH */
 520         {
 521           if (fi)               /* Record the frame size. */
 522             get_frame_extra_info (fi)->framesize += inst2;
 523           next_addr += xstormy16_inst_size;
 524         }
 525
 526       else if (inst == 0x46fd)  /* mov r13, r15 */
 527         {
 528           if (fi)               /* Record that the frame pointer is in use. */
 529             get_frame_extra_info (fi)->frameless_p = 0;
 530           if (frameless)
 531             *frameless = 0;
 532         }
 533
 534       /* optional copying of args in r2-r7 to r10-r13 */
 535       /* Probably only in optimized case but legal action for prologue */
 536       else if ((inst & 0xff00) == 0x4600        /* 46SD   mov rD, rS */
 537                && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
 538                && (inst & 0x000f) >= 0x00a0 && (inst & 0x000f) <= 0x000d)
 539         ;
 540
 541       /* optional copying of args in r2-r7 to stack */
 542       /* 72DS HHHH   mov.b (rD, 0xHHHH), r(S-8) (bit3 always 1, bit2-0 = reg) */
 543       /* 73DS HHHH   mov.w (rD, 0xHHHH), r(S-8) */
 544       else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
 545         {
 546           if (fi)
 547             {
 548               regnum = inst & 0x0007;
 549               /* Only 12 of 16 bits of the argument are used for the
 550                  signed offset. */
 551               offset = (LONGEST) (inst2 & 0x0fff);
 552               if (offset & 0x0800)
 553                 offset -= 0x1000;
 554
 555               deprecated_get_frame_saved_regs (fi)[regnum] = get_frame_extra_info (fi)->framesize + offset;
 556             }
 557           next_addr += xstormy16_inst_size;
 558         }
 559
 560 #if 0
 561       /* 2001-08-10: Not part of the prologue anymore due to change in
 562          ABI. r8 and r9 are not used for argument passing anymore. */
 563
 564       /* optional copying of r8, r9 to stack */
 565       /* 46S7; 73Df HHHH   mov.w r7,rS; mov.w (rD, 0xHHHH), r7 D=8,9; S=13,15 */
 566       /* 46S7; 72df HHHH   mov.w r7,rS; mov.b (rD, 0xHHHH), r7 D=8,9; S=13,15 */
 567       else if ((inst & 0xffef) == 0x4687 && (inst2 & 0xfedf) == 0x72df)
 568         {
 569           next_addr += xstormy16_inst_size;
 570           if (fi)
 571             {
 572               regnum = (inst & 0x00f0) >> 4;
 573               inst = inst2;
 574               inst2 = read_memory_unsigned_integer (next_addr
 575                                                     + xstormy16_inst_size,
 576                                                     xstormy16_inst_size);
 577               /* Only 12 of 16 bits of the argument are used for the
 578                  signed offset. */
 579               offset = (LONGEST) (inst2 & 0x0fff);
 580               if (offset & 0x0800)
 581                 offset -= 0x1000;
 582
 583               fi->saved_regs[regnum] = fi->extra_info->framesize + offset;
 584             }
 585           next_addr += xstormy16_inst_size;
 586         }
 587 #endif
 588
 589       else                      /* Not a prologue instruction. */
 590         break;
 591     }
 592
 593   if (fi)
 594     {
 595       /* Special handling for the "saved" address of the SP:
 596          The SP is of course never saved on the stack at all, so
 597          by convention what we put here is simply the previous
 598          _value_ of the SP (as opposed to an address where the
 599          previous value would have been pushed).  */
 600       if (get_frame_extra_info (fi)->frameless_p)
 601         {
 602           deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM] = sp - get_frame_extra_info (fi)->framesize;
 603           deprecated_update_frame_base_hack (fi, sp);
 604         }
 605       else
 606         {
 607           deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM] = fp - get_frame_extra_info (fi)->framesize;
 608           deprecated_update_frame_base_hack (fi, fp);
 609         }
 610
 611       /* So far only offsets to the beginning of the frame are
 612          saved in the saved_regs. Now we now the relation between
 613          sp, fp and framesize. We know the beginning of the frame
 614          so we can translate the register offsets to real addresses. */
 615       for (regnum = 0; regnum < E_SP_REGNUM; ++regnum)
 616         if (deprecated_get_frame_saved_regs (fi)[regnum])
 617           deprecated_get_frame_saved_regs (fi)[regnum] += deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM];
 618
 619       /* Save address of PC on stack. */
 620       deprecated_get_frame_saved_regs (fi)[E_PC_REGNUM] = deprecated_get_frame_saved_regs (fi)[E_SP_REGNUM];
 621     }
 622
 623   return next_addr;
 624 }
 625
 626 /* Function: xstormy16_skip_prologue
 627    If the input address is in a function prologue,
 628    returns the address of the end of the prologue;
 629    else returns the input address.
 630
 631    Note: the input address is likely to be the function start,
 632    since this function is mainly used for advancing a breakpoint
 633    to the first line, or stepping to the first line when we have
 634    stepped into a function call.  */
 635
 636 static CORE_ADDR
 637 xstormy16_skip_prologue (CORE_ADDR pc)
 638 {
 639   CORE_ADDR func_addr = 0, func_end = 0;
 640   char *func_name;
 641
 642   if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
 643     {
 644       struct symtab_and_line sal;
 645       struct symbol *sym;
 646
 647       /* Don't trust line number debug info in frameless functions. */
 648       int frameless = 1;
 649       CORE_ADDR plg_end = xstormy16_scan_prologue (func_addr, func_end,
 650                                                    NULL, &frameless);
 651       if (frameless)
 652         return plg_end;
 653
 654       /* Found a function.  */
 655       sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL, NULL);
 656       /* Don't use line number debug info for assembly source files. */
 657       if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
 658         {
 659           sal = find_pc_line (func_addr, 0);
 660           if (sal.end && sal.end < func_end)
 661             {
 662               /* Found a line number, use it as end of prologue.  */
 663               return sal.end;
 664             }
 665         }
 666       /* No useable line symbol.  Use result of prologue parsing method. */
 667       return plg_end;
 668     }
 669
 670   /* No function symbol -- just return the PC. */
 671
 672   return (CORE_ADDR) pc;
 673 }
 674
 675 /* The epilogue is defined here as the area at the end of a function,
 676    either on the `ret' instruction itself or after an instruction which
 677    destroys the function's stack frame. */
 678 static int
 679 xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 680 {
 681   CORE_ADDR addr, func_addr = 0, func_end = 0;
 682
 683   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 684     {
 685       ULONGEST inst, inst2;
 686       CORE_ADDR addr = func_end - xstormy16_inst_size;
 687
 688       /* The Xstormy16 epilogue is max. 14 bytes long. */
 689       if (pc < func_end - 7 * xstormy16_inst_size)
 690         return 0;
 691
 692       /* Check if we're on a `ret' instruction.  Otherwise it's
 693          too dangerous to proceed. */
 694       inst = read_memory_unsigned_integer (addr, xstormy16_inst_size);
 695       if (inst != 0x0003)
 696         return 0;
 697
 698       while ((addr -= xstormy16_inst_size) >= func_addr)
 699         {
 700           inst = read_memory_unsigned_integer (addr, xstormy16_inst_size);
 701           if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
 702             continue;
 703           if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
 704             break;
 705           inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
 706                                                 xstormy16_inst_size);
 707           if (inst2 == 0x314f && inst >= 0x8000)        /* add r15, neg. value */
 708             {
 709               addr -= xstormy16_inst_size;
 710               break;
 711             }
 712           return 0;
 713         }
 714       if (pc > addr)
 715         return 1;
 716     }
 717   return 0;
 718 }
 719
 720 /* Function: xstormy16_frame_init_saved_regs
 721    Set up the 'saved_regs' array.
 722    This is a data structure containing the addresses on the stack
 723    where each register has been saved, for each stack frame.
 724    Registers that have not been saved will have zero here.
 725    The stack register is special: rather than the address where the
 726    stack register has been saved, saved_regs[SP_REGNUM] will have the
 727    actual value of the previous frame's stack register.
 728
 729    This function may be called in any context where the saved register
 730    values may be needed (backtrace, frame_info, frame_register).  On
 731    many targets, it is called directly by init_extra_frame_info, in
 732    part because the information may be needed immediately by
 733    frame_chain.  */
 734
 735 static void
 736 xstormy16_frame_init_saved_regs (struct frame_info *fi)
 737 {
 738   CORE_ADDR func_addr, func_end;
 739
 740   if (!deprecated_get_frame_saved_regs (fi))
 741     {
 742       frame_saved_regs_zalloc (fi);
 743
 744       /* Find the beginning of this function, so we can analyze its
 745          prologue. */
 746       if (find_pc_partial_function (get_frame_pc (fi), NULL, &func_addr, &func_end))
 747         xstormy16_scan_prologue (func_addr, get_frame_pc (fi), fi, NULL);
 748       /* Else we're out of luck (can't debug completely stripped code).
 749          FIXME. */
 750     }
 751 }
 752
 753 /* Function: xstormy16_frame_saved_pc
 754    Returns the return address for the selected frame.
 755    Called by frame_info, legacy_frame_chain_valid, and sometimes by
 756    get_prev_frame.  */
 757
 758 static CORE_ADDR
 759 xstormy16_frame_saved_pc (struct frame_info *fi)
 760 {
 761   CORE_ADDR saved_pc;
 762
 763   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
 764                                    get_frame_base (fi)))
 765     {
 766       saved_pc = deprecated_read_register_dummy (get_frame_pc (fi),
 767                                                  get_frame_base (fi),
 768                                                  E_PC_REGNUM);
 769     }
 770   else
 771     {
 772       saved_pc = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[E_PC_REGNUM],
 773                                                xstormy16_pc_size);
 774     }
 775
 776   return saved_pc;
 777 }
 778
 779 /* Function: xstormy16_init_extra_frame_info
 780    This is the constructor function for the frame_info struct,
 781    called whenever a new frame_info is created (from create_new_frame,
 782    and from get_prev_frame).
 783 */
 784
 785 static void
 786 xstormy16_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 787 {
 788   if (!get_frame_extra_info (fi))
 789     {
 790       frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
 791       get_frame_extra_info (fi)->framesize = 0;
 792       get_frame_extra_info (fi)->frameless_p = 1;       /* Default frameless, detect framed */
 793
 794       /* By default, the fi->frame is set to the value of the FP reg by gdb.
 795          This may not always be right; we may be in a frameless function,
 796          or we may be in the prologue, before the FP has been set up.
 797          Unfortunately, we can't make this determination without first
 798          calling scan_prologue, and we can't do that unles we know the
 799          get_frame_pc (fi).  */
 800
 801       if (!get_frame_pc (fi))
 802         {
 803           /* Sometimes we are called from get_prev_frame without
 804              the PC being set up first.  Long history, don't ask.
 805              Fortunately this will never happen from the outermost
 806              frame, so we should be able to get the saved pc from
 807              the next frame. */
 808           if (get_next_frame (fi))
 809             deprecated_update_frame_pc_hack (fi, xstormy16_frame_saved_pc (get_next_frame (fi)));
 810         }
 811
 812       /* Take care of the saved_regs right here (non-lazy). */
 813       xstormy16_frame_init_saved_regs (fi);
 814     }
 815 }
 816
 817 /* Function: xstormy16_frame_chain
 818    Returns a pointer to the stack frame of the calling function.
 819    Called only from get_prev_frame.  Needed for backtrace, "up", etc.
 820 */
 821
 822 static CORE_ADDR
 823 xstormy16_frame_chain (struct frame_info *fi)
 824 {
 825   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
 826                                    get_frame_base (fi)))
 827     {
 828       /* Call dummy's frame is the same as caller's.  */
 829       return get_frame_base (fi);
 830     }
 831   else
 832     {
 833       /* Return computed offset from this frame's fp. */
 834       return get_frame_base (fi) - get_frame_extra_info (fi)->framesize;
 835     }
 836 }
 837
 838 static int
 839 xstormy16_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
 840 {
 841   return chain < 0x8000 && DEPRECATED_FRAME_SAVED_PC (thisframe) >= 0x8000 &&
 842     (get_frame_extra_info (thisframe)->frameless_p ||
 843      get_frame_base (thisframe) - get_frame_extra_info (thisframe)->framesize == chain);
 844 }
 845
 846 /* Function: xstormy16_saved_pc_after_call Returns the previous PC
 847    immediately after a function call.  This function is meant to
 848    bypass the regular frame_register() mechanism, ie. it is meant to
 849    work even if the frame isn't complete.  Called by
 850    step_over_function, and sometimes by get_prev_frame.  */
 851
 852 static CORE_ADDR
 853 xstormy16_saved_pc_after_call (struct frame_info *ignore)
 854 {
 855   CORE_ADDR sp, pc, tmp;
 856
 857   sp = read_register (E_SP_REGNUM) - xstormy16_pc_size;
 858   pc = read_memory_integer (sp, xstormy16_pc_size);
 859
 860   /* Skip over jump table entry if necessary.  */
 861   if ((tmp = SKIP_TRAMPOLINE_CODE (pc)))
 862     pc = tmp;
 863
 864   return pc;
 865 }
 866
 867 const static unsigned char *
 868 xstormy16_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 869 {
 870   static unsigned char breakpoint[] = { 0x06, 0x0 };
 871   *lenptr = sizeof (breakpoint);
 872   return breakpoint;
 873 }
 874
 875 /* Given a pointer to a jump table entry, return the address
 876    of the function it jumps to.  Return 0 if not found. */
 877 static CORE_ADDR
 878 xstormy16_resolve_jmp_table_entry (CORE_ADDR faddr)
 879 {
 880   struct obj_section *faddr_sect = find_pc_section (faddr);
 881
 882   if (faddr_sect)
 883     {
 884       LONGEST inst, inst2, addr;
 885       char buf[2 * xstormy16_inst_size];
 886
 887       /* Return faddr if it's not pointing into the jump table. */
 888       if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
 889         return faddr;
 890
 891       if (!target_read_memory (faddr, buf, sizeof buf))
 892         {
 893           inst = extract_unsigned_integer (buf, xstormy16_inst_size);
 894           inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
 895                                             xstormy16_inst_size);
 896           addr = inst2 << 8 | (inst & 0xff);
 897           return addr;
 898         }
 899     }
 900   return 0;
 901 }
 902
 903 /* Given a function's address, attempt to find (and return) the
 904    address of the corresponding jump table entry.  Return 0 if
 905    not found. */
 906 static CORE_ADDR
 907 xstormy16_find_jmp_table_entry (CORE_ADDR faddr)
 908 {
 909   struct obj_section *faddr_sect = find_pc_section (faddr);
 910
 911   if (faddr_sect)
 912     {
 913       struct obj_section *osect;
 914
 915       /* Return faddr if it's already a pointer to a jump table entry. */
 916       if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
 917         return faddr;
 918
 919       ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
 920       {
 921         if (!strcmp (osect->the_bfd_section->name, ".plt"))
 922           break;
 923       }
 924
 925       if (osect < faddr_sect->objfile->sections_end)
 926         {
 927           CORE_ADDR addr;
 928           for (addr = osect->addr;
 929                addr < osect->endaddr; addr += 2 * xstormy16_inst_size)
 930             {
 931               int status;
 932               LONGEST inst, inst2, faddr2;
 933               char buf[2 * xstormy16_inst_size];
 934
 935               if (target_read_memory (addr, buf, sizeof buf))
 936                 return 0;
 937               inst = extract_unsigned_integer (buf, xstormy16_inst_size);
 938               inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
 939                                                 xstormy16_inst_size);
 940               faddr2 = inst2 << 8 | (inst & 0xff);
 941               if (faddr == faddr2)
 942                 return addr;
 943             }
 944         }
 945     }
 946   return 0;
 947 }
 948
 949 static CORE_ADDR
 950 xstormy16_skip_trampoline_code (CORE_ADDR pc)
 951 {
 952   int tmp = xstormy16_resolve_jmp_table_entry (pc);
 953
 954   if (tmp && tmp != pc)
 955     return tmp;
 956   return 0;
 957 }
 958
 959 static int
 960 xstormy16_in_solib_call_trampoline (CORE_ADDR pc, char *name)
 961 {
 962   return xstormy16_skip_trampoline_code (pc) != 0;
 963 }
 964
 965 static CORE_ADDR
 966 xstormy16_pointer_to_address (struct type *type, const void *buf)
 967 {
 968   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 969   CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
 970
 971   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
 972     {
 973       CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (addr);
 974       if (addr2)
 975         addr = addr2;
 976     }
 977
 978   return addr;
 979 }
 980
 981 static void
 982 xstormy16_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 983 {
 984   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 985
 986   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
 987     {
 988       CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (addr);
 989       if (addr2)
 990         addr = addr2;
 991     }
 992   store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
 993 }
 994
 995 static CORE_ADDR
 996 xstormy16_stack_align (CORE_ADDR addr)
 997 {
 998   if (addr & 1)
 999     ++addr;
1000   return addr;
1001 }
1002
1003 static void
1004 xstormy16_save_dummy_frame_tos (CORE_ADDR sp)
1005 {
1006   generic_save_dummy_frame_tos (sp - xstormy16_pc_size);
1007 }
1008
1009 /* Function: xstormy16_gdbarch_init
1010    Initializer function for the xstormy16 gdbarch vector.
1011    Called by gdbarch.  Sets up the gdbarch vector(s) for this target. */
1012
1013 static struct gdbarch *
1014 xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1015 {
1016   static LONGEST call_dummy_words[1] = { 0 };
1017   struct gdbarch_tdep *tdep = NULL;
1018   struct gdbarch *gdbarch;
1019
1020   /* find a candidate among the list of pre-declared architectures. */
1021   arches = gdbarch_list_lookup_by_info (arches, &info);
1022   if (arches != NULL)
1023     return (arches->gdbarch);
1024
1025 #if 0
1026   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1027 #endif
1028
1029   gdbarch = gdbarch_alloc (&info, 0);
1030
1031   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1032      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
1033   set_gdbarch_deprecated_init_frame_pc (gdbarch, deprecated_init_frame_pc_default);
1034
1035   /*
1036    * Basic register fields and methods.
1037    */
1038
1039   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
1040   set_gdbarch_num_pseudo_regs (gdbarch, 0);
1041   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1042   set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
1043   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1044   set_gdbarch_register_name (gdbarch, xstormy16_register_name);
1045   set_gdbarch_deprecated_register_size (gdbarch, xstormy16_reg_size);
1046   set_gdbarch_deprecated_register_bytes (gdbarch, E_ALL_REGS_SIZE);
1047   set_gdbarch_deprecated_register_byte (gdbarch, xstormy16_register_byte);
1048   set_gdbarch_deprecated_register_raw_size (gdbarch, xstormy16_register_raw_size);
1049   set_gdbarch_deprecated_max_register_raw_size (gdbarch, xstormy16_pc_size);
1050   set_gdbarch_deprecated_register_virtual_size (gdbarch, xstormy16_register_raw_size);
1051   set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 4);
1052   set_gdbarch_deprecated_register_virtual_type (gdbarch, xstormy16_reg_virtual_type);
1053
1054   /*
1055    * Frame Info
1056    */
1057   set_gdbarch_deprecated_init_extra_frame_info (gdbarch,
1058                                      xstormy16_init_extra_frame_info);
1059   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch,
1060                                      xstormy16_frame_init_saved_regs);
1061   set_gdbarch_deprecated_frame_chain (gdbarch, xstormy16_frame_chain);
1062   set_gdbarch_deprecated_get_saved_register (gdbarch, xstormy16_get_saved_register);
1063   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, xstormy16_saved_pc_after_call);
1064   set_gdbarch_deprecated_frame_saved_pc (gdbarch, xstormy16_frame_saved_pc);
1065   set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
1066   set_gdbarch_deprecated_frame_chain_valid (gdbarch, xstormy16_frame_chain_valid);
1067
1068   set_gdbarch_in_function_epilogue_p (gdbarch,
1069                                       xstormy16_in_function_epilogue_p);
1070
1071   /*
1072    * Miscelany
1073    */
1074   /* Stack grows up. */
1075   set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
1076   /* This value is almost never non-zero... */
1077   set_gdbarch_frame_args_skip (gdbarch, 0);
1078
1079   /*
1080    * Call Dummies
1081    *
1082    * These values and methods are used when gdb calls a target function.  */
1083   set_gdbarch_deprecated_push_return_address (gdbarch, xstormy16_push_return_address);
1084   set_gdbarch_deprecated_extract_return_value (gdbarch, xstormy16_extract_return_value);
1085   set_gdbarch_deprecated_push_arguments (gdbarch, xstormy16_push_arguments);
1086   set_gdbarch_deprecated_pop_frame (gdbarch, xstormy16_pop_frame);
1087   set_gdbarch_deprecated_store_struct_return (gdbarch, xstormy16_store_struct_return);
1088   set_gdbarch_deprecated_store_return_value (gdbarch, xstormy16_store_return_value);
1089   set_gdbarch_extract_struct_value_address (gdbarch, xstormy16_extract_struct_value_address);
1090   set_gdbarch_use_struct_convention (gdbarch,
1091                                      xstormy16_use_struct_convention);
1092   set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words);
1093   set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
1094   set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
1095
1096   set_gdbarch_char_signed (gdbarch, 0);
1097   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1098   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1099   set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1100   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1101
1102   set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
1103   set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
1104
1105   set_gdbarch_deprecated_stack_align (gdbarch, xstormy16_stack_align);
1106
1107   set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch, xstormy16_save_dummy_frame_tos);
1108
1109   set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
1110
1111   set_gdbarch_in_solib_call_trampoline (gdbarch,
1112                                         xstormy16_in_solib_call_trampoline);
1113
1114   /* Should be using push_dummy_call.  */
1115   set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
1116
1117   set_gdbarch_print_insn (gdbarch, print_insn_xstormy16);
1118
1119   return gdbarch;
1120 }
1121
1122 /* Function: _initialize_xstormy16_tdep
1123    Initializer function for the Sanyo Xstormy16a module.
1124    Called by gdb at start-up. */
1125
1126 extern initialize_file_ftype _initialize_xstormy16_tdep; /* -Wmissing-prototypes */
1127
1128 void
1129 _initialize_xstormy16_tdep (void)
1130 {
1131   register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
1132 }