gdb/sh-tdep.c

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