gdb/sh-tdep.c

   1 /* Target-dependent code for Renesas Super-H, for GDB.
   2
   3    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   4    2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 /*
  24    Contributed by Steve Chamberlain
  25    sac@cygnus.com
  26  */
  27
  28 #include "defs.h"
  29 #include "frame.h"
  30 #include "frame-base.h"
  31 #include "frame-unwind.h"
  32 #include "dwarf2-frame.h"
  33 #include "symtab.h"
  34 #include "gdbtypes.h"
  35 #include "gdbcmd.h"
  36 #include "gdbcore.h"
  37 #include "value.h"
  38 #include "dis-asm.h"
  39 #include "inferior.h"
  40 #include "gdb_string.h"
  41 #include "gdb_assert.h"
  42 #include "arch-utils.h"
  43 #include "floatformat.h"
  44 #include "regcache.h"
  45 #include "doublest.h"
  46 #include "osabi.h"
  47
  48 #include "sh-tdep.h"
  49
  50 #include "elf-bfd.h"
  51 #include "solib-svr4.h"
  52
  53 /* sh flags */
  54 #include "elf/sh.h"
  55 /* registers numbers shared with the simulator */
  56 #include "gdb/sim-sh.h"
  57
  58 static void (*sh_show_regs) (void);
  59
  60 #define SH_NUM_REGS 67
  61
  62 struct sh_frame_cache
  63 {
  64   /* Base address.  */
  65   CORE_ADDR base;
  66   LONGEST sp_offset;
  67   CORE_ADDR pc;
  68
  69   /* Flag showing that a frame has been created in the prologue code. */
  70   int uses_fp;
  71
  72   /* Saved registers.  */
  73   CORE_ADDR saved_regs[SH_NUM_REGS];
  74   CORE_ADDR saved_sp;
  75 };
  76
  77 static const char *
  78 sh_sh_register_name (int reg_nr)
  79 {
  80   static char *register_names[] = {
  81     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  82     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
  83     "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
  84     "", "",
  85     "", "", "", "", "", "", "", "",
  86     "", "", "", "", "", "", "", "",
  87     "", "",
  88     "", "", "", "", "", "", "", "",
  89     "", "", "", "", "", "", "", "",
  90     "", "", "", "", "", "", "", "",
  91   };
  92   if (reg_nr < 0)
  93     return NULL;
  94   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
  95     return NULL;
  96   return register_names[reg_nr];
  97 }
  98
  99 static const char *
 100 sh_sh3_register_name (int reg_nr)
 101 {
 102   static char *register_names[] = {
 103     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 104     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 105     "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
 106     "", "",
 107     "", "", "", "", "", "", "", "",
 108     "", "", "", "", "", "", "", "",
 109     "ssr", "spc",
 110     "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
 111     "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1"
 112     "", "", "", "", "", "", "", "",
 113   };
 114   if (reg_nr < 0)
 115     return NULL;
 116   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 117     return NULL;
 118   return register_names[reg_nr];
 119 }
 120
 121 static const char *
 122 sh_sh3e_register_name (int reg_nr)
 123 {
 124   static char *register_names[] = {
 125     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 126     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 127     "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
 128     "fpul", "fpscr",
 129     "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
 130     "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 131     "ssr", "spc",
 132     "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
 133     "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
 134     "", "", "", "", "", "", "", "",
 135   };
 136   if (reg_nr < 0)
 137     return NULL;
 138   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 139     return NULL;
 140   return register_names[reg_nr];
 141 }
 142
 143 static const char *
 144 sh_sh2e_register_name (int reg_nr)
 145 {
 146   static char *register_names[] = {
 147     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 148     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 149     "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
 150     "fpul", "fpscr",
 151     "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
 152     "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 153     "", "",
 154     "", "", "", "", "", "", "", "",
 155     "", "", "", "", "", "", "", "",
 156     "", "", "", "", "", "", "", "",
 157   };
 158   if (reg_nr < 0)
 159     return NULL;
 160   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 161     return NULL;
 162   return register_names[reg_nr];
 163 }
 164
 165 static const char *
 166 sh_sh2a_register_name (int reg_nr)
 167 {
 168   static char *register_names[] = {
 169     /* general registers 0-15 */
 170     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 171     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 172     /* 16 - 22 */
 173     "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
 174     /* 23, 24 */
 175     "fpul", "fpscr",
 176     /* floating point registers 25 - 40 */
 177     "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
 178     "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 179     /* 41, 42 */
 180     "", "",
 181     /* 43 - 62.  Banked registers.  The bank number used is determined by
 182        the bank register (63). */
 183     "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b",
 184     "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b",
 185     "machb", "ivnb", "prb", "gbrb", "maclb",
 186     /* 63: register bank number, not a real register but used to
 187        communicate the register bank currently get/set.  This register
 188        is hidden to the user, who manipulates it using the pseudo
 189        register called "bank" (67).  See below.  */
 190     "",
 191     /* 64 - 66 */
 192     "ibcr", "ibnr", "tbr",
 193     /* 67: register bank number, the user visible pseudo register.  */
 194     "bank",
 195     /* double precision (pseudo) 68 - 75 */
 196     "dr0", "dr2", "dr4", "dr6", "dr8", "dr10", "dr12", "dr14",
 197   };
 198   if (reg_nr < 0)
 199     return NULL;
 200   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 201     return NULL;
 202   return register_names[reg_nr];
 203 }
 204
 205 static const char *
 206 sh_sh2a_nofpu_register_name (int reg_nr)
 207 {
 208   static char *register_names[] = {
 209     /* general registers 0-15 */
 210     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 211     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 212     /* 16 - 22 */
 213     "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
 214     /* 23, 24 */
 215     "", "",
 216     /* floating point registers 25 - 40 */
 217     "", "", "", "", "", "", "", "",
 218     "", "", "", "", "", "", "", "",
 219     /* 41, 42 */
 220     "", "",
 221     /* 43 - 62.  Banked registers.  The bank number used is determined by
 222        the bank register (63). */
 223     "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b",
 224     "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b",
 225     "machb", "ivnb", "prb", "gbrb", "maclb",
 226     /* 63: register bank number, not a real register but used to
 227        communicate the register bank currently get/set.  This register
 228        is hidden to the user, who manipulates it using the pseudo
 229        register called "bank" (67).  See below.  */
 230     "",
 231     /* 64 - 66 */
 232     "ibcr", "ibnr", "tbr",
 233     /* 67: register bank number, the user visible pseudo register.  */
 234     "bank",
 235     /* double precision (pseudo) 68 - 75 */
 236     "", "", "", "", "", "", "", "",
 237   };
 238   if (reg_nr < 0)
 239     return NULL;
 240   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 241     return NULL;
 242   return register_names[reg_nr];
 243 }
 244
 245 static const char *
 246 sh_sh_dsp_register_name (int reg_nr)
 247 {
 248   static char *register_names[] = {
 249     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 250     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 251     "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
 252     "", "dsr",
 253     "a0g", "a0", "a1g", "a1", "m0", "m1", "x0", "x1",
 254     "y0", "y1", "", "", "", "", "", "mod",
 255     "", "",
 256     "rs", "re", "", "", "", "", "", "",
 257     "", "", "", "", "", "", "", "",
 258     "", "", "", "", "", "", "", "",
 259   };
 260   if (reg_nr < 0)
 261     return NULL;
 262   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 263     return NULL;
 264   return register_names[reg_nr];
 265 }
 266
 267 static const char *
 268 sh_sh3_dsp_register_name (int reg_nr)
 269 {
 270   static char *register_names[] = {
 271     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 272     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 273     "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
 274     "", "dsr",
 275     "a0g", "a0", "a1g", "a1", "m0", "m1", "x0", "x1",
 276     "y0", "y1", "", "", "", "", "", "mod",
 277     "ssr", "spc",
 278     "rs", "re", "", "", "", "", "", "",
 279     "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b",
 280     "", "", "", "", "", "", "", "",
 281     "", "", "", "", "", "", "", "",
 282   };
 283   if (reg_nr < 0)
 284     return NULL;
 285   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 286     return NULL;
 287   return register_names[reg_nr];
 288 }
 289
 290 static const char *
 291 sh_sh4_register_name (int reg_nr)
 292 {
 293   static char *register_names[] = {
 294     /* general registers 0-15 */
 295     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 296     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 297     /* 16 - 22 */
 298     "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
 299     /* 23, 24 */
 300     "fpul", "fpscr",
 301     /* floating point registers 25 - 40 */
 302     "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
 303     "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 304     /* 41, 42 */
 305     "ssr", "spc",
 306     /* bank 0 43 - 50 */
 307     "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
 308     /* bank 1 51 - 58 */
 309     "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
 310     "", "", "", "", "", "", "", "",
 311     /* pseudo bank register. */
 312     "",
 313     /* double precision (pseudo) 59 - 66 */
 314     "dr0", "dr2", "dr4", "dr6", "dr8", "dr10", "dr12", "dr14",
 315     /* vectors (pseudo) 67 - 70 */
 316     "fv0", "fv4", "fv8", "fv12",
 317     /* FIXME: missing XF 71 - 86 */
 318     /* FIXME: missing XD 87 - 94 */
 319   };
 320   if (reg_nr < 0)
 321     return NULL;
 322   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 323     return NULL;
 324   return register_names[reg_nr];
 325 }
 326
 327 static const char *
 328 sh_sh4_nofpu_register_name (int reg_nr)
 329 {
 330   static char *register_names[] = {
 331     /* general registers 0-15 */
 332     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 333     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 334     /* 16 - 22 */
 335     "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
 336     /* 23, 24 */
 337     "", "",
 338     /* floating point registers 25 - 40 -- not for nofpu target */
 339     "", "", "", "", "", "", "", "",
 340     "", "", "", "", "", "", "", "",
 341     /* 41, 42 */
 342     "ssr", "spc",
 343     /* bank 0 43 - 50 */
 344     "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
 345     /* bank 1 51 - 58 */
 346     "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
 347     "", "", "", "", "", "", "", "",
 348     /* pseudo bank register. */
 349     "",
 350     /* double precision (pseudo) 59 - 66 -- not for nofpu target */
 351     "", "", "", "", "", "", "", "",
 352     /* vectors (pseudo) 67 - 70 -- not for nofpu target */
 353     "", "", "", "",
 354   };
 355   if (reg_nr < 0)
 356     return NULL;
 357   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 358     return NULL;
 359   return register_names[reg_nr];
 360 }
 361
 362 static const char *
 363 sh_sh4al_dsp_register_name (int reg_nr)
 364 {
 365   static char *register_names[] = {
 366     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 367     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 368     "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
 369     "", "dsr",
 370     "a0g", "a0", "a1g", "a1", "m0", "m1", "x0", "x1",
 371     "y0", "y1", "", "", "", "", "", "mod",
 372     "ssr", "spc",
 373     "rs", "re", "", "", "", "", "", "",
 374     "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b",
 375     "", "", "", "", "", "", "", "",
 376     "", "", "", "", "", "", "", "",
 377   };
 378   if (reg_nr < 0)
 379     return NULL;
 380   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 381     return NULL;
 382   return register_names[reg_nr];
 383 }
 384
 385 static const unsigned char *
 386 sh_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 387 {
 388   /* 0xc3c3 is trapa #c3, and it works in big and little endian modes */
 389   static unsigned char breakpoint[] = { 0xc3, 0xc3 };
 390
 391   *lenptr = sizeof (breakpoint);
 392   return breakpoint;
 393 }
 394
 395 /* Prologue looks like
 396    mov.l        r14,@-r15
 397    sts.l        pr,@-r15
 398    mov.l        <regs>,@-r15
 399    sub          <room_for_loca_vars>,r15
 400    mov          r15,r14
 401
 402    Actually it can be more complicated than this but that's it, basically.
 403  */
 404
 405 #define GET_SOURCE_REG(x)       (((x) >> 4) & 0xf)
 406 #define GET_TARGET_REG(x)       (((x) >> 8) & 0xf)
 407
 408 /* JSR @Rm         0100mmmm00001011 */
 409 #define IS_JSR(x)               (((x) & 0xf0ff) == 0x400b)
 410
 411 /* STS.L PR,@-r15  0100111100100010
 412    r15-4-->r15, PR-->(r15) */
 413 #define IS_STS(x)               ((x) == 0x4f22)
 414
 415 /* STS.L MACL,@-r15  0100111100010010
 416    r15-4-->r15, MACL-->(r15) */
 417 #define IS_MACL_STS(x)          ((x) == 0x4f12)
 418
 419 /* MOV.L Rm,@-r15  00101111mmmm0110
 420    r15-4-->r15, Rm-->(R15) */
 421 #define IS_PUSH(x)              (((x) & 0xff0f) == 0x2f06)
 422
 423 /* MOV r15,r14     0110111011110011
 424    r15-->r14  */
 425 #define IS_MOV_SP_FP(x)         ((x) == 0x6ef3)
 426
 427 /* ADD #imm,r15    01111111iiiiiiii
 428    r15+imm-->r15 */
 429 #define IS_ADD_IMM_SP(x)        (((x) & 0xff00) == 0x7f00)
 430
 431 #define IS_MOV_R3(x)            (((x) & 0xff00) == 0x1a00)
 432 #define IS_SHLL_R3(x)           ((x) == 0x4300)
 433
 434 /* ADD r3,r15      0011111100111100
 435    r15+r3-->r15 */
 436 #define IS_ADD_R3SP(x)          ((x) == 0x3f3c)
 437
 438 /* FMOV.S FRm,@-Rn  Rn-4-->Rn, FRm-->(Rn)     1111nnnnmmmm1011
 439    FMOV DRm,@-Rn    Rn-8-->Rn, DRm-->(Rn)     1111nnnnmmm01011
 440    FMOV XDm,@-Rn    Rn-8-->Rn, XDm-->(Rn)     1111nnnnmmm11011 */
 441 /* CV, 2003-08-28: Only suitable with Rn == SP, therefore name changed to
 442                    make this entirely clear. */
 443 /* #define IS_FMOV(x)           (((x) & 0xf00f) == 0xf00b) */
 444 #define IS_FPUSH(x)             (((x) & 0xff0f) == 0xff0b)
 445
 446 /* MOV Rm,Rn          Rm-->Rn        0110nnnnmmmm0011  4 <= m <= 7 */
 447 #define IS_MOV_ARG_TO_REG(x) \
 448         (((x) & 0xf00f) == 0x6003 && \
 449          ((x) & 0x00f0) >= 0x0040 && \
 450          ((x) & 0x00f0) <= 0x0070)
 451 /* MOV.L Rm,@Rn               0010nnnnmmmm0010  n = 14, 4 <= m <= 7 */
 452 #define IS_MOV_ARG_TO_IND_R14(x) \
 453         (((x) & 0xff0f) == 0x2e02 && \
 454          ((x) & 0x00f0) >= 0x0040 && \
 455          ((x) & 0x00f0) <= 0x0070)
 456 /* MOV.L Rm,@(disp*4,Rn)      00011110mmmmdddd  n = 14, 4 <= m <= 7 */
 457 #define IS_MOV_ARG_TO_IND_R14_WITH_DISP(x) \
 458         (((x) & 0xff00) == 0x1e00 && \
 459          ((x) & 0x00f0) >= 0x0040 && \
 460          ((x) & 0x00f0) <= 0x0070)
 461
 462 /* MOV.W @(disp*2,PC),Rn      1001nnnndddddddd */
 463 #define IS_MOVW_PCREL_TO_REG(x) (((x) & 0xf000) == 0x9000)
 464 /* MOV.L @(disp*4,PC),Rn      1101nnnndddddddd */
 465 #define IS_MOVL_PCREL_TO_REG(x) (((x) & 0xf000) == 0xd000)
 466 /* MOVI20 #imm20,Rn           0000nnnniiii0000 */
 467 #define IS_MOVI20(x)            (((x) & 0xf00f) == 0x0000)
 468 /* SUB Rn,R15                 00111111nnnn1000 */
 469 #define IS_SUB_REG_FROM_SP(x)   (((x) & 0xff0f) == 0x3f08)
 470
 471 #define FPSCR_SZ                (1 << 20)
 472
 473 /* The following instructions are used for epilogue testing. */
 474 #define IS_RESTORE_FP(x)        ((x) == 0x6ef6)
 475 #define IS_RTS(x)               ((x) == 0x000b)
 476 #define IS_LDS(x)               ((x) == 0x4f26)
 477 #define IS_MACL_LDS(x)          ((x) == 0x4f16)
 478 #define IS_MOV_FP_SP(x)         ((x) == 0x6fe3)
 479 #define IS_ADD_REG_TO_FP(x)     (((x) & 0xff0f) == 0x3e0c)
 480 #define IS_ADD_IMM_FP(x)        (((x) & 0xff00) == 0x7e00)
 481
 482 /* Disassemble an instruction.  */
 483 static int
 484 gdb_print_insn_sh (bfd_vma memaddr, disassemble_info * info)
 485 {
 486   info->endian = TARGET_BYTE_ORDER;
 487   return print_insn_sh (memaddr, info);
 488 }
 489
 490 static CORE_ADDR
 491 sh_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc,
 492                      struct sh_frame_cache *cache)
 493 {
 494   ULONGEST inst;
 495   CORE_ADDR opc;
 496   int offset;
 497   int sav_offset = 0;
 498   int r3_val = 0;
 499   int reg, sav_reg = -1;
 500
 501   if (pc >= current_pc)
 502     return current_pc;
 503
 504   cache->uses_fp = 0;
 505   for (opc = pc + (2 * 28); pc < opc; pc += 2)
 506     {
 507       inst = read_memory_unsigned_integer (pc, 2);
 508       /* See where the registers will be saved to */
 509       if (IS_PUSH (inst))
 510         {
 511           cache->saved_regs[GET_SOURCE_REG (inst)] = cache->sp_offset;
 512           cache->sp_offset += 4;
 513         }
 514       else if (IS_STS (inst))
 515         {
 516           cache->saved_regs[PR_REGNUM] = cache->sp_offset;
 517           cache->sp_offset += 4;
 518         }
 519       else if (IS_MACL_STS (inst))
 520         {
 521           cache->saved_regs[MACL_REGNUM] = cache->sp_offset;
 522           cache->sp_offset += 4;
 523         }
 524       else if (IS_MOV_R3 (inst))
 525         {
 526           r3_val = ((inst & 0xff) ^ 0x80) - 0x80;
 527         }
 528       else if (IS_SHLL_R3 (inst))
 529         {
 530           r3_val <<= 1;
 531         }
 532       else if (IS_ADD_R3SP (inst))
 533         {
 534           cache->sp_offset += -r3_val;
 535         }
 536       else if (IS_ADD_IMM_SP (inst))
 537         {
 538           offset = ((inst & 0xff) ^ 0x80) - 0x80;
 539           cache->sp_offset -= offset;
 540         }
 541       else if (IS_MOVW_PCREL_TO_REG (inst))
 542         {
 543           if (sav_reg < 0)
 544             {
 545               reg = GET_TARGET_REG (inst);
 546               if (reg < 14)
 547                 {
 548                   sav_reg = reg;
 549                   offset = (inst & 0xff) << 1;
 550                   sav_offset =
 551                     read_memory_integer ((pc + 4) + offset, 2);
 552                 }
 553             }
 554         }
 555       else if (IS_MOVL_PCREL_TO_REG (inst))
 556         {
 557           if (sav_reg < 0)
 558             {
 559               reg = GET_TARGET_REG (inst);
 560               if (reg < 14)
 561                 {
 562                   sav_reg = reg;
 563                   offset = (inst & 0xff) << 2;
 564                   sav_offset =
 565                     read_memory_integer (((pc & 0xfffffffc) + 4) + offset, 4);
 566                 }
 567             }
 568         }
 569       else if (IS_MOVI20 (inst))
 570         {
 571           if (sav_reg < 0)
 572             {
 573               reg = GET_TARGET_REG (inst);
 574               if (reg < 14)
 575                 {
 576                   sav_reg = reg;
 577                   sav_offset = GET_SOURCE_REG (inst) << 16;
 578                   /* MOVI20 is a 32 bit instruction! */
 579                   pc += 2;
 580                   sav_offset |= read_memory_unsigned_integer (pc, 2);
 581                   /* Now sav_offset contains an unsigned 20 bit value.
 582                      It must still get sign extended.  */
 583                   if (sav_offset & 0x00080000)
 584                     sav_offset |= 0xfff00000;
 585                 }
 586             }
 587         }
 588       else if (IS_SUB_REG_FROM_SP (inst))
 589         {
 590           reg = GET_SOURCE_REG (inst);
 591           if (sav_reg > 0 && reg == sav_reg)
 592             {
 593               sav_reg = -1;
 594             }
 595           cache->sp_offset += sav_offset;
 596         }
 597       else if (IS_FPUSH (inst))
 598         {
 599           if (read_register (FPSCR_REGNUM) & FPSCR_SZ)
 600             {
 601               cache->sp_offset += 8;
 602             }
 603           else
 604             {
 605               cache->sp_offset += 4;
 606             }
 607         }
 608       else if (IS_MOV_SP_FP (inst))
 609         {
 610           cache->uses_fp = 1;
 611           /* At this point, only allow argument register moves to other
 612              registers or argument register moves to @(X,fp) which are
 613              moving the register arguments onto the stack area allocated
 614              by a former add somenumber to SP call.  Don't allow moving
 615              to an fp indirect address above fp + cache->sp_offset. */
 616           pc += 2;
 617           for (opc = pc + 12; pc < opc; pc += 2)
 618             {
 619               inst = read_memory_integer (pc, 2);
 620               if (IS_MOV_ARG_TO_IND_R14 (inst))
 621                 {
 622                   reg = GET_SOURCE_REG (inst);
 623                   if (cache->sp_offset > 0)
 624                     cache->saved_regs[reg] = cache->sp_offset;
 625                 }
 626               else if (IS_MOV_ARG_TO_IND_R14_WITH_DISP (inst))
 627                 {
 628                   reg = GET_SOURCE_REG (inst);
 629                   offset = (inst & 0xf) * 4;
 630                   if (cache->sp_offset > offset)
 631                     cache->saved_regs[reg] = cache->sp_offset - offset;
 632                 }
 633               else if (IS_MOV_ARG_TO_REG (inst))
 634                 continue;
 635               else
 636                 break;
 637             }
 638           break;
 639         }
 640       else if (IS_JSR (inst))
 641         {
 642           /* We have found a jsr that has been scheduled into the prologue.
 643              If we continue the scan and return a pc someplace after this,
 644              then setting a breakpoint on this function will cause it to
 645              appear to be called after the function it is calling via the
 646              jsr, which will be very confusing.  Most likely the next
 647              instruction is going to be IS_MOV_SP_FP in the delay slot.  If
 648              so, note that before returning the current pc. */
 649           inst = read_memory_integer (pc + 2, 2);
 650           if (IS_MOV_SP_FP (inst))
 651             cache->uses_fp = 1;
 652           break;
 653         }
 654 #if 0                           /* This used to just stop when it found an instruction that
 655                                    was not considered part of the prologue.  Now, we just
 656                                    keep going looking for likely instructions. */
 657       else
 658         break;
 659 #endif
 660     }
 661
 662   return pc;
 663 }
 664
 665 /* Skip any prologue before the guts of a function */
 666
 667 /* Skip the prologue using the debug information. If this fails we'll
 668    fall back on the 'guess' method below. */
 669 static CORE_ADDR
 670 after_prologue (CORE_ADDR pc)
 671 {
 672   struct symtab_and_line sal;
 673   CORE_ADDR func_addr, func_end;
 674
 675   /* If we can not find the symbol in the partial symbol table, then
 676      there is no hope we can determine the function's start address
 677      with this code.  */
 678   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 679     return 0;
 680
 681   /* Get the line associated with FUNC_ADDR.  */
 682   sal = find_pc_line (func_addr, 0);
 683
 684   /* There are only two cases to consider.  First, the end of the source line
 685      is within the function bounds.  In that case we return the end of the
 686      source line.  Second is the end of the source line extends beyond the
 687      bounds of the current function.  We need to use the slow code to
 688      examine instructions in that case.  */
 689   if (sal.end < func_end)
 690     return sal.end;
 691   else
 692     return 0;
 693 }
 694
 695 static CORE_ADDR
 696 sh_skip_prologue (CORE_ADDR start_pc)
 697 {
 698   CORE_ADDR pc;
 699   struct sh_frame_cache cache;
 700
 701   /* See if we can determine the end of the prologue via the symbol table.
 702      If so, then return either PC, or the PC after the prologue, whichever
 703      is greater.  */
 704   pc = after_prologue (start_pc);
 705
 706   /* If after_prologue returned a useful address, then use it.  Else
 707      fall back on the instruction skipping code. */
 708   if (pc)
 709     return max (pc, start_pc);
 710
 711   cache.sp_offset = -4;
 712   pc = sh_analyze_prologue (start_pc, (CORE_ADDR) -1, &cache);
 713   if (!cache.uses_fp)
 714     return start_pc;
 715
 716   return pc;
 717 }
 718
 719 /* The ABI says:
 720
 721    Aggregate types not bigger than 8 bytes that have the same size and
 722    alignment as one of the integer scalar types are returned in the
 723    same registers as the integer type they match.
 724
 725    For example, a 2-byte aligned structure with size 2 bytes has the
 726    same size and alignment as a short int, and will be returned in R0.
 727    A 4-byte aligned structure with size 8 bytes has the same size and
 728    alignment as a long long int, and will be returned in R0 and R1.
 729
 730    When an aggregate type is returned in R0 and R1, R0 contains the
 731    first four bytes of the aggregate, and R1 contains the
 732    remainder. If the size of the aggregate type is not a multiple of 4
 733    bytes, the aggregate is tail-padded up to a multiple of 4
 734    bytes. The value of the padding is undefined. For little-endian
 735    targets the padding will appear at the most significant end of the
 736    last element, for big-endian targets the padding appears at the
 737    least significant end of the last element.
 738
 739    All other aggregate types are returned by address. The caller
 740    function passes the address of an area large enough to hold the
 741    aggregate value in R2. The called function stores the result in
 742    this location.
 743
 744    To reiterate, structs smaller than 8 bytes could also be returned
 745    in memory, if they don't pass the "same size and alignment as an
 746    integer type" rule.
 747
 748    For example, in
 749
 750    struct s { char c[3]; } wibble;
 751    struct s foo(void) {  return wibble; }
 752
 753    the return value from foo() will be in memory, not
 754    in R0, because there is no 3-byte integer type.
 755
 756    Similarly, in
 757
 758    struct s { char c[2]; } wibble;
 759    struct s foo(void) {  return wibble; }
 760
 761    because a struct containing two chars has alignment 1, that matches
 762    type char, but size 2, that matches type short.  There's no integer
 763    type that has alignment 1 and size 2, so the struct is returned in
 764    memory.
 765
 766 */
 767
 768 static int
 769 sh_use_struct_convention (int gcc_p, struct type *type)
 770 {
 771   int len = TYPE_LENGTH (type);
 772   int nelem = TYPE_NFIELDS (type);
 773
 774   /* Non-power of 2 length types and types bigger than 8 bytes (which don't
 775      fit in two registers anyway) use struct convention.  */
 776   if (len != 1 && len != 2 && len != 4 && len != 8)
 777     return 1;
 778
 779   /* Scalar types and aggregate types with exactly one field are aligned
 780      by definition.  They are returned in registers.  */
 781   if (nelem <= 1)
 782     return 0;
 783
 784   /* If the first field in the aggregate has the same length as the entire
 785      aggregate type, the type is returned in registers.  */
 786   if (TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == len)
 787     return 0;
 788
 789   /* If the size of the aggregate is 8 bytes and the first field is
 790      of size 4 bytes its alignment is equal to long long's alignment,
 791      so it's returned in registers.  */
 792   if (len == 8 && TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == 4)
 793     return 0;
 794
 795   /* Otherwise use struct convention.  */
 796   return 1;
 797 }
 798
 799 /* Extract from an array REGBUF containing the (raw) register state
 800    the address in which a function should return its structure value,
 801    as a CORE_ADDR (or an expression that can be used as one).  */
 802 static CORE_ADDR
 803 sh_extract_struct_value_address (struct regcache *regcache)
 804 {
 805   ULONGEST addr;
 806
 807   regcache_cooked_read_unsigned (regcache, STRUCT_RETURN_REGNUM, &addr);
 808   return addr;
 809 }
 810
 811 static CORE_ADDR
 812 sh_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
 813 {
 814   return sp & ~3;
 815 }
 816
 817 /* Function: push_dummy_call (formerly push_arguments)
 818    Setup the function arguments for calling a function in the inferior.
 819
 820    On the Renesas SH architecture, there are four registers (R4 to R7)
 821    which are dedicated for passing function arguments.  Up to the first
 822    four arguments (depending on size) may go into these registers.
 823    The rest go on the stack.
 824
 825    MVS: Except on SH variants that have floating point registers.
 826    In that case, float and double arguments are passed in the same
 827    manner, but using FP registers instead of GP registers.
 828
 829    Arguments that are smaller than 4 bytes will still take up a whole
 830    register or a whole 32-bit word on the stack, and will be
 831    right-justified in the register or the stack word.  This includes
 832    chars, shorts, and small aggregate types.
 833
 834    Arguments that are larger than 4 bytes may be split between two or
 835    more registers.  If there are not enough registers free, an argument
 836    may be passed partly in a register (or registers), and partly on the
 837    stack.  This includes doubles, long longs, and larger aggregates.
 838    As far as I know, there is no upper limit to the size of aggregates
 839    that will be passed in this way; in other words, the convention of
 840    passing a pointer to a large aggregate instead of a copy is not used.
 841
 842    MVS: The above appears to be true for the SH variants that do not
 843    have an FPU, however those that have an FPU appear to copy the
 844    aggregate argument onto the stack (and not place it in registers)
 845    if it is larger than 16 bytes (four GP registers).
 846
 847    An exceptional case exists for struct arguments (and possibly other
 848    aggregates such as arrays) if the size is larger than 4 bytes but
 849    not a multiple of 4 bytes.  In this case the argument is never split
 850    between the registers and the stack, but instead is copied in its
 851    entirety onto the stack, AND also copied into as many registers as
 852    there is room for.  In other words, space in registers permitting,
 853    two copies of the same argument are passed in.  As far as I can tell,
 854    only the one on the stack is used, although that may be a function
 855    of the level of compiler optimization.  I suspect this is a compiler
 856    bug.  Arguments of these odd sizes are left-justified within the
 857    word (as opposed to arguments smaller than 4 bytes, which are
 858    right-justified).
 859
 860    If the function is to return an aggregate type such as a struct, it
 861    is either returned in the normal return value register R0 (if its
 862    size is no greater than one byte), or else the caller must allocate
 863    space into which the callee will copy the return value (if the size
 864    is greater than one byte).  In this case, a pointer to the return
 865    value location is passed into the callee in register R2, which does
 866    not displace any of the other arguments passed in via registers R4
 867    to R7.   */
 868
 869 /* Helper function to justify value in register according to endianess. */
 870 static char *
 871 sh_justify_value_in_reg (struct value *val, int len)
 872 {
 873   static char valbuf[4];
 874
 875   memset (valbuf, 0, sizeof (valbuf));
 876   if (len < 4)
 877     {
 878       /* value gets right-justified in the register or stack word */
 879       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 880         memcpy (valbuf + (4 - len), (char *) value_contents (val), len);
 881       else
 882         memcpy (valbuf, (char *) value_contents (val), len);
 883       return valbuf;
 884     }
 885   return (char *) value_contents (val);
 886 }
 887
 888 /* Helper function to eval number of bytes to allocate on stack. */
 889 static CORE_ADDR
 890 sh_stack_allocsize (int nargs, struct value **args)
 891 {
 892   int stack_alloc = 0;
 893   while (nargs-- > 0)
 894     stack_alloc += ((TYPE_LENGTH (value_type (args[nargs])) + 3) & ~3);
 895   return stack_alloc;
 896 }
 897
 898 /* Helper functions for getting the float arguments right.  Registers usage
 899    depends on the ABI and the endianess.  The comments should enlighten how
 900    it's intended to work. */
 901
 902 /* This array stores which of the float arg registers are already in use. */
 903 static int flt_argreg_array[FLOAT_ARGLAST_REGNUM - FLOAT_ARG0_REGNUM + 1];
 904
 905 /* This function just resets the above array to "no reg used so far". */
 906 static void
 907 sh_init_flt_argreg (void)
 908 {
 909   memset (flt_argreg_array, 0, sizeof flt_argreg_array);
 910 }
 911
 912 /* This function returns the next register to use for float arg passing.
 913    It returns either a valid value between FLOAT_ARG0_REGNUM and
 914    FLOAT_ARGLAST_REGNUM if a register is available, otherwise it returns
 915    FLOAT_ARGLAST_REGNUM + 1 to indicate that no register is available.
 916
 917    Note that register number 0 in flt_argreg_array corresponds with the
 918    real float register fr4.  In contrast to FLOAT_ARG0_REGNUM (value is
 919    29) the parity of the register number is preserved, which is important
 920    for the double register passing test (see the "argreg & 1" test below). */
 921 static int
 922 sh_next_flt_argreg (int len)
 923 {
 924   int argreg;
 925
 926   /* First search for the next free register. */
 927   for (argreg = 0; argreg <= FLOAT_ARGLAST_REGNUM - FLOAT_ARG0_REGNUM;
 928        ++argreg)
 929     if (!flt_argreg_array[argreg])
 930       break;
 931
 932   /* No register left? */
 933   if (argreg > FLOAT_ARGLAST_REGNUM - FLOAT_ARG0_REGNUM)
 934     return FLOAT_ARGLAST_REGNUM + 1;
 935
 936   if (len == 8)
 937     {
 938       /* Doubles are always starting in a even register number. */
 939       if (argreg & 1)
 940         {
 941           flt_argreg_array[argreg] = 1;
 942
 943           ++argreg;
 944
 945           /* No register left? */
 946           if (argreg > FLOAT_ARGLAST_REGNUM - FLOAT_ARG0_REGNUM)
 947             return FLOAT_ARGLAST_REGNUM + 1;
 948         }
 949       /* Also mark the next register as used. */
 950       flt_argreg_array[argreg + 1] = 1;
 951     }
 952   else if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
 953     {
 954       /* In little endian, gcc passes floats like this: f5, f4, f7, f6, ... */
 955       if (!flt_argreg_array[argreg + 1])
 956         ++argreg;
 957     }
 958   flt_argreg_array[argreg] = 1;
 959   return FLOAT_ARG0_REGNUM + argreg;
 960 }
 961
 962 /* Helper function which figures out, if a type is treated like a float type.
 963
 964    The FPU ABIs have a special way how to treat types as float types.
 965    Structures with exactly one member, which is of type float or double, are
 966    treated exactly as the base types float or double:
 967
 968      struct sf {
 969        float f;
 970      };
 971
 972      struct sd {
 973        double d;
 974      };
 975
 976    are handled the same way as just
 977
 978      float f;
 979
 980      double d;
 981
 982    As a result, arguments of these struct types are pushed into floating point
 983    registers exactly as floats or doubles, using the same decision algorithm.
 984
 985    The same is valid if these types are used as function return types.  The
 986    above structs are returned in fr0 resp. fr0,fr1 instead of in r0, r0,r1
 987    or even using struct convention as it is for other structs.  */
 988
 989 static int
 990 sh_treat_as_flt_p (struct type *type)
 991 {
 992   int len = TYPE_LENGTH (type);
 993
 994   /* Ordinary float types are obviously treated as float.  */
 995   if (TYPE_CODE (type) == TYPE_CODE_FLT)
 996     return 1;
 997   /* Otherwise non-struct types are not treated as float.  */
 998   if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
 999     return 0;
1000   /* Otherwise structs with more than one memeber are not treated as float.  */
1001   if (TYPE_NFIELDS (type) != 1)
1002     return 0;
1003   /* Otherwise if the type of that member is float, the whole type is
1004      treated as float.  */
1005   if (TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_FLT)
1006     return 1;
1007   /* Otherwise it's not treated as float.  */
1008   return 0;
1009 }
1010
1011 static CORE_ADDR
1012 sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
1013                         struct value *function,
1014                         struct regcache *regcache,
1015                         CORE_ADDR bp_addr, int nargs,
1016                         struct value **args,
1017                         CORE_ADDR sp, int struct_return,
1018                         CORE_ADDR struct_addr)
1019 {
1020   int stack_offset = 0;
1021   int argreg = ARG0_REGNUM;
1022   int flt_argreg = 0;
1023   int argnum;
1024   struct type *type;
1025   CORE_ADDR regval;
1026   char *val;
1027   int len, reg_size = 0;
1028   int pass_on_stack = 0;
1029   int treat_as_flt;
1030
1031   /* first force sp to a 4-byte alignment */
1032   sp = sh_frame_align (gdbarch, sp);
1033
1034   if (struct_return)
1035     regcache_cooked_write_unsigned (regcache,
1036                                     STRUCT_RETURN_REGNUM, struct_addr);
1037
1038   /* make room on stack for args */
1039   sp -= sh_stack_allocsize (nargs, args);
1040
1041   /* Initialize float argument mechanism. */
1042   sh_init_flt_argreg ();
1043
1044   /* Now load as many as possible of the first arguments into
1045      registers, and push the rest onto the stack.  There are 16 bytes
1046      in four registers available.  Loop thru args from first to last.  */
1047   for (argnum = 0; argnum < nargs; argnum++)
1048     {
1049       type = value_type (args[argnum]);
1050       len = TYPE_LENGTH (type);
1051       val = sh_justify_value_in_reg (args[argnum], len);
1052
1053       /* Some decisions have to be made how various types are handled.
1054          This also differs in different ABIs. */
1055       pass_on_stack = 0;
1056
1057       /* Find out the next register to use for a floating point value. */
1058       treat_as_flt = sh_treat_as_flt_p (type);
1059       if (treat_as_flt)
1060         flt_argreg = sh_next_flt_argreg (len);
1061       /* In contrast to non-FPU CPUs, arguments are never split between
1062          registers and stack.  If an argument doesn't fit in the remaining
1063          registers it's always pushed entirely on the stack.  */
1064       else if (len > ((ARGLAST_REGNUM - argreg + 1) * 4))
1065         pass_on_stack = 1;
1066
1067       while (len > 0)
1068         {
1069           if ((treat_as_flt && flt_argreg > FLOAT_ARGLAST_REGNUM)
1070               || (!treat_as_flt && (argreg > ARGLAST_REGNUM
1071                                     || pass_on_stack)))
1072             {
1073               /* The data goes entirely on the stack, 4-byte aligned. */
1074               reg_size = (len + 3) & ~3;
1075               write_memory (sp + stack_offset, val, reg_size);
1076               stack_offset += reg_size;
1077             }
1078           else if (treat_as_flt && flt_argreg <= FLOAT_ARGLAST_REGNUM)
1079             {
1080               /* Argument goes in a float argument register.  */
1081               reg_size = register_size (gdbarch, flt_argreg);
1082               regval = extract_unsigned_integer (val, reg_size);
1083               /* In little endian mode, float types taking two registers
1084                  (doubles on sh4, long doubles on sh2e, sh3e and sh4) must
1085                  be stored swapped in the argument registers.  The below
1086                  code first writes the first 32 bits in the next but one
1087                  register, increments the val and len values accordingly
1088                  and then proceeds as normal by writing the second 32 bits
1089                  into the next register. */
1090               if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE
1091                   && TYPE_LENGTH (type) == 2 * reg_size)
1092                 {
1093                   regcache_cooked_write_unsigned (regcache, flt_argreg + 1,
1094                                                   regval);
1095                   val += reg_size;
1096                   len -= reg_size;
1097                   regval = extract_unsigned_integer (val, reg_size);
1098                 }
1099               regcache_cooked_write_unsigned (regcache, flt_argreg++, regval);
1100             }
1101           else if (!treat_as_flt && argreg <= ARGLAST_REGNUM)
1102             {
1103               /* there's room in a register */
1104               reg_size = register_size (gdbarch, argreg);
1105               regval = extract_unsigned_integer (val, reg_size);
1106               regcache_cooked_write_unsigned (regcache, argreg++, regval);
1107             }
1108           /* Store the value one register at a time or in one step on stack.  */
1109           len -= reg_size;
1110           val += reg_size;
1111         }
1112     }
1113
1114   /* Store return address. */
1115   regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
1116
1117   /* Update stack pointer.  */
1118   regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp);
1119
1120   return sp;
1121 }
1122
1123 static CORE_ADDR
1124 sh_push_dummy_call_nofpu (struct gdbarch *gdbarch,
1125                           struct value *function,
1126                           struct regcache *regcache,
1127                           CORE_ADDR bp_addr,
1128                           int nargs, struct value **args,
1129                           CORE_ADDR sp, int struct_return,
1130                           CORE_ADDR struct_addr)
1131 {
1132   int stack_offset = 0;
1133   int argreg = ARG0_REGNUM;
1134   int argnum;
1135   struct type *type;
1136   CORE_ADDR regval;
1137   char *val;
1138   int len, reg_size;
1139
1140   /* first force sp to a 4-byte alignment */
1141   sp = sh_frame_align (gdbarch, sp);
1142
1143   if (struct_return)
1144     regcache_cooked_write_unsigned (regcache,
1145                                     STRUCT_RETURN_REGNUM, struct_addr);
1146
1147   /* make room on stack for args */
1148   sp -= sh_stack_allocsize (nargs, args);
1149
1150   /* Now load as many as possible of the first arguments into
1151      registers, and push the rest onto the stack.  There are 16 bytes
1152      in four registers available.  Loop thru args from first to last.  */
1153   for (argnum = 0; argnum < nargs; argnum++)
1154     {
1155       type = value_type (args[argnum]);
1156       len = TYPE_LENGTH (type);
1157       val = sh_justify_value_in_reg (args[argnum], len);
1158
1159       while (len > 0)
1160         {
1161           if (argreg > ARGLAST_REGNUM)
1162             {
1163               /* The remainder of the data goes entirely on the stack,
1164                  4-byte aligned. */
1165               reg_size = (len + 3) & ~3;
1166               write_memory (sp + stack_offset, val, reg_size);
1167               stack_offset += reg_size;
1168             }
1169           else if (argreg <= ARGLAST_REGNUM)
1170             {
1171               /* there's room in a register */
1172               reg_size = register_size (gdbarch, argreg);
1173               regval = extract_unsigned_integer (val, reg_size);
1174               regcache_cooked_write_unsigned (regcache, argreg++, regval);
1175             }
1176           /* Store the value reg_size bytes at a time.  This means that things
1177              larger than reg_size bytes may go partly in registers and partly
1178              on the stack.  */
1179           len -= reg_size;
1180           val += reg_size;
1181         }
1182     }
1183
1184   /* Store return address. */
1185   regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
1186
1187   /* Update stack pointer.  */
1188   regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp);
1189
1190   return sp;
1191 }
1192
1193 /* Find a function's return value in the appropriate registers (in
1194    regbuf), and copy it into valbuf.  Extract from an array REGBUF
1195    containing the (raw) register state a function return value of type
1196    TYPE, and copy that, in virtual format, into VALBUF.  */
1197 static void
1198 sh_extract_return_value_nofpu (struct type *type, struct regcache *regcache,
1199                                void *valbuf)
1200 {
1201   int len = TYPE_LENGTH (type);
1202   int return_register = R0_REGNUM;
1203   int offset;
1204
1205   if (len <= 4)
1206     {
1207       ULONGEST c;
1208
1209       regcache_cooked_read_unsigned (regcache, R0_REGNUM, &c);
1210       store_unsigned_integer (valbuf, len, c);
1211     }
1212   else if (len == 8)
1213     {
1214       int i, regnum = R0_REGNUM;
1215       for (i = 0; i < len; i += 4)
1216         regcache_raw_read (regcache, regnum++, (char *) valbuf + i);
1217     }
1218   else
1219     error (_("bad size for return value"));
1220 }
1221
1222 static void
1223 sh_extract_return_value_fpu (struct type *type, struct regcache *regcache,
1224                              void *valbuf)
1225 {
1226   if (sh_treat_as_flt_p (type))
1227     {
1228       int len = TYPE_LENGTH (type);
1229       int i, regnum = FP0_REGNUM;
1230       for (i = 0; i < len; i += 4)
1231         if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
1232           regcache_raw_read (regcache, regnum++, (char *) valbuf + len - 4 - i);
1233         else
1234           regcache_raw_read (regcache, regnum++, (char *) valbuf + i);
1235     }
1236   else
1237     sh_extract_return_value_nofpu (type, regcache, valbuf);
1238 }
1239
1240 /* Write into appropriate registers a function return value
1241    of type TYPE, given in virtual format.
1242    If the architecture is sh4 or sh3e, store a function's return value
1243    in the R0 general register or in the FP0 floating point register,
1244    depending on the type of the return value. In all the other cases
1245    the result is stored in r0, left-justified. */
1246 static void
1247 sh_store_return_value_nofpu (struct type *type, struct regcache *regcache,
1248                              const void *valbuf)
1249 {
1250   ULONGEST val;
1251   int len = TYPE_LENGTH (type);
1252
1253   if (len <= 4)
1254     {
1255       val = extract_unsigned_integer (valbuf, len);
1256       regcache_cooked_write_unsigned (regcache, R0_REGNUM, val);
1257     }
1258   else
1259     {
1260       int i, regnum = R0_REGNUM;
1261       for (i = 0; i < len; i += 4)
1262         regcache_raw_write (regcache, regnum++, (char *) valbuf + i);
1263     }
1264 }
1265
1266 static void
1267 sh_store_return_value_fpu (struct type *type, struct regcache *regcache,
1268                            const void *valbuf)
1269 {
1270   if (sh_treat_as_flt_p (type))
1271     {
1272       int len = TYPE_LENGTH (type);
1273       int i, regnum = FP0_REGNUM;
1274       for (i = 0; i < len; i += 4)
1275         if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
1276           regcache_raw_write (regcache, regnum++,
1277                               (char *) valbuf + len - 4 - i);
1278         else
1279           regcache_raw_write (regcache, regnum++, (char *) valbuf + i);
1280     }
1281   else
1282     sh_store_return_value_nofpu (type, regcache, valbuf);
1283 }
1284
1285 static enum return_value_convention
1286 sh_return_value_nofpu (struct gdbarch *gdbarch, struct type *type,
1287                        struct regcache *regcache,
1288                        void *readbuf, const void *writebuf)
1289 {
1290   if (sh_use_struct_convention (0, type))
1291     return RETURN_VALUE_STRUCT_CONVENTION;
1292   if (writebuf)
1293     sh_store_return_value_nofpu (type, regcache, writebuf);
1294   else if (readbuf)
1295     sh_extract_return_value_nofpu (type, regcache, readbuf);
1296   return RETURN_VALUE_REGISTER_CONVENTION;
1297 }
1298
1299 static enum return_value_convention
1300 sh_return_value_fpu (struct gdbarch *gdbarch, struct type *type,
1301                      struct regcache *regcache,
1302                      void *readbuf, const void *writebuf)
1303 {
1304   if (sh_use_struct_convention (0, type))
1305     return RETURN_VALUE_STRUCT_CONVENTION;
1306   if (writebuf)
1307     sh_store_return_value_fpu (type, regcache, writebuf);
1308   else if (readbuf)
1309     sh_extract_return_value_fpu (type, regcache, readbuf);
1310   return RETURN_VALUE_REGISTER_CONVENTION;
1311 }
1312
1313 /* Print the registers in a form similar to the E7000 */
1314
1315 static void
1316 sh_generic_show_regs (void)
1317 {
1318   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1319                    paddr (read_register (PC_REGNUM)),
1320                    (long) read_register (SR_REGNUM),
1321                    (long) read_register (PR_REGNUM),
1322                    (long) read_register (MACH_REGNUM),
1323                    (long) read_register (MACL_REGNUM));
1324
1325   printf_filtered ("GBR=%08lx VBR=%08lx",
1326                    (long) read_register (GBR_REGNUM),
1327                    (long) read_register (VBR_REGNUM));
1328
1329   printf_filtered
1330     ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1331      (long) read_register (0), (long) read_register (1),
1332      (long) read_register (2), (long) read_register (3),
1333      (long) read_register (4), (long) read_register (5),
1334      (long) read_register (6), (long) read_register (7));
1335   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1336                    (long) read_register (8), (long) read_register (9),
1337                    (long) read_register (10), (long) read_register (11),
1338                    (long) read_register (12), (long) read_register (13),
1339                    (long) read_register (14), (long) read_register (15));
1340 }
1341
1342 static void
1343 sh3_show_regs (void)
1344 {
1345   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1346                    paddr (read_register (PC_REGNUM)),
1347                    (long) read_register (SR_REGNUM),
1348                    (long) read_register (PR_REGNUM),
1349                    (long) read_register (MACH_REGNUM),
1350                    (long) read_register (MACL_REGNUM));
1351
1352   printf_filtered ("GBR=%08lx VBR=%08lx",
1353                    (long) read_register (GBR_REGNUM),
1354                    (long) read_register (VBR_REGNUM));
1355   printf_filtered (" SSR=%08lx SPC=%08lx",
1356                    (long) read_register (SSR_REGNUM),
1357                    (long) read_register (SPC_REGNUM));
1358
1359   printf_filtered
1360     ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1361      (long) read_register (0), (long) read_register (1),
1362      (long) read_register (2), (long) read_register (3),
1363      (long) read_register (4), (long) read_register (5),
1364      (long) read_register (6), (long) read_register (7));
1365   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1366                    (long) read_register (8), (long) read_register (9),
1367                    (long) read_register (10), (long) read_register (11),
1368                    (long) read_register (12), (long) read_register (13),
1369                    (long) read_register (14), (long) read_register (15));
1370 }
1371
1372
1373 static void
1374 sh2e_show_regs (void)
1375 {
1376   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1377                    paddr (read_register (PC_REGNUM)),
1378                    (long) read_register (SR_REGNUM),
1379                    (long) read_register (PR_REGNUM),
1380                    (long) read_register (MACH_REGNUM),
1381                    (long) read_register (MACL_REGNUM));
1382
1383   printf_filtered ("GBR=%08lx VBR=%08lx",
1384                    (long) read_register (GBR_REGNUM),
1385                    (long) read_register (VBR_REGNUM));
1386   printf_filtered (" FPUL=%08lx FPSCR=%08lx",
1387                    (long) read_register (FPUL_REGNUM),
1388                    (long) read_register (FPSCR_REGNUM));
1389
1390   printf_filtered
1391     ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1392      (long) read_register (0), (long) read_register (1),
1393      (long) read_register (2), (long) read_register (3),
1394      (long) read_register (4), (long) read_register (5),
1395      (long) read_register (6), (long) read_register (7));
1396   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1397                    (long) read_register (8), (long) read_register (9),
1398                    (long) read_register (10), (long) read_register (11),
1399                    (long) read_register (12), (long) read_register (13),
1400                    (long) read_register (14), (long) read_register (15));
1401
1402   printf_filtered (("FP0-FP7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"), (long) read_register (FP0_REGNUM + 0), (long) read_register (FP0_REGNUM + 1), (long) read_register (FP0_REGNUM + 2), (long) read_register (FP0_REGNUM + 3), (long) read_register (FP0_REGNUM + 4), (long) read_register (FP0_REGNUM + 5), (long) read_register (FP0_REGNUM + 6), (long) read_register (FP0_REGNUM + 7));
1403   printf_filtered (("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"), (long) read_register (FP0_REGNUM + 8), (long) read_register (FP0_REGNUM + 9), (long) read_register (FP0_REGNUM + 10), (long) read_register (FP0_REGNUM + 11), (long) read_register (FP0_REGNUM + 12), (long) read_register (FP0_REGNUM + 13), (long) read_register (FP0_REGNUM + 14), (long) read_register (FP0_REGNUM + 15));
1404 }
1405
1406 static void
1407 sh2a_show_regs (void)
1408 {
1409   int pr = read_register (FPSCR_REGNUM) & 0x80000;
1410   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1411                    paddr (read_register (PC_REGNUM)),
1412                    (long) read_register (SR_REGNUM),
1413                    (long) read_register (PR_REGNUM),
1414                    (long) read_register (MACH_REGNUM),
1415                    (long) read_register (MACL_REGNUM));
1416
1417   printf_filtered ("GBR=%08lx VBR=%08lx TBR=%08lx",
1418                    (long) read_register (GBR_REGNUM),
1419                    (long) read_register (VBR_REGNUM),
1420                    (long) read_register (TBR_REGNUM));
1421   printf_filtered (" FPUL=%08lx FPSCR=%08lx\n",
1422                    (long) read_register (FPUL_REGNUM),
1423                    (long) read_register (FPSCR_REGNUM));
1424
1425   printf_filtered ("R0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1426                    (long) read_register (0), (long) read_register (1),
1427                    (long) read_register (2), (long) read_register (3),
1428                    (long) read_register (4), (long) read_register (5),
1429                    (long) read_register (6), (long) read_register (7));
1430   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1431                    (long) read_register (8), (long) read_register (9),
1432                    (long) read_register (10), (long) read_register (11),
1433                    (long) read_register (12), (long) read_register (13),
1434                    (long) read_register (14), (long) read_register (15));
1435
1436   printf_filtered ((pr
1437                     ? "DR0-DR6  %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
1438                     :
1439                     "FP0-FP7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1440                    (long) read_register (FP0_REGNUM + 0),
1441                    (long) read_register (FP0_REGNUM + 1),
1442                    (long) read_register (FP0_REGNUM + 2),
1443                    (long) read_register (FP0_REGNUM + 3),
1444                    (long) read_register (FP0_REGNUM + 4),
1445                    (long) read_register (FP0_REGNUM + 5),
1446                    (long) read_register (FP0_REGNUM + 6),
1447                    (long) read_register (FP0_REGNUM + 7));
1448   printf_filtered ((pr ?
1449                     "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n" :
1450                     "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1451                    (long) read_register (FP0_REGNUM + 8),
1452                    (long) read_register (FP0_REGNUM + 9),
1453                    (long) read_register (FP0_REGNUM + 10),
1454                    (long) read_register (FP0_REGNUM + 11),
1455                    (long) read_register (FP0_REGNUM + 12),
1456                    (long) read_register (FP0_REGNUM + 13),
1457                    (long) read_register (FP0_REGNUM + 14),
1458                    (long) read_register (FP0_REGNUM + 15));
1459   printf_filtered ("BANK=%-3d\n", (int) read_register (BANK_REGNUM));
1460   printf_filtered ("R0b - R7b  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1461                    (long) read_register (R0_BANK0_REGNUM + 0),
1462                    (long) read_register (R0_BANK0_REGNUM + 1),
1463                    (long) read_register (R0_BANK0_REGNUM + 2),
1464                    (long) read_register (R0_BANK0_REGNUM + 3),
1465                    (long) read_register (R0_BANK0_REGNUM + 4),
1466                    (long) read_register (R0_BANK0_REGNUM + 5),
1467                    (long) read_register (R0_BANK0_REGNUM + 6),
1468                    (long) read_register (R0_BANK0_REGNUM + 7));
1469   printf_filtered ("R8b - R14b %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1470                    (long) read_register (R0_BANK0_REGNUM + 8),
1471                    (long) read_register (R0_BANK0_REGNUM + 9),
1472                    (long) read_register (R0_BANK0_REGNUM + 10),
1473                    (long) read_register (R0_BANK0_REGNUM + 11),
1474                    (long) read_register (R0_BANK0_REGNUM + 12),
1475                    (long) read_register (R0_BANK0_REGNUM + 13),
1476                    (long) read_register (R0_BANK0_REGNUM + 14));
1477   printf_filtered ("MACHb=%08lx IVNb=%08lx PRb=%08lx GBRb=%08lx MACLb=%08lx\n",
1478                    (long) read_register (R0_BANK0_REGNUM + 15),
1479                    (long) read_register (R0_BANK0_REGNUM + 16),
1480                    (long) read_register (R0_BANK0_REGNUM + 17),
1481                    (long) read_register (R0_BANK0_REGNUM + 18),
1482                    (long) read_register (R0_BANK0_REGNUM + 19));
1483 }
1484
1485 static void
1486 sh2a_nofpu_show_regs (void)
1487 {
1488   int pr = read_register (FPSCR_REGNUM) & 0x80000;
1489   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1490                    paddr (read_register (PC_REGNUM)),
1491                    (long) read_register (SR_REGNUM),
1492                    (long) read_register (PR_REGNUM),
1493                    (long) read_register (MACH_REGNUM),
1494                    (long) read_register (MACL_REGNUM));
1495
1496   printf_filtered ("GBR=%08lx VBR=%08lx TBR=%08lx",
1497                    (long) read_register (GBR_REGNUM),
1498                    (long) read_register (VBR_REGNUM),
1499                    (long) read_register (TBR_REGNUM));
1500   printf_filtered (" FPUL=%08lx FPSCR=%08lx\n",
1501                    (long) read_register (FPUL_REGNUM),
1502                    (long) read_register (FPSCR_REGNUM));
1503
1504   printf_filtered ("R0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1505                    (long) read_register (0), (long) read_register (1),
1506                    (long) read_register (2), (long) read_register (3),
1507                    (long) read_register (4), (long) read_register (5),
1508                    (long) read_register (6), (long) read_register (7));
1509   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1510                    (long) read_register (8), (long) read_register (9),
1511                    (long) read_register (10), (long) read_register (11),
1512                    (long) read_register (12), (long) read_register (13),
1513                    (long) read_register (14), (long) read_register (15));
1514
1515   printf_filtered ("BANK=%-3d\n", (int) read_register (BANK_REGNUM));
1516   printf_filtered ("R0b - R7b  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1517                    (long) read_register (R0_BANK0_REGNUM + 0),
1518                    (long) read_register (R0_BANK0_REGNUM + 1),
1519                    (long) read_register (R0_BANK0_REGNUM + 2),
1520                    (long) read_register (R0_BANK0_REGNUM + 3),
1521                    (long) read_register (R0_BANK0_REGNUM + 4),
1522                    (long) read_register (R0_BANK0_REGNUM + 5),
1523                    (long) read_register (R0_BANK0_REGNUM + 6),
1524                    (long) read_register (R0_BANK0_REGNUM + 7));
1525   printf_filtered ("R8b - R14b %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1526                    (long) read_register (R0_BANK0_REGNUM + 8),
1527                    (long) read_register (R0_BANK0_REGNUM + 9),
1528                    (long) read_register (R0_BANK0_REGNUM + 10),
1529                    (long) read_register (R0_BANK0_REGNUM + 11),
1530                    (long) read_register (R0_BANK0_REGNUM + 12),
1531                    (long) read_register (R0_BANK0_REGNUM + 13),
1532                    (long) read_register (R0_BANK0_REGNUM + 14));
1533   printf_filtered ("MACHb=%08lx IVNb=%08lx PRb=%08lx GBRb=%08lx MACLb=%08lx\n",
1534                    (long) read_register (R0_BANK0_REGNUM + 15),
1535                    (long) read_register (R0_BANK0_REGNUM + 16),
1536                    (long) read_register (R0_BANK0_REGNUM + 17),
1537                    (long) read_register (R0_BANK0_REGNUM + 18),
1538                    (long) read_register (R0_BANK0_REGNUM + 19));
1539 }
1540
1541 static void
1542 sh3e_show_regs (void)
1543 {
1544   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1545                    paddr (read_register (PC_REGNUM)),
1546                    (long) read_register (SR_REGNUM),
1547                    (long) read_register (PR_REGNUM),
1548                    (long) read_register (MACH_REGNUM),
1549                    (long) read_register (MACL_REGNUM));
1550
1551   printf_filtered ("GBR=%08lx VBR=%08lx",
1552                    (long) read_register (GBR_REGNUM),
1553                    (long) read_register (VBR_REGNUM));
1554   printf_filtered (" SSR=%08lx SPC=%08lx",
1555                    (long) read_register (SSR_REGNUM),
1556                    (long) read_register (SPC_REGNUM));
1557   printf_filtered (" FPUL=%08lx FPSCR=%08lx",
1558                    (long) read_register (FPUL_REGNUM),
1559                    (long) read_register (FPSCR_REGNUM));
1560
1561   printf_filtered
1562     ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1563      (long) read_register (0), (long) read_register (1),
1564      (long) read_register (2), (long) read_register (3),
1565      (long) read_register (4), (long) read_register (5),
1566      (long) read_register (6), (long) read_register (7));
1567   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1568                    (long) read_register (8), (long) read_register (9),
1569                    (long) read_register (10), (long) read_register (11),
1570                    (long) read_register (12), (long) read_register (13),
1571                    (long) read_register (14), (long) read_register (15));
1572
1573   printf_filtered (("FP0-FP7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"), (long) read_register (FP0_REGNUM + 0), (long) read_register (FP0_REGNUM + 1), (long) read_register (FP0_REGNUM + 2), (long) read_register (FP0_REGNUM + 3), (long) read_register (FP0_REGNUM + 4), (long) read_register (FP0_REGNUM + 5), (long) read_register (FP0_REGNUM + 6), (long) read_register (FP0_REGNUM + 7));
1574   printf_filtered (("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"), (long) read_register (FP0_REGNUM + 8), (long) read_register (FP0_REGNUM + 9), (long) read_register (FP0_REGNUM + 10), (long) read_register (FP0_REGNUM + 11), (long) read_register (FP0_REGNUM + 12), (long) read_register (FP0_REGNUM + 13), (long) read_register (FP0_REGNUM + 14), (long) read_register (FP0_REGNUM + 15));
1575 }
1576
1577 static void
1578 sh3_dsp_show_regs (void)
1579 {
1580   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1581                    paddr (read_register (PC_REGNUM)),
1582                    (long) read_register (SR_REGNUM),
1583                    (long) read_register (PR_REGNUM),
1584                    (long) read_register (MACH_REGNUM),
1585                    (long) read_register (MACL_REGNUM));
1586
1587   printf_filtered ("GBR=%08lx VBR=%08lx",
1588                    (long) read_register (GBR_REGNUM),
1589                    (long) read_register (VBR_REGNUM));
1590
1591   printf_filtered (" SSR=%08lx SPC=%08lx",
1592                    (long) read_register (SSR_REGNUM),
1593                    (long) read_register (SPC_REGNUM));
1594
1595   printf_filtered (" DSR=%08lx", (long) read_register (DSR_REGNUM));
1596
1597   printf_filtered
1598     ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1599      (long) read_register (0), (long) read_register (1),
1600      (long) read_register (2), (long) read_register (3),
1601      (long) read_register (4), (long) read_register (5),
1602      (long) read_register (6), (long) read_register (7));
1603   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1604                    (long) read_register (8), (long) read_register (9),
1605                    (long) read_register (10), (long) read_register (11),
1606                    (long) read_register (12), (long) read_register (13),
1607                    (long) read_register (14), (long) read_register (15));
1608
1609   printf_filtered
1610     ("A0G=%02lx A0=%08lx M0=%08lx X0=%08lx Y0=%08lx RS=%08lx MOD=%08lx\n",
1611      (long) read_register (A0G_REGNUM) & 0xff,
1612      (long) read_register (A0_REGNUM), (long) read_register (M0_REGNUM),
1613      (long) read_register (X0_REGNUM), (long) read_register (Y0_REGNUM),
1614      (long) read_register (RS_REGNUM), (long) read_register (MOD_REGNUM));
1615   printf_filtered ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
1616                    (long) read_register (A1G_REGNUM) & 0xff,
1617                    (long) read_register (A1_REGNUM),
1618                    (long) read_register (M1_REGNUM),
1619                    (long) read_register (X1_REGNUM),
1620                    (long) read_register (Y1_REGNUM),
1621                    (long) read_register (RE_REGNUM));
1622 }
1623
1624 static void
1625 sh4_show_regs (void)
1626 {
1627   int pr = read_register (FPSCR_REGNUM) & 0x80000;
1628   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1629                    paddr (read_register (PC_REGNUM)),
1630                    (long) read_register (SR_REGNUM),
1631                    (long) read_register (PR_REGNUM),
1632                    (long) read_register (MACH_REGNUM),
1633                    (long) read_register (MACL_REGNUM));
1634
1635   printf_filtered ("GBR=%08lx VBR=%08lx",
1636                    (long) read_register (GBR_REGNUM),
1637                    (long) read_register (VBR_REGNUM));
1638   printf_filtered (" SSR=%08lx SPC=%08lx",
1639                    (long) read_register (SSR_REGNUM),
1640                    (long) read_register (SPC_REGNUM));
1641   printf_filtered (" FPUL=%08lx FPSCR=%08lx",
1642                    (long) read_register (FPUL_REGNUM),
1643                    (long) read_register (FPSCR_REGNUM));
1644
1645   printf_filtered
1646     ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1647      (long) read_register (0), (long) read_register (1),
1648      (long) read_register (2), (long) read_register (3),
1649      (long) read_register (4), (long) read_register (5),
1650      (long) read_register (6), (long) read_register (7));
1651   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1652                    (long) read_register (8), (long) read_register (9),
1653                    (long) read_register (10), (long) read_register (11),
1654                    (long) read_register (12), (long) read_register (13),
1655                    (long) read_register (14), (long) read_register (15));
1656
1657   printf_filtered ((pr
1658                     ? "DR0-DR6  %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
1659                     :
1660                     "FP0-FP7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1661                    (long) read_register (FP0_REGNUM + 0),
1662                    (long) read_register (FP0_REGNUM + 1),
1663                    (long) read_register (FP0_REGNUM + 2),
1664                    (long) read_register (FP0_REGNUM + 3),
1665                    (long) read_register (FP0_REGNUM + 4),
1666                    (long) read_register (FP0_REGNUM + 5),
1667                    (long) read_register (FP0_REGNUM + 6),
1668                    (long) read_register (FP0_REGNUM + 7));
1669   printf_filtered ((pr ?
1670                     "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n" :
1671                     "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1672                    (long) read_register (FP0_REGNUM + 8),
1673                    (long) read_register (FP0_REGNUM + 9),
1674                    (long) read_register (FP0_REGNUM + 10),
1675                    (long) read_register (FP0_REGNUM + 11),
1676                    (long) read_register (FP0_REGNUM + 12),
1677                    (long) read_register (FP0_REGNUM + 13),
1678                    (long) read_register (FP0_REGNUM + 14),
1679                    (long) read_register (FP0_REGNUM + 15));
1680 }
1681
1682 static void
1683 sh4_nofpu_show_regs (void)
1684 {
1685   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1686                    paddr (read_register (PC_REGNUM)),
1687                    (long) read_register (SR_REGNUM),
1688                    (long) read_register (PR_REGNUM),
1689                    (long) read_register (MACH_REGNUM),
1690                    (long) read_register (MACL_REGNUM));
1691
1692   printf_filtered ("GBR=%08lx VBR=%08lx",
1693                    (long) read_register (GBR_REGNUM),
1694                    (long) read_register (VBR_REGNUM));
1695   printf_filtered (" SSR=%08lx SPC=%08lx",
1696                    (long) read_register (SSR_REGNUM),
1697                    (long) read_register (SPC_REGNUM));
1698
1699   printf_filtered
1700     ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1701      (long) read_register (0), (long) read_register (1),
1702      (long) read_register (2), (long) read_register (3),
1703      (long) read_register (4), (long) read_register (5),
1704      (long) read_register (6), (long) read_register (7));
1705   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1706                    (long) read_register (8), (long) read_register (9),
1707                    (long) read_register (10), (long) read_register (11),
1708                    (long) read_register (12), (long) read_register (13),
1709                    (long) read_register (14), (long) read_register (15));
1710 }
1711
1712 static void
1713 sh_dsp_show_regs (void)
1714 {
1715   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1716                    paddr (read_register (PC_REGNUM)),
1717                    (long) read_register (SR_REGNUM),
1718                    (long) read_register (PR_REGNUM),
1719                    (long) read_register (MACH_REGNUM),
1720                    (long) read_register (MACL_REGNUM));
1721
1722   printf_filtered ("GBR=%08lx VBR=%08lx",
1723                    (long) read_register (GBR_REGNUM),
1724                    (long) read_register (VBR_REGNUM));
1725
1726   printf_filtered (" DSR=%08lx", (long) read_register (DSR_REGNUM));
1727
1728   printf_filtered
1729     ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1730      (long) read_register (0), (long) read_register (1),
1731      (long) read_register (2), (long) read_register (3),
1732      (long) read_register (4), (long) read_register (5),
1733      (long) read_register (6), (long) read_register (7));
1734   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1735                    (long) read_register (8), (long) read_register (9),
1736                    (long) read_register (10), (long) read_register (11),
1737                    (long) read_register (12), (long) read_register (13),
1738                    (long) read_register (14), (long) read_register (15));
1739
1740   printf_filtered
1741     ("A0G=%02lx A0=%08lx M0=%08lx X0=%08lx Y0=%08lx RS=%08lx MOD=%08lx\n",
1742      (long) read_register (A0G_REGNUM) & 0xff,
1743      (long) read_register (A0_REGNUM), (long) read_register (M0_REGNUM),
1744      (long) read_register (X0_REGNUM), (long) read_register (Y0_REGNUM),
1745      (long) read_register (RS_REGNUM), (long) read_register (MOD_REGNUM));
1746   printf_filtered ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
1747                    (long) read_register (A1G_REGNUM) & 0xff,
1748                    (long) read_register (A1_REGNUM),
1749                    (long) read_register (M1_REGNUM),
1750                    (long) read_register (X1_REGNUM),
1751                    (long) read_register (Y1_REGNUM),
1752                    (long) read_register (RE_REGNUM));
1753 }
1754
1755 static void
1756 sh_show_regs_command (char *args, int from_tty)
1757 {
1758   if (sh_show_regs)
1759     (*sh_show_regs) ();
1760 }
1761
1762 static struct type *
1763 sh_sh2a_register_type (struct gdbarch *gdbarch, int reg_nr)
1764 {
1765   if ((reg_nr >= FP0_REGNUM
1766        && (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM))
1767     return builtin_type_float;
1768   else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
1769     return builtin_type_double;
1770   else
1771     return builtin_type_int;
1772 }
1773
1774 /* Return the GDB type object for the "standard" data type
1775    of data in register N.  */
1776 static struct type *
1777 sh_sh3e_register_type (struct gdbarch *gdbarch, int reg_nr)
1778 {
1779   if ((reg_nr >= FP0_REGNUM
1780        && (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM))
1781     return builtin_type_float;
1782   else
1783     return builtin_type_int;
1784 }
1785
1786 static struct type *
1787 sh_sh4_build_float_register_type (int high)
1788 {
1789   struct type *temp;
1790
1791   temp = create_range_type (NULL, builtin_type_int, 0, high);
1792   return create_array_type (NULL, builtin_type_float, temp);
1793 }
1794
1795 static struct type *
1796 sh_sh4_register_type (struct gdbarch *gdbarch, int reg_nr)
1797 {
1798   if ((reg_nr >= FP0_REGNUM
1799        && (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM))
1800     return builtin_type_float;
1801   else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
1802     return builtin_type_double;
1803   else if (reg_nr >= FV0_REGNUM && reg_nr <= FV_LAST_REGNUM)
1804     return sh_sh4_build_float_register_type (3);
1805   else
1806     return builtin_type_int;
1807 }
1808
1809 static struct type *
1810 sh_default_register_type (struct gdbarch *gdbarch, int reg_nr)
1811 {
1812   return builtin_type_int;
1813 }
1814
1815 /* On the sh4, the DRi pseudo registers are problematic if the target
1816    is little endian. When the user writes one of those registers, for
1817    instance with 'ser var $dr0=1', we want the double to be stored
1818    like this:
1819    fr0 = 0x00 0x00 0x00 0x00 0x00 0xf0 0x3f
1820    fr1 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
1821
1822    This corresponds to little endian byte order & big endian word
1823    order.  However if we let gdb write the register w/o conversion, it
1824    will write fr0 and fr1 this way:
1825    fr0 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
1826    fr1 = 0x00 0x00 0x00 0x00 0x00 0xf0 0x3f
1827    because it will consider fr0 and fr1 as a single LE stretch of memory.
1828
1829    To achieve what we want we must force gdb to store things in
1830    floatformat_ieee_double_littlebyte_bigword (which is defined in
1831    include/floatformat.h and libiberty/floatformat.c.
1832
1833    In case the target is big endian, there is no problem, the
1834    raw bytes will look like:
1835    fr0 = 0x3f 0xf0 0x00 0x00 0x00 0x00 0x00
1836    fr1 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
1837
1838    The other pseudo registers (the FVs) also don't pose a problem
1839    because they are stored as 4 individual FP elements. */
1840
1841 static void
1842 sh_register_convert_to_virtual (int regnum, struct type *type,
1843                                 char *from, char *to)
1844 {
1845   if (regnum >= DR0_REGNUM && regnum <= DR_LAST_REGNUM)
1846     {
1847       DOUBLEST val;
1848       floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
1849                                from, &val);
1850       store_typed_floating (to, type, val);
1851     }
1852   else
1853     error
1854       ("sh_register_convert_to_virtual called with non DR register number");
1855 }
1856
1857 static void
1858 sh_register_convert_to_raw (struct type *type, int regnum,
1859                             const void *from, void *to)
1860 {
1861   if (regnum >= DR0_REGNUM && regnum <= DR_LAST_REGNUM)
1862     {
1863       DOUBLEST val = extract_typed_floating (from, type);
1864       floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword,
1865                                  &val, to);
1866     }
1867   else
1868     error (_("sh_register_convert_to_raw called with non DR register number"));
1869 }
1870
1871 /* For vectors of 4 floating point registers. */
1872 static int
1873 fv_reg_base_num (int fv_regnum)
1874 {
1875   int fp_regnum;
1876
1877   fp_regnum = FP0_REGNUM + (fv_regnum - FV0_REGNUM) * 4;
1878   return fp_regnum;
1879 }
1880
1881 /* For double precision floating point registers, i.e 2 fp regs.*/
1882 static int
1883 dr_reg_base_num (int dr_regnum)
1884 {
1885   int fp_regnum;
1886
1887   fp_regnum = FP0_REGNUM + (dr_regnum - DR0_REGNUM) * 2;
1888   return fp_regnum;
1889 }
1890
1891 static void
1892 sh_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
1893                          int reg_nr, void *buffer)
1894 {
1895   int base_regnum, portion;
1896   char temp_buffer[MAX_REGISTER_SIZE];
1897
1898   if (reg_nr == PSEUDO_BANK_REGNUM)
1899     regcache_raw_read (regcache, BANK_REGNUM, buffer);
1900   else
1901   if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
1902     {
1903       base_regnum = dr_reg_base_num (reg_nr);
1904
1905       /* Build the value in the provided buffer. */
1906       /* Read the real regs for which this one is an alias.  */
1907       for (portion = 0; portion < 2; portion++)
1908         regcache_raw_read (regcache, base_regnum + portion,
1909                            (temp_buffer
1910                             + register_size (gdbarch,
1911                                              base_regnum) * portion));
1912       /* We must pay attention to the endiannes. */
1913       sh_register_convert_to_virtual (reg_nr,
1914                                       gdbarch_register_type (gdbarch, reg_nr),
1915                                       temp_buffer, buffer);
1916     }
1917   else if (reg_nr >= FV0_REGNUM && reg_nr <= FV_LAST_REGNUM)
1918     {
1919       base_regnum = fv_reg_base_num (reg_nr);
1920
1921       /* Read the real regs for which this one is an alias.  */
1922       for (portion = 0; portion < 4; portion++)
1923         regcache_raw_read (regcache, base_regnum + portion,
1924                            ((char *) buffer
1925                             + register_size (gdbarch,
1926                                              base_regnum) * portion));
1927     }
1928 }
1929
1930 static void
1931 sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
1932                           int reg_nr, const void *buffer)
1933 {
1934   int base_regnum, portion;
1935   char temp_buffer[MAX_REGISTER_SIZE];
1936
1937   if (reg_nr == PSEUDO_BANK_REGNUM)
1938     {
1939       /* When the bank register is written to, the whole register bank
1940          is switched and all values in the bank registers must be read
1941          from the target/sim again. We're just invalidating the regcache
1942          so that a re-read happens next time it's necessary.  */
1943       int bregnum;
1944
1945       regcache_raw_write (regcache, BANK_REGNUM, buffer);
1946       for (bregnum = R0_BANK0_REGNUM; bregnum < MACLB_REGNUM; ++bregnum)
1947         set_register_cached (bregnum, 0);
1948     }
1949   else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
1950     {
1951       base_regnum = dr_reg_base_num (reg_nr);
1952
1953       /* We must pay attention to the endiannes. */
1954       sh_register_convert_to_raw (gdbarch_register_type (gdbarch, reg_nr),
1955                                   reg_nr, buffer, temp_buffer);
1956
1957       /* Write the real regs for which this one is an alias.  */
1958       for (portion = 0; portion < 2; portion++)
1959         regcache_raw_write (regcache, base_regnum + portion,
1960                             (temp_buffer
1961                              + register_size (gdbarch,
1962                                               base_regnum) * portion));
1963     }
1964   else if (reg_nr >= FV0_REGNUM && reg_nr <= FV_LAST_REGNUM)
1965     {
1966       base_regnum = fv_reg_base_num (reg_nr);
1967
1968       /* Write the real regs for which this one is an alias.  */
1969       for (portion = 0; portion < 4; portion++)
1970         regcache_raw_write (regcache, base_regnum + portion,
1971                             ((char *) buffer
1972                              + register_size (gdbarch,
1973                                               base_regnum) * portion));
1974     }
1975 }
1976
1977 /* Floating point vector of 4 float registers. */
1978 static void
1979 do_fv_register_info (struct gdbarch *gdbarch, struct ui_file *file,
1980                      int fv_regnum)
1981 {
1982   int first_fp_reg_num = fv_reg_base_num (fv_regnum);
1983   fprintf_filtered (file, "fv%d\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n",
1984                     fv_regnum - FV0_REGNUM,
1985                     (int) read_register (first_fp_reg_num),
1986                     (int) read_register (first_fp_reg_num + 1),
1987                     (int) read_register (first_fp_reg_num + 2),
1988                     (int) read_register (first_fp_reg_num + 3));
1989 }
1990
1991 /* Double precision registers. */
1992 static void
1993 do_dr_register_info (struct gdbarch *gdbarch, struct ui_file *file,
1994                      int dr_regnum)
1995 {
1996   int first_fp_reg_num = dr_reg_base_num (dr_regnum);
1997
1998   fprintf_filtered (file, "dr%d\t0x%08x%08x\n",
1999                     dr_regnum - DR0_REGNUM,
2000                     (int) read_register (first_fp_reg_num),
2001                     (int) read_register (first_fp_reg_num + 1));
2002 }
2003 static void
2004 do_bank_register_info (struct gdbarch *gdbarch, struct ui_file *file)
2005 {
2006   fprintf_filtered (file, "bank           %d\n",
2007                     (int) read_register (BANK_REGNUM));
2008 }
2009
2010 static void
2011 sh_print_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
2012                           int regnum)
2013 {
2014   if (regnum < NUM_REGS || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
2015     internal_error (__FILE__, __LINE__,
2016                     _("Invalid pseudo register number %d\n"), regnum);
2017   else if (regnum == PSEUDO_BANK_REGNUM)
2018     do_bank_register_info (gdbarch, file);
2019   else if (regnum >= DR0_REGNUM && regnum <= DR_LAST_REGNUM)
2020     do_dr_register_info (gdbarch, file, regnum);
2021   else if (regnum >= FV0_REGNUM && regnum <= FV_LAST_REGNUM)
2022     do_fv_register_info (gdbarch, file, regnum);
2023 }
2024
2025 static void
2026 sh_do_fp_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
2027 {                               /* do values for FP (float) regs */
2028   char *raw_buffer;
2029   double flt;                   /* double extracted from raw hex data */
2030   int inv;
2031   int j;
2032
2033   /* Allocate space for the float. */
2034   raw_buffer = (char *) alloca (register_size (gdbarch, FP0_REGNUM));
2035
2036   /* Get the data in raw format.  */
2037   if (!frame_register_read (get_selected_frame (NULL), regnum, raw_buffer))
2038     error (_("can't read register %d (%s)"), regnum, REGISTER_NAME (regnum));
2039
2040   /* Get the register as a number */
2041   flt = unpack_double (builtin_type_float, raw_buffer, &inv);
2042
2043   /* Print the name and some spaces. */
2044   fputs_filtered (REGISTER_NAME (regnum), file);
2045   print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
2046
2047   /* Print the value. */
2048   if (inv)
2049     fprintf_filtered (file, "<invalid float>");
2050   else
2051     fprintf_filtered (file, "%-10.9g", flt);
2052
2053   /* Print the fp register as hex. */
2054   fprintf_filtered (file, "\t(raw 0x");
2055   for (j = 0; j < register_size (gdbarch, regnum); j++)
2056     {
2057       int idx = (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
2058                  ? j
2059                  : register_size (gdbarch, regnum) - 1 - j);
2060       fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
2061     }
2062   fprintf_filtered (file, ")");
2063   fprintf_filtered (file, "\n");
2064 }
2065
2066 static void
2067 sh_do_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
2068 {
2069   char raw_buffer[MAX_REGISTER_SIZE];
2070
2071   fputs_filtered (REGISTER_NAME (regnum), file);
2072   print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
2073
2074   /* Get the data in raw format.  */
2075   if (!frame_register_read (get_selected_frame (NULL), regnum, raw_buffer))
2076     fprintf_filtered (file, "*value not available*\n");
2077
2078   val_print (gdbarch_register_type (gdbarch, regnum), raw_buffer, 0, 0,
2079              file, 'x', 1, 0, Val_pretty_default);
2080   fprintf_filtered (file, "\t");
2081   val_print (gdbarch_register_type (gdbarch, regnum), raw_buffer, 0, 0,
2082              file, 0, 1, 0, Val_pretty_default);
2083   fprintf_filtered (file, "\n");
2084 }
2085
2086 static void
2087 sh_print_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
2088 {
2089   if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
2090     internal_error (__FILE__, __LINE__,
2091                     _("Invalid register number %d\n"), regnum);
2092
2093   else if (regnum >= 0 && regnum < NUM_REGS)
2094     {
2095       if (TYPE_CODE (gdbarch_register_type (gdbarch, regnum)) ==
2096           TYPE_CODE_FLT)
2097         sh_do_fp_register (gdbarch, file, regnum);      /* FP regs */
2098       else
2099         sh_do_register (gdbarch, file, regnum); /* All other regs */
2100     }
2101
2102   else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
2103     {
2104       sh_print_pseudo_register (gdbarch, file, regnum);
2105     }
2106 }
2107
2108 static void
2109 sh_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
2110                          struct frame_info *frame, int regnum, int fpregs)
2111 {
2112   if (regnum != -1)             /* do one specified register */
2113     {
2114       if (*(REGISTER_NAME (regnum)) == '\0')
2115         error (_("Not a valid register for the current processor type"));
2116
2117       sh_print_register (gdbarch, file, regnum);
2118     }
2119   else
2120     /* do all (or most) registers */
2121     {
2122       for (regnum = 0; regnum < NUM_REGS; ++regnum)
2123         {
2124           /* If the register name is empty, it is undefined for this
2125              processor, so don't display anything.  */
2126           if (REGISTER_NAME (regnum) == NULL
2127               || *(REGISTER_NAME (regnum)) == '\0')
2128             continue;
2129
2130           if (TYPE_CODE (gdbarch_register_type (gdbarch, regnum)) ==
2131               TYPE_CODE_FLT)
2132             {
2133               /* true for "INFO ALL-REGISTERS" command */
2134               if (fpregs)
2135                 sh_do_fp_register (gdbarch, file, regnum);      /* FP regs */
2136             }
2137           else
2138             sh_do_register (gdbarch, file, regnum);     /* All other regs */
2139         }
2140
2141       if (regnum == PSEUDO_BANK_REGNUM
2142           && REGISTER_NAME (regnum)
2143           && *REGISTER_NAME (regnum))
2144         sh_print_pseudo_register (gdbarch, file, regnum++);
2145
2146       if (fpregs)
2147         while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
2148           {
2149             sh_print_pseudo_register (gdbarch, file, regnum);
2150             regnum++;
2151           }
2152     }
2153 }
2154
2155 /* Fetch (and possibly build) an appropriate link_map_offsets structure
2156    for native i386 linux targets using the struct offsets defined in
2157    link.h (but without actual reference to that file).
2158
2159    This makes it possible to access i386-linux shared libraries from
2160    a gdb that was not built on an i386-linux host (for cross debugging).
2161    */
2162
2163 struct link_map_offsets *
2164 sh_linux_svr4_fetch_link_map_offsets (void)
2165 {
2166   static struct link_map_offsets lmo;
2167   static struct link_map_offsets *lmp = 0;
2168
2169   if (lmp == 0)
2170     {
2171       lmp = &lmo;
2172
2173       lmo.r_debug_size = 8;     /* 20 not actual size but all we need */
2174
2175       lmo.r_map_offset = 4;
2176       lmo.r_map_size = 4;
2177
2178       lmo.link_map_size = 20;   /* 552 not actual size but all we need */
2179
2180       lmo.l_addr_offset = 0;
2181       lmo.l_addr_size = 4;
2182
2183       lmo.l_name_offset = 4;
2184       lmo.l_name_size = 4;
2185
2186       lmo.l_next_offset = 12;
2187       lmo.l_next_size = 4;
2188
2189       lmo.l_prev_offset = 16;
2190       lmo.l_prev_size = 4;
2191     }
2192
2193   return lmp;
2194 }
2195
2196 static int
2197 sh_dsp_register_sim_regno (int nr)
2198 {
2199   if (legacy_register_sim_regno (nr) < 0)
2200     return legacy_register_sim_regno (nr);
2201   if (nr >= DSR_REGNUM && nr <= Y1_REGNUM)
2202     return nr - DSR_REGNUM + SIM_SH_DSR_REGNUM;
2203   if (nr == MOD_REGNUM)
2204     return SIM_SH_MOD_REGNUM;
2205   if (nr == RS_REGNUM)
2206     return SIM_SH_RS_REGNUM;
2207   if (nr == RE_REGNUM)
2208     return SIM_SH_RE_REGNUM;
2209   if (nr >= DSP_R0_BANK_REGNUM && nr <= DSP_R7_BANK_REGNUM)
2210     return nr - DSP_R0_BANK_REGNUM + SIM_SH_R0_BANK_REGNUM;
2211   return nr;
2212 }
2213
2214 static int
2215 sh_sh2a_register_sim_regno (int nr)
2216 {
2217   switch (nr)
2218     {
2219       case TBR_REGNUM:
2220         return SIM_SH_TBR_REGNUM;
2221       case IBNR_REGNUM:
2222         return SIM_SH_IBNR_REGNUM;
2223       case IBCR_REGNUM:
2224         return SIM_SH_IBCR_REGNUM;
2225       case BANK_REGNUM:
2226         return SIM_SH_BANK_REGNUM;
2227       case MACLB_REGNUM:
2228         return SIM_SH_BANK_MACL_REGNUM;
2229       case GBRB_REGNUM:
2230         return SIM_SH_BANK_GBR_REGNUM;
2231       case PRB_REGNUM:
2232         return SIM_SH_BANK_PR_REGNUM;
2233       case IVNB_REGNUM:
2234         return SIM_SH_BANK_IVN_REGNUM;
2235       case MACHB_REGNUM:
2236         return SIM_SH_BANK_MACH_REGNUM;
2237       default:
2238         break;
2239     }
2240   return legacy_register_sim_regno (nr);
2241 }
2242
2243 static struct sh_frame_cache *
2244 sh_alloc_frame_cache (void)
2245 {
2246   struct sh_frame_cache *cache;
2247   int i;
2248
2249   cache = FRAME_OBSTACK_ZALLOC (struct sh_frame_cache);
2250
2251   /* Base address.  */
2252   cache->base = 0;
2253   cache->saved_sp = 0;
2254   cache->sp_offset = 0;
2255   cache->pc = 0;
2256
2257   /* Frameless until proven otherwise.  */
2258   cache->uses_fp = 0;
2259
2260   /* Saved registers.  We initialize these to -1 since zero is a valid
2261      offset (that's where fp is supposed to be stored).  */
2262   for (i = 0; i < SH_NUM_REGS; i++)
2263     {
2264       cache->saved_regs[i] = -1;
2265     }
2266
2267   return cache;
2268 }
2269
2270 static struct sh_frame_cache *
2271 sh_frame_cache (struct frame_info *next_frame, void **this_cache)
2272 {
2273   struct sh_frame_cache *cache;
2274   CORE_ADDR current_pc;
2275   int i;
2276
2277   if (*this_cache)
2278     return *this_cache;
2279
2280   cache = sh_alloc_frame_cache ();
2281   *this_cache = cache;
2282
2283   /* In principle, for normal frames, fp holds the frame pointer,
2284      which holds the base address for the current stack frame.
2285      However, for functions that don't need it, the frame pointer is
2286      optional.  For these "frameless" functions the frame pointer is
2287      actually the frame pointer of the calling frame. */
2288   cache->base = frame_unwind_register_unsigned (next_frame, FP_REGNUM);
2289   if (cache->base == 0)
2290     return cache;
2291
2292   cache->pc = frame_func_unwind (next_frame);
2293   current_pc = frame_pc_unwind (next_frame);
2294   if (cache->pc != 0)
2295     sh_analyze_prologue (cache->pc, current_pc, cache);
2296
2297   if (!cache->uses_fp)
2298     {
2299       /* We didn't find a valid frame, which means that CACHE->base
2300          currently holds the frame pointer for our calling frame.  If
2301          we're at the start of a function, or somewhere half-way its
2302          prologue, the function's frame probably hasn't been fully
2303          setup yet.  Try to reconstruct the base address for the stack
2304          frame by looking at the stack pointer.  For truly "frameless"
2305          functions this might work too.  */
2306       cache->base = frame_unwind_register_unsigned (next_frame, SP_REGNUM);
2307     }
2308
2309   /* Now that we have the base address for the stack frame we can
2310      calculate the value of sp in the calling frame.  */
2311   cache->saved_sp = cache->base + cache->sp_offset;
2312
2313   /* Adjust all the saved registers such that they contain addresses
2314      instead of offsets.  */
2315   for (i = 0; i < SH_NUM_REGS; i++)
2316     if (cache->saved_regs[i] != -1)
2317       cache->saved_regs[i] = cache->saved_sp - cache->saved_regs[i] - 4;
2318
2319   return cache;
2320 }
2321
2322 static void
2323 sh_frame_prev_register (struct frame_info *next_frame, void **this_cache,
2324                         int regnum, int *optimizedp,
2325                         enum lval_type *lvalp, CORE_ADDR *addrp,
2326                         int *realnump, void *valuep)
2327 {
2328   struct sh_frame_cache *cache = sh_frame_cache (next_frame, this_cache);
2329
2330   gdb_assert (regnum >= 0);
2331
2332   if (regnum == SP_REGNUM && cache->saved_sp)
2333     {
2334       *optimizedp = 0;
2335       *lvalp = not_lval;
2336       *addrp = 0;
2337       *realnump = -1;
2338       if (valuep)
2339         {
2340           /* Store the value.  */
2341           store_unsigned_integer (valuep, 4, cache->saved_sp);
2342         }
2343       return;
2344     }
2345
2346   /* The PC of the previous frame is stored in the PR register of
2347      the current frame.  Frob regnum so that we pull the value from
2348      the correct place.  */
2349   if (regnum == PC_REGNUM)
2350     regnum = PR_REGNUM;
2351
2352   if (regnum < SH_NUM_REGS && cache->saved_regs[regnum] != -1)
2353     {
2354       *optimizedp = 0;
2355       *lvalp = lval_memory;
2356       *addrp = cache->saved_regs[regnum];
2357       *realnump = -1;
2358       if (valuep)
2359         {
2360           /* Read the value in from memory.  */
2361           read_memory (*addrp, valuep,
2362                        register_size (current_gdbarch, regnum));
2363         }
2364       return;
2365     }
2366
2367   *optimizedp = 0;
2368   *lvalp = lval_register;
2369   *addrp = 0;
2370   *realnump = regnum;
2371   if (valuep)
2372     frame_unwind_register (next_frame, (*realnump), valuep);
2373 }
2374
2375 static void
2376 sh_frame_this_id (struct frame_info *next_frame, void **this_cache,
2377                   struct frame_id *this_id)
2378 {
2379   struct sh_frame_cache *cache = sh_frame_cache (next_frame, this_cache);
2380
2381   /* This marks the outermost frame.  */
2382   if (cache->base == 0)
2383     return;
2384
2385   *this_id = frame_id_build (cache->saved_sp, cache->pc);
2386 }
2387
2388 static const struct frame_unwind sh_frame_unwind = {
2389   NORMAL_FRAME,
2390   sh_frame_this_id,
2391   sh_frame_prev_register
2392 };
2393
2394 static const struct frame_unwind *
2395 sh_frame_sniffer (struct frame_info *next_frame)
2396 {
2397   return &sh_frame_unwind;
2398 }
2399
2400 static CORE_ADDR
2401 sh_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2402 {
2403   return frame_unwind_register_unsigned (next_frame, SP_REGNUM);
2404 }
2405
2406 static CORE_ADDR
2407 sh_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2408 {
2409   return frame_unwind_register_unsigned (next_frame, PC_REGNUM);
2410 }
2411
2412 static struct frame_id
2413 sh_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
2414 {
2415   return frame_id_build (sh_unwind_sp (gdbarch, next_frame),
2416                          frame_pc_unwind (next_frame));
2417 }
2418
2419 static CORE_ADDR
2420 sh_frame_base_address (struct frame_info *next_frame, void **this_cache)
2421 {
2422   struct sh_frame_cache *cache = sh_frame_cache (next_frame, this_cache);
2423
2424   return cache->base;
2425 }
2426
2427 static const struct frame_base sh_frame_base = {
2428   &sh_frame_unwind,
2429   sh_frame_base_address,
2430   sh_frame_base_address,
2431   sh_frame_base_address
2432 };
2433
2434 /* The epilogue is defined here as the area at the end of a function,
2435    either on the `ret' instruction itself or after an instruction which
2436    destroys the function's stack frame. */
2437 static int
2438 sh_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
2439 {
2440   CORE_ADDR func_addr = 0, func_end = 0;
2441
2442   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
2443     {
2444       ULONGEST inst;
2445       /* The sh epilogue is max. 14 bytes long.  Give another 14 bytes
2446          for a nop and some fixed data (e.g. big offsets) which are
2447          unfortunately also treated as part of the function (which
2448          means, they are below func_end. */
2449       CORE_ADDR addr = func_end - 28;
2450       if (addr < func_addr + 4)
2451         addr = func_addr + 4;
2452       if (pc < addr)
2453         return 0;
2454
2455       /* First search forward until hitting an rts. */
2456       while (addr < func_end
2457              && !IS_RTS (read_memory_unsigned_integer (addr, 2)))
2458         addr += 2;
2459       if (addr >= func_end)
2460         return 0;
2461
2462       /* At this point we should find a mov.l @r15+,r14 instruction,
2463          either before or after the rts.  If not, then the function has
2464          probably no "normal" epilogue and we bail out here. */
2465       inst = read_memory_unsigned_integer (addr - 2, 2);
2466       if (IS_RESTORE_FP (read_memory_unsigned_integer (addr - 2, 2)))
2467         addr -= 2;
2468       else if (!IS_RESTORE_FP (read_memory_unsigned_integer (addr + 2, 2)))
2469         return 0;
2470
2471       inst = read_memory_unsigned_integer (addr - 2, 2);
2472
2473       /* Step over possible lds.l @r15+,macl. */
2474       if (IS_MACL_LDS (inst))
2475         {
2476           addr -= 2;
2477           inst = read_memory_unsigned_integer (addr - 2, 2);
2478         }
2479
2480       /* Step over possible lds.l @r15+,pr. */
2481       if (IS_LDS (inst))
2482         {
2483           addr -= 2;
2484           inst = read_memory_unsigned_integer (addr - 2, 2);
2485         }
2486
2487       /* Step over possible mov r14,r15. */
2488       if (IS_MOV_FP_SP (inst))
2489         {
2490           addr -= 2;
2491           inst = read_memory_unsigned_integer (addr - 2, 2);
2492         }
2493
2494       /* Now check for FP adjustments, using add #imm,r14 or add rX, r14
2495          instructions. */
2496       while (addr > func_addr + 4
2497              && (IS_ADD_REG_TO_FP (inst) || IS_ADD_IMM_FP (inst)))
2498         {
2499           addr -= 2;
2500           inst = read_memory_unsigned_integer (addr - 2, 2);
2501         }
2502
2503       /* On SH2a check if the previous instruction was perhaps a MOVI20.
2504          That's allowed for the epilogue.  */
2505       if ((gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_sh2a
2506            || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_sh2a_nofpu)
2507           && addr > func_addr + 6
2508           && IS_MOVI20 (read_memory_unsigned_integer (addr - 4, 2)))
2509         addr -= 4;
2510
2511       if (pc >= addr)
2512         return 1;
2513     }
2514   return 0;
2515 }
2516
2517 static gdbarch_init_ftype sh_gdbarch_init;
2518
2519 static struct gdbarch *
2520 sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2521 {
2522   struct gdbarch *gdbarch;
2523
2524   sh_show_regs = sh_generic_show_regs;
2525   switch (info.bfd_arch_info->mach)
2526     {
2527     case bfd_mach_sh2e:
2528       sh_show_regs = sh2e_show_regs;
2529       break;
2530     case bfd_mach_sh2a:
2531       sh_show_regs = sh2a_show_regs;
2532       break;
2533     case bfd_mach_sh2a_nofpu:
2534       sh_show_regs = sh2a_nofpu_show_regs;
2535       break;
2536     case bfd_mach_sh_dsp:
2537       sh_show_regs = sh_dsp_show_regs;
2538       break;
2539
2540     case bfd_mach_sh3:
2541       sh_show_regs = sh3_show_regs;
2542       break;
2543
2544     case bfd_mach_sh3e:
2545       sh_show_regs = sh3e_show_regs;
2546       break;
2547
2548     case bfd_mach_sh3_dsp:
2549     case bfd_mach_sh4al_dsp:
2550       sh_show_regs = sh3_dsp_show_regs;
2551       break;
2552
2553     case bfd_mach_sh4:
2554     case bfd_mach_sh4a:
2555       sh_show_regs = sh4_show_regs;
2556       break;
2557
2558     case bfd_mach_sh4_nofpu:
2559     case bfd_mach_sh4a_nofpu:
2560       sh_show_regs = sh4_nofpu_show_regs;
2561       break;
2562
2563 #if 0
2564     case bfd_mach_sh5:
2565       sh_show_regs = sh64_show_regs;
2566       /* SH5 is handled entirely in sh64-tdep.c */
2567       return sh64_gdbarch_init (info, arches);
2568 #endif
2569     }
2570
2571   /* If there is already a candidate, use it.  */
2572   arches = gdbarch_list_lookup_by_info (arches, &info);
2573   if (arches != NULL)
2574     return arches->gdbarch;
2575
2576   /* None found, create a new architecture from the information
2577      provided. */
2578   gdbarch = gdbarch_alloc (&info, NULL);
2579
2580   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
2581   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2582   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2583   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2584   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2585   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2586   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2587   set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2588
2589   set_gdbarch_num_regs (gdbarch, SH_NUM_REGS);
2590   set_gdbarch_sp_regnum (gdbarch, 15);
2591   set_gdbarch_pc_regnum (gdbarch, 16);
2592   set_gdbarch_fp0_regnum (gdbarch, -1);
2593   set_gdbarch_num_pseudo_regs (gdbarch, 0);
2594
2595   set_gdbarch_register_type (gdbarch, sh_default_register_type);
2596
2597   set_gdbarch_print_registers_info (gdbarch, sh_print_registers_info);
2598
2599   set_gdbarch_breakpoint_from_pc (gdbarch, sh_breakpoint_from_pc);
2600
2601   set_gdbarch_print_insn (gdbarch, gdb_print_insn_sh);
2602   set_gdbarch_register_sim_regno (gdbarch, legacy_register_sim_regno);
2603
2604   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
2605
2606   set_gdbarch_return_value (gdbarch, sh_return_value_nofpu);
2607   set_gdbarch_deprecated_extract_struct_value_address (gdbarch,
2608                                             sh_extract_struct_value_address);
2609
2610   set_gdbarch_skip_prologue (gdbarch, sh_skip_prologue);
2611   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2612
2613   set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call_nofpu);
2614
2615   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
2616
2617   set_gdbarch_frame_align (gdbarch, sh_frame_align);
2618   set_gdbarch_unwind_sp (gdbarch, sh_unwind_sp);
2619   set_gdbarch_unwind_pc (gdbarch, sh_unwind_pc);
2620   set_gdbarch_unwind_dummy_id (gdbarch, sh_unwind_dummy_id);
2621   frame_base_set_default (gdbarch, &sh_frame_base);
2622
2623   set_gdbarch_in_function_epilogue_p (gdbarch, sh_in_function_epilogue_p);
2624
2625   switch (info.bfd_arch_info->mach)
2626     {
2627     case bfd_mach_sh:
2628       set_gdbarch_register_name (gdbarch, sh_sh_register_name);
2629       break;
2630
2631     case bfd_mach_sh2:
2632       set_gdbarch_register_name (gdbarch, sh_sh_register_name);
2633       break;
2634
2635     case bfd_mach_sh2e:
2636       /* doubles on sh2e and sh3e are actually 4 byte. */
2637       set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2638
2639       set_gdbarch_register_name (gdbarch, sh_sh2e_register_name);
2640       set_gdbarch_register_type (gdbarch, sh_sh3e_register_type);
2641       set_gdbarch_fp0_regnum (gdbarch, 25);
2642       set_gdbarch_return_value (gdbarch, sh_return_value_fpu);
2643       set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call_fpu);
2644       break;
2645
2646     case bfd_mach_sh2a:
2647       set_gdbarch_register_name (gdbarch, sh_sh2a_register_name);
2648       set_gdbarch_register_type (gdbarch, sh_sh2a_register_type);
2649       set_gdbarch_register_sim_regno (gdbarch, sh_sh2a_register_sim_regno);
2650
2651       set_gdbarch_fp0_regnum (gdbarch, 25);
2652       set_gdbarch_num_pseudo_regs (gdbarch, 9);
2653       set_gdbarch_pseudo_register_read (gdbarch, sh_pseudo_register_read);
2654       set_gdbarch_pseudo_register_write (gdbarch, sh_pseudo_register_write);
2655       set_gdbarch_return_value (gdbarch, sh_return_value_fpu);
2656       set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call_fpu);
2657       break;
2658
2659     case bfd_mach_sh2a_nofpu:
2660       set_gdbarch_register_name (gdbarch, sh_sh2a_nofpu_register_name);
2661       set_gdbarch_register_sim_regno (gdbarch, sh_sh2a_register_sim_regno);
2662
2663       set_gdbarch_num_pseudo_regs (gdbarch, 1);
2664       set_gdbarch_pseudo_register_read (gdbarch, sh_pseudo_register_read);
2665       set_gdbarch_pseudo_register_write (gdbarch, sh_pseudo_register_write);
2666       break;
2667
2668     case bfd_mach_sh_dsp:
2669       set_gdbarch_register_name (gdbarch, sh_sh_dsp_register_name);
2670       set_gdbarch_register_sim_regno (gdbarch, sh_dsp_register_sim_regno);
2671       break;
2672
2673     case bfd_mach_sh3:
2674       set_gdbarch_register_name (gdbarch, sh_sh3_register_name);
2675       break;
2676
2677     case bfd_mach_sh3e:
2678       /* doubles on sh2e and sh3e are actually 4 byte. */
2679       set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2680
2681       set_gdbarch_register_name (gdbarch, sh_sh3e_register_name);
2682       set_gdbarch_register_type (gdbarch, sh_sh3e_register_type);
2683       set_gdbarch_fp0_regnum (gdbarch, 25);
2684       set_gdbarch_return_value (gdbarch, sh_return_value_fpu);
2685       set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call_fpu);
2686       break;
2687
2688     case bfd_mach_sh3_dsp:
2689       set_gdbarch_register_name (gdbarch, sh_sh3_dsp_register_name);
2690       set_gdbarch_register_sim_regno (gdbarch, sh_dsp_register_sim_regno);
2691       break;
2692
2693     case bfd_mach_sh4:
2694     case bfd_mach_sh4a:
2695       set_gdbarch_register_name (gdbarch, sh_sh4_register_name);
2696       set_gdbarch_register_type (gdbarch, sh_sh4_register_type);
2697       set_gdbarch_fp0_regnum (gdbarch, 25);
2698       set_gdbarch_num_pseudo_regs (gdbarch, 13);
2699       set_gdbarch_pseudo_register_read (gdbarch, sh_pseudo_register_read);
2700       set_gdbarch_pseudo_register_write (gdbarch, sh_pseudo_register_write);
2701       set_gdbarch_return_value (gdbarch, sh_return_value_fpu);
2702       set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call_fpu);
2703       break;
2704
2705     case bfd_mach_sh4_nofpu:
2706     case bfd_mach_sh4a_nofpu:
2707       set_gdbarch_register_name (gdbarch, sh_sh4_nofpu_register_name);
2708       break;
2709
2710     case bfd_mach_sh4al_dsp:
2711       set_gdbarch_register_name (gdbarch, sh_sh4al_dsp_register_name);
2712       set_gdbarch_register_sim_regno (gdbarch, sh_dsp_register_sim_regno);
2713       break;
2714
2715     default:
2716       set_gdbarch_register_name (gdbarch, sh_sh_register_name);
2717       break;
2718     }
2719
2720   /* Hook in ABI-specific overrides, if they have been registered.  */
2721   gdbarch_init_osabi (info, gdbarch);
2722
2723   frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
2724   frame_unwind_append_sniffer (gdbarch, sh_frame_sniffer);
2725
2726   return gdbarch;
2727 }
2728
2729 extern initialize_file_ftype _initialize_sh_tdep;       /* -Wmissing-prototypes */
2730
2731 void
2732 _initialize_sh_tdep (void)
2733 {
2734   struct cmd_list_element *c;
2735
2736   gdbarch_register (bfd_arch_sh, sh_gdbarch_init, NULL);
2737
2738   add_com ("regs", class_vars, sh_show_regs_command, _("Print all registers"));
2739 }