gdb/sh-tdep.c

   1 /* Target-dependent code for Hitachi Super-H, for GDB.
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 /*
  23    Contributed by Steve Chamberlain
  24    sac@cygnus.com
  25  */
  26
  27 #include "defs.h"
  28 #include "frame.h"
  29 #include "symtab.h"
  30 #include "symfile.h"
  31 #include "gdbtypes.h"
  32 #include "gdbcmd.h"
  33 #include "gdbcore.h"
  34 #include "value.h"
  35 #include "dis-asm.h"
  36 #include "inferior.h"           /* for BEFORE_TEXT_END etc. */
  37 #include "gdb_string.h"
  38 #include "arch-utils.h"
  39 #include "floatformat.h"
  40 #include "regcache.h"
  41 #include "doublest.h"
  42
  43 #include "sh-tdep.h"
  44
  45 #include "elf-bfd.h"
  46 #include "solib-svr4.h"
  47
  48 /* sh64 flags */
  49 #include "elf/sh.h"
  50 /* registers numbers shared with the simulator */
  51 #include "gdb/sim-sh.h"
  52
  53 void (*sh_show_regs) (void);
  54 CORE_ADDR (*skip_prologue_hard_way) (CORE_ADDR);
  55 void (*do_pseudo_register) (int);
  56
  57 #define SH_DEFAULT_NUM_REGS 59
  58
  59 /* Define other aspects of the stack frame.
  60    we keep a copy of the worked out return pc lying around, since it
  61    is a useful bit of info */
  62
  63 struct frame_extra_info
  64 {
  65   CORE_ADDR return_pc;
  66   int leaf_function;
  67   int f_offset;
  68 };
  69
  70 static const char *
  71 sh_generic_register_name (int reg_nr)
  72 {
  73   static char *register_names[] =
  74   {
  75     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
  76     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
  77     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
  78     "fpul", "fpscr",
  79     "fr0",  "fr1",  "fr2",  "fr3",  "fr4",  "fr5",  "fr6",  "fr7",
  80     "fr8",  "fr9",  "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
  81     "ssr",  "spc",
  82     "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
  83     "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
  84   };
  85   if (reg_nr < 0)
  86     return NULL;
  87   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
  88     return NULL;
  89   return register_names[reg_nr];
  90 }
  91
  92 static const char *
  93 sh_sh_register_name (int reg_nr)
  94 {
  95   static char *register_names[] =
  96   {
  97     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
  98     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
  99     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 100     "",     "",
 101     "",     "",     "",     "",     "",     "",     "",     "",
 102     "",     "",     "",     "",     "",     "",     "",     "",
 103     "",     "",
 104     "",     "",     "",     "",     "",     "",     "",     "",
 105     "",     "",     "",     "",     "",     "",     "",     "",
 106   };
 107   if (reg_nr < 0)
 108     return NULL;
 109   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 110     return NULL;
 111   return register_names[reg_nr];
 112 }
 113
 114 static const char *
 115 sh_sh3_register_name (int reg_nr)
 116 {
 117   static char *register_names[] =
 118   {
 119     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 120     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 121     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 122     "",     "",
 123     "",     "",     "",     "",     "",     "",     "",     "",
 124     "",     "",     "",     "",     "",     "",     "",     "",
 125     "ssr",  "spc",
 126     "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
 127     "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1"
 128   };
 129   if (reg_nr < 0)
 130     return NULL;
 131   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 132     return NULL;
 133   return register_names[reg_nr];
 134 }
 135
 136 static const char *
 137 sh_sh3e_register_name (int reg_nr)
 138 {
 139   static char *register_names[] =
 140   {
 141     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 142     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 143     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 144     "fpul", "fpscr",
 145     "fr0",  "fr1",  "fr2",  "fr3",  "fr4",  "fr5",  "fr6",  "fr7",
 146     "fr8",  "fr9",  "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 147     "ssr",  "spc",
 148     "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
 149     "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
 150   };
 151   if (reg_nr < 0)
 152     return NULL;
 153   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 154     return NULL;
 155   return register_names[reg_nr];
 156 }
 157
 158 static const char *
 159 sh_sh_dsp_register_name (int reg_nr)
 160 {
 161   static char *register_names[] =
 162   {
 163     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 164     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 165     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 166     "",     "dsr",
 167     "a0g",  "a0",   "a1g",  "a1",   "m0",   "m1",   "x0",   "x1",
 168     "y0",   "y1",   "",     "",     "",     "",     "",     "mod",
 169     "",     "",
 170     "rs",   "re",   "",     "",     "",     "",     "",     "",
 171     "",     "",     "",     "",     "",     "",     "",     "",
 172   };
 173   if (reg_nr < 0)
 174     return NULL;
 175   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 176     return NULL;
 177   return register_names[reg_nr];
 178 }
 179
 180 static const char *
 181 sh_sh3_dsp_register_name (int reg_nr)
 182 {
 183   static char *register_names[] =
 184   {
 185     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 186     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 187     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 188     "",     "dsr",
 189     "a0g",  "a0",   "a1g",  "a1",   "m0",   "m1",   "x0",   "x1",
 190     "y0",   "y1",   "",     "",     "",     "",     "",     "mod",
 191     "ssr",  "spc",
 192     "rs",   "re",   "",     "",     "",     "",     "",     "",
 193     "r0b",  "r1b",  "r2b",  "r3b",  "r4b",  "r5b",  "r6b",  "r7b"
 194     "",     "",     "",     "",     "",     "",     "",     "",
 195   };
 196   if (reg_nr < 0)
 197     return NULL;
 198   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 199     return NULL;
 200   return register_names[reg_nr];
 201 }
 202
 203 static const char *
 204 sh_sh4_register_name (int reg_nr)
 205 {
 206   static char *register_names[] =
 207   {
 208     /* general registers 0-15 */
 209     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 210     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 211     /* 16 - 22 */
 212     "pc",   "pr",   "gbr",  "vbr",  "mach", "macl", "sr",
 213     /* 23, 24 */
 214     "fpul", "fpscr",
 215     /* floating point registers 25 - 40 */
 216     "fr0",  "fr1",  "fr2",  "fr3",  "fr4",  "fr5",  "fr6",  "fr7",
 217     "fr8",  "fr9",  "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 218     /* 41, 42 */
 219     "ssr",  "spc",
 220     /* bank 0 43 - 50 */
 221     "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
 222     /* bank 1 51 - 58 */
 223     "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
 224     /* double precision (pseudo) 59 - 66 */
 225     "dr0",  "dr2",  "dr4",  "dr6",  "dr8",  "dr10", "dr12", "dr14",
 226     /* vectors (pseudo) 67 - 70 */
 227     "fv0",  "fv4",  "fv8",  "fv12",
 228     /* FIXME: missing XF 71 - 86 */
 229     /* FIXME: missing XD 87 - 94 */
 230   };
 231   if (reg_nr < 0)
 232     return NULL;
 233   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 234     return NULL;
 235   return register_names[reg_nr];
 236 }
 237
 238 static const char *
 239 sh_sh64_register_name (int reg_nr)
 240 {
 241   static char *register_names[] =
 242   {
 243     /* SH MEDIA MODE (ISA 32) */
 244     /* general registers (64-bit) 0-63 */
 245     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 246     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 247     "r16",  "r17",  "r18",  "r19",  "r20",  "r21",  "r22",  "r23",
 248     "r24",  "r25",  "r26",  "r27",  "r28",  "r29",  "r30",  "r31",
 249     "r32",  "r33",  "r34",  "r35",  "r36",  "r37",  "r38",  "r39",
 250     "r40",  "r41",  "r42",  "r43",  "r44",  "r45",  "r46",  "r47",
 251     "r48",  "r49",  "r50",  "r51",  "r52",  "r53",  "r54",  "r55",
 252     "r56",  "r57",  "r58",  "r59",  "r60",  "r61",  "r62",  "r63",
 253
 254     /* pc (64-bit) 64 */
 255     "pc",
 256
 257     /* status reg., saved status reg., saved pc reg. (64-bit) 65-67 */
 258     "sr",  "ssr",  "spc",
 259
 260     /* target registers (64-bit) 68-75*/
 261     "tr0",  "tr1",  "tr2",  "tr3",  "tr4",  "tr5",  "tr6",  "tr7",
 262
 263     /* floating point state control register (32-bit) 76 */
 264     "fpscr",
 265
 266     /* single precision floating point registers (32-bit) 77-140*/
 267     "fr0",  "fr1",  "fr2",  "fr3",  "fr4",  "fr5",  "fr6",  "fr7",
 268     "fr8",  "fr9",  "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 269     "fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23",
 270     "fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31",
 271     "fr32", "fr33", "fr34", "fr35", "fr36", "fr37", "fr38", "fr39",
 272     "fr40", "fr41", "fr42", "fr43", "fr44", "fr45", "fr46", "fr47",
 273     "fr48", "fr49", "fr50", "fr51", "fr52", "fr53", "fr54", "fr55",
 274     "fr56", "fr57", "fr58", "fr59", "fr60", "fr61", "fr62", "fr63",
 275
 276     /* double precision registers (pseudo) 141-172 */
 277     "dr0",  "dr2",  "dr4",  "dr6",  "dr8",  "dr10", "dr12", "dr14",
 278     "dr16", "dr18", "dr20", "dr22", "dr24", "dr26", "dr28", "dr30",
 279     "dr32", "dr34", "dr36", "dr38", "dr40", "dr42", "dr44", "dr46",
 280     "dr48", "dr50", "dr52", "dr54", "dr56", "dr58", "dr60", "dr62",
 281
 282     /* floating point pairs (pseudo) 173-204*/
 283     "fp0",  "fp2",  "fp4",  "fp6",  "fp8",  "fp10", "fp12", "fp14",
 284     "fp16", "fp18", "fp20", "fp22", "fp24", "fp26", "fp28", "fp30",
 285     "fp32", "fp34", "fp36", "fp38", "fp40", "fp42", "fp44", "fp46",
 286     "fp48", "fp50", "fp52", "fp54", "fp56", "fp58", "fp60", "fp62",
 287
 288     /* floating point vectors (4 floating point regs) (pseudo) 205-220*/
 289     "fv0",  "fv4",  "fv8",  "fv12", "fv16", "fv20", "fv24", "fv28",
 290     "fv32", "fv36", "fv40", "fv44", "fv48", "fv52", "fv56", "fv60",
 291
 292     /* SH COMPACT MODE (ISA 16) (all pseudo) 221-272*/
 293     "r0_c", "r1_c", "r2_c",  "r3_c",  "r4_c",  "r5_c",  "r6_c",  "r7_c",
 294     "r8_c", "r9_c", "r10_c", "r11_c", "r12_c", "r13_c", "r14_c", "r15_c",
 295     "pc_c",
 296     "gbr_c", "mach_c", "macl_c", "pr_c", "t_c",
 297     "fpscr_c", "fpul_c",
 298     "fr0_c", "fr1_c", "fr2_c",  "fr3_c",  "fr4_c",  "fr5_c",  "fr6_c",  "fr7_c",
 299     "fr8_c", "fr9_c", "fr10_c", "fr11_c", "fr12_c", "fr13_c", "fr14_c", "fr15_c",
 300     "dr0_c", "dr2_c", "dr4_c",  "dr6_c",  "dr8_c",  "dr10_c", "dr12_c", "dr14_c",
 301     "fv0_c", "fv4_c", "fv8_c",  "fv12_c",
 302     /* FIXME!!!! XF0 XF15, XD0 XD14 ?????*/
 303   };
 304
 305   if (reg_nr < 0)
 306     return NULL;
 307   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 308     return NULL;
 309   return register_names[reg_nr];
 310 }
 311
 312 #define NUM_PSEUDO_REGS_SH_MEDIA 80
 313 #define NUM_PSEUDO_REGS_SH_COMPACT 51
 314
 315 static const unsigned char *
 316 sh_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 317 {
 318   /* 0xc3c3 is trapa #c3, and it works in big and little endian modes */
 319   static unsigned char breakpoint[] =  {0xc3, 0xc3};
 320
 321   *lenptr = sizeof (breakpoint);
 322   return breakpoint;
 323 }
 324
 325 /* Macros and functions for setting and testing a bit in a minimal
 326    symbol that marks it as 32-bit function.  The MSB of the minimal
 327    symbol's "info" field is used for this purpose. This field is
 328    already being used to store the symbol size, so the assumption is
 329    that the symbol size cannot exceed 2^31.
 330
 331    ELF_MAKE_MSYMBOL_SPECIAL
 332    tests whether an ELF symbol is "special", i.e. refers
 333    to a 32-bit function, and sets a "special" bit in a
 334    minimal symbol to mark it as a 32-bit function
 335    MSYMBOL_IS_SPECIAL   tests the "special" bit in a minimal symbol
 336    MSYMBOL_SIZE         returns the size of the minimal symbol, i.e.
 337    the "info" field with the "special" bit masked out */
 338
 339 #define MSYMBOL_IS_SPECIAL(msym) \
 340   (((long) MSYMBOL_INFO (msym) & 0x80000000) != 0)
 341
 342 void
 343 sh64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 344 {
 345   if (msym == NULL)
 346     return;
 347
 348   if (((elf_symbol_type *)(sym))->internal_elf_sym.st_other == STO_SH5_ISA32)
 349     {
 350       MSYMBOL_INFO (msym) = (char *) (((long) MSYMBOL_INFO (msym)) | 0x80000000);
 351       SYMBOL_VALUE_ADDRESS (msym) |= 1;
 352     }
 353 }
 354
 355 /* ISA32 (shmedia) function addresses are odd (bit 0 is set).  Here
 356    are some macros to test, set, or clear bit 0 of addresses.  */
 357 #define IS_ISA32_ADDR(addr)      ((addr) & 1)
 358 #define MAKE_ISA32_ADDR(addr)    ((addr) | 1)
 359 #define UNMAKE_ISA32_ADDR(addr)  ((addr) & ~1)
 360
 361 static int
 362 pc_is_isa32 (bfd_vma memaddr)
 363 {
 364   struct minimal_symbol *sym;
 365
 366   /* If bit 0 of the address is set, assume this is a
 367      ISA32 (shmedia) address. */
 368   if (IS_ISA32_ADDR (memaddr))
 369     return 1;
 370
 371   /* A flag indicating that this is a ISA32 function is stored by elfread.c in
 372      the high bit of the info field.  Use this to decide if the function is
 373      ISA16 or ISA32.  */
 374   sym = lookup_minimal_symbol_by_pc (memaddr);
 375   if (sym)
 376     return MSYMBOL_IS_SPECIAL (sym);
 377   else
 378     return 0;
 379 }
 380
 381 static const unsigned char *
 382 sh_sh64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 383 {
 384   /* The BRK instruction for shmedia is
 385      01101111 11110101 11111111 11110000
 386      which translates in big endian mode to 0x6f, 0xf5, 0xff, 0xf0
 387      and in little endian mode to 0xf0, 0xff, 0xf5, 0x6f */
 388
 389   /* The BRK instruction for shcompact is
 390      00000000 00111011
 391      which translates in big endian mode to 0x0, 0x3b
 392      and in little endian mode to 0x3b, 0x0*/
 393
 394   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 395     {
 396       if (pc_is_isa32 (*pcptr))
 397         {
 398           static unsigned char big_breakpoint_media[] = {0x6f, 0xf5, 0xff, 0xf0};
 399           *pcptr = UNMAKE_ISA32_ADDR (*pcptr);
 400           *lenptr = sizeof (big_breakpoint_media);
 401           return big_breakpoint_media;
 402         }
 403       else
 404         {
 405           static unsigned char big_breakpoint_compact[] = {0x0, 0x3b};
 406           *lenptr = sizeof (big_breakpoint_compact);
 407           return big_breakpoint_compact;
 408         }
 409     }
 410   else
 411     {
 412       if (pc_is_isa32 (*pcptr))
 413         {
 414           static unsigned char little_breakpoint_media[] = {0xf0, 0xff, 0xf5, 0x6f};
 415           *pcptr = UNMAKE_ISA32_ADDR (*pcptr);
 416           *lenptr = sizeof (little_breakpoint_media);
 417           return little_breakpoint_media;
 418         }
 419       else
 420         {
 421           static unsigned char little_breakpoint_compact[] = {0x3b, 0x0};
 422           *lenptr = sizeof (little_breakpoint_compact);
 423           return little_breakpoint_compact;
 424         }
 425     }
 426 }
 427
 428 /* Prologue looks like
 429    [mov.l       <regs>,@-r15]...
 430    [sts.l       pr,@-r15]
 431    [mov.l       r14,@-r15]
 432    [mov         r15,r14]
 433
 434    Actually it can be more complicated than this.  For instance, with
 435    newer gcc's:
 436
 437    mov.l   r14,@-r15
 438    add     #-12,r15
 439    mov     r15,r14
 440    mov     r4,r1
 441    mov     r5,r2
 442    mov.l   r6,@(4,r14)
 443    mov.l   r7,@(8,r14)
 444    mov.b   r1,@r14
 445    mov     r14,r1
 446    mov     r14,r1
 447    add     #2,r1
 448    mov.w   r2,@r1
 449
 450  */
 451
 452 /* PTABS/L Rn, TRa       0110101111110001nnnnnnl00aaa0000
 453    with l=1 and n = 18   0110101111110001010010100aaa0000 */
 454 #define IS_PTABSL_R18(x)  (((x) & 0xffffff8f) == 0x6bf14a00)
 455
 456 /* STS.L PR,@-r0   0100000000100010
 457    r0-4-->r0, PR-->(r0) */
 458 #define IS_STS_R0(x)            ((x) == 0x4022)
 459
 460 /* STS PR, Rm      0000mmmm00101010
 461    PR-->Rm */
 462 #define IS_STS_PR(x)            (((x) & 0xf0ff) == 0x2a)
 463
 464 /* MOV.L Rm,@(disp,r15)  00011111mmmmdddd
 465    Rm-->(dispx4+r15) */
 466 #define IS_MOV_TO_R15(x)              (((x) & 0xff00) == 0x1f00)
 467
 468 /* MOV.L R14,@(disp,r15)  000111111110dddd
 469    R14-->(dispx4+r15) */
 470 #define IS_MOV_R14(x)              (((x) & 0xfff0) == 0x1fe0)
 471
 472 /* ST.Q R14, disp, R18    101011001110dddddddddd0100100000
 473    R18-->(dispx8+R14) */
 474 #define IS_STQ_R18_R14(x)          (((x) & 0xfff003ff) == 0xace00120)
 475
 476 /* ST.Q R15, disp, R18    101011001111dddddddddd0100100000
 477    R18-->(dispx8+R15) */
 478 #define IS_STQ_R18_R15(x)          (((x) & 0xfff003ff) == 0xacf00120)
 479
 480 /* ST.L R15, disp, R18    101010001111dddddddddd0100100000
 481    R18-->(dispx4+R15) */
 482 #define IS_STL_R18_R15(x)          (((x) & 0xfff003ff) == 0xa8f00120)
 483
 484 /* ST.Q R15, disp, R14    1010 1100 1111 dddd dddd dd00 1110 0000
 485    R14-->(dispx8+R15) */
 486 #define IS_STQ_R14_R15(x)          (((x) & 0xfff003ff) == 0xacf000e0)
 487
 488 /* ST.L R15, disp, R14    1010 1000 1111 dddd dddd dd00 1110 0000
 489    R14-->(dispx4+R15) */
 490 #define IS_STL_R14_R15(x)          (((x) & 0xfff003ff) == 0xa8f000e0)
 491
 492 /* ADDI.L R15,imm,R15     1101 0100 1111 ssss ssss ss00 1111 0000
 493    R15 + imm --> R15 */
 494 #define IS_ADDIL_SP_MEDIA(x)         (((x) & 0xfff003ff) == 0xd4f000f0)
 495
 496 /* ADDI R15,imm,R15     1101 0000 1111 ssss ssss ss00 1111 0000
 497    R15 + imm --> R15 */
 498 #define IS_ADDI_SP_MEDIA(x)         (((x) & 0xfff003ff) == 0xd0f000f0)
 499
 500 /* ADD.L R15,R63,R14    0000 0000 1111 1000 1111 1100 1110 0000
 501    R15 + R63 --> R14 */
 502 #define IS_ADDL_SP_FP_MEDIA(x)          ((x) == 0x00f8fce0)
 503
 504 /* ADD R15,R63,R14    0000 0000 1111 1001 1111 1100 1110 0000
 505    R15 + R63 --> R14 */
 506 #define IS_ADD_SP_FP_MEDIA(x)   ((x) == 0x00f9fce0)
 507
 508 #define IS_MOV_SP_FP_MEDIA(x)   (IS_ADDL_SP_FP_MEDIA(x) || IS_ADD_SP_FP_MEDIA(x))
 509
 510 /* MOV #imm, R0    1110 0000 ssss ssss
 511    #imm-->R0 */
 512 #define IS_MOV_R0(x)            (((x) & 0xff00) == 0xe000)
 513
 514 /* MOV.L @(disp,PC), R0    1101 0000 iiii iiii  */
 515 #define IS_MOVL_R0(x)           (((x) & 0xff00) == 0xd000)
 516
 517 /* ADD r15,r0      0011 0000 1111 1100
 518    r15+r0-->r0 */
 519 #define IS_ADD_SP_R0(x)         ((x) == 0x30fc)
 520
 521 /* MOV.L R14 @-R0  0010 0000 1110 0110
 522    R14-->(R0-4), R0-4-->R0 */
 523 #define IS_MOV_R14_R0(x)        ((x) == 0x20e6)
 524
 525 /* ADD Rm,R63,Rn  Rm+R63-->Rn  0000 00mm mmmm 1001 1111 11nn nnnn 0000
 526    where Rm is one of r2-r9 which are the argument registers. */
 527 /* FIXME: Recognize the float and double register moves too! */
 528 #define IS_MEDIA_IND_ARG_MOV(x) \
 529 ((((x) & 0xfc0ffc0f) == 0x0009fc00) && (((x) & 0x03f00000) >= 0x00200000 && ((x) & 0x03f00000) <= 0x00900000))
 530
 531 /* ST.Q Rn,0,Rm  Rm-->Rn+0  1010 11nn nnnn 0000 0000 00mm mmmm 0000
 532    or ST.L Rn,0,Rm  Rm-->Rn+0  1010 10nn nnnn 0000 0000 00mm mmmm 0000
 533    where Rm is one of r2-r9 which are the argument registers. */
 534 #define IS_MEDIA_ARG_MOV(x) \
 535 (((((x) & 0xfc0ffc0f) == 0xac000000) || (((x) & 0xfc0ffc0f) == 0xa8000000)) \
 536    && (((x) & 0x000003f0) >= 0x00000020 && ((x) & 0x000003f0) <= 0x00000090))
 537
 538 /* ST.B R14,0,Rn     Rn-->(R14+0) 1010 0000 1110 0000 0000 00nn nnnn 0000*/
 539 /* ST.W R14,0,Rn     Rn-->(R14+0) 1010 0100 1110 0000 0000 00nn nnnn 0000*/
 540 /* ST.L R14,0,Rn     Rn-->(R14+0) 1010 1000 1110 0000 0000 00nn nnnn 0000*/
 541 /* FST.S R14,0,FRn   Rn-->(R14+0) 1011 0100 1110 0000 0000 00nn nnnn 0000*/
 542 /* FST.D R14,0,DRn   Rn-->(R14+0) 1011 1100 1110 0000 0000 00nn nnnn 0000*/
 543 #define IS_MEDIA_MOV_TO_R14(x)  \
 544 ((((x) & 0xfffffc0f) == 0xa0e00000) \
 545 || (((x) & 0xfffffc0f) == 0xa4e00000) \
 546 || (((x) & 0xfffffc0f) == 0xa8e00000) \
 547 || (((x) & 0xfffffc0f) == 0xb4e00000) \
 548 || (((x) & 0xfffffc0f) == 0xbce00000))
 549
 550 /* MOV Rm, Rn  Rm-->Rn 0110 nnnn mmmm 0011
 551    where Rm is r2-r9 */
 552 #define IS_COMPACT_IND_ARG_MOV(x) \
 553 ((((x) & 0xf00f) == 0x6003) && (((x) & 0x00f0) >= 0x0020) && (((x) & 0x00f0) <= 0x0090))
 554
 555 /* compact direct arg move!
 556    MOV.L Rn, @r14     0010 1110 mmmm 0010 */
 557 #define IS_COMPACT_ARG_MOV(x) \
 558 (((((x) & 0xff0f) == 0x2e02) && (((x) & 0x00f0) >= 0x0020) && ((x) & 0x00f0) <= 0x0090))
 559
 560 /* MOV.B Rm, @R14     0010 1110 mmmm 0000
 561    MOV.W Rm, @R14     0010 1110 mmmm 0001 */
 562 #define IS_COMPACT_MOV_TO_R14(x) \
 563 ((((x) & 0xff0f) == 0x2e00) || (((x) & 0xff0f) == 0x2e01))
 564
 565 #define IS_JSR_R0(x)           ((x) == 0x400b)
 566 #define IS_NOP(x)              ((x) == 0x0009)
 567
 568
 569 /* STS.L PR,@-r15  0100111100100010
 570    r15-4-->r15, PR-->(r15) */
 571 #define IS_STS(x)               ((x) == 0x4f22)
 572
 573 /* MOV.L Rm,@-r15  00101111mmmm0110
 574    r15-4-->r15, Rm-->(R15) */
 575 #define IS_PUSH(x)              (((x) & 0xff0f) == 0x2f06)
 576
 577 #define GET_PUSHED_REG(x)       (((x) >> 4) & 0xf)
 578
 579 /* MOV r15,r14     0110111011110011
 580    r15-->r14  */
 581 #define IS_MOV_SP_FP(x)         ((x) == 0x6ef3)
 582
 583 /* ADD #imm,r15    01111111iiiiiiii
 584    r15+imm-->r15 */
 585 #define IS_ADD_SP(x)            (((x) & 0xff00) == 0x7f00)
 586
 587 #define IS_MOV_R3(x)            (((x) & 0xff00) == 0x1a00)
 588 #define IS_SHLL_R3(x)           ((x) == 0x4300)
 589
 590 /* ADD r3,r15      0011111100111100
 591    r15+r3-->r15 */
 592 #define IS_ADD_R3SP(x)          ((x) == 0x3f3c)
 593
 594 /* FMOV.S FRm,@-Rn  Rn-4-->Rn, FRm-->(Rn)     1111nnnnmmmm1011
 595    FMOV DRm,@-Rn    Rn-8-->Rn, DRm-->(Rn)     1111nnnnmmm01011
 596    FMOV XDm,@-Rn    Rn-8-->Rn, XDm-->(Rn)     1111nnnnmmm11011 */
 597 #define IS_FMOV(x)              (((x) & 0xf00f) == 0xf00b)
 598
 599 /* MOV Rm,Rn            Rm-->Rn          0110nnnnmmmm0011
 600    MOV.L Rm,@(disp,Rn)  Rm-->(dispx4+Rn) 0001nnnnmmmmdddd
 601    MOV.L Rm,@Rn         Rm-->(Rn)        0010nnnnmmmm0010
 602    where Rm is one of r4,r5,r6,r7 which are the argument registers. */
 603 #define IS_ARG_MOV(x) \
 604 (((((x) & 0xf00f) == 0x6003) && (((x) & 0x00f0) >= 0x0040 && ((x) & 0x00f0) <= 0x0070)) \
 605  || ((((x) & 0xf000) == 0x1000) && (((x) & 0x00f0) >= 0x0040 && ((x) & 0x00f0) <= 0x0070)) \
 606  || ((((x) & 0xf00f) == 0x2002) && (((x) & 0x00f0) >= 0x0040 && ((x) & 0x00f0) <= 0x0070)))
 607
 608 /* MOV.L Rm,@(disp,r14)  00011110mmmmdddd
 609    Rm-->(dispx4+r14) where Rm is one of r4,r5,r6,r7 */
 610 #define IS_MOV_TO_R14(x) \
 611      ((((x) & 0xff00) == 0x1e) && (((x) & 0x00f0) >= 0x0040 && ((x) & 0x00f0) <= 0x0070))
 612
 613 #define FPSCR_SZ                (1 << 20)
 614
 615 /* Skip any prologue before the guts of a function */
 616
 617 /* Skip the prologue using the debug information. If this fails we'll
 618    fall back on the 'guess' method below. */
 619 static CORE_ADDR
 620 after_prologue (CORE_ADDR pc)
 621 {
 622   struct symtab_and_line sal;
 623   CORE_ADDR func_addr, func_end;
 624
 625   /* If we can not find the symbol in the partial symbol table, then
 626      there is no hope we can determine the function's start address
 627      with this code.  */
 628   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 629     return 0;
 630
 631   /* Get the line associated with FUNC_ADDR.  */
 632   sal = find_pc_line (func_addr, 0);
 633
 634   /* There are only two cases to consider.  First, the end of the source line
 635      is within the function bounds.  In that case we return the end of the
 636      source line.  Second is the end of the source line extends beyond the
 637      bounds of the current function.  We need to use the slow code to
 638      examine instructions in that case.  */
 639   if (sal.end < func_end)
 640     return sal.end;
 641   else
 642     return 0;
 643 }
 644
 645 /* Here we look at each instruction in the function, and try to guess
 646    where the prologue ends. Unfortunately this is not always
 647    accurate. */
 648 static CORE_ADDR
 649 sh_skip_prologue_hard_way (CORE_ADDR start_pc)
 650 {
 651   CORE_ADDR here, end;
 652   int updated_fp = 0;
 653
 654   if (!start_pc)
 655     return 0;
 656
 657   for (here = start_pc, end = start_pc + (2 * 28); here < end;)
 658     {
 659       int w = read_memory_integer (here, 2);
 660       here += 2;
 661       if (IS_FMOV (w) || IS_PUSH (w) || IS_STS (w) || IS_MOV_R3 (w)
 662           || IS_ADD_R3SP (w) || IS_ADD_SP (w) || IS_SHLL_R3 (w)
 663           || IS_ARG_MOV (w) || IS_MOV_TO_R14 (w))
 664         {
 665           start_pc = here;
 666         }
 667       else if (IS_MOV_SP_FP (w))
 668         {
 669           start_pc = here;
 670           updated_fp = 1;
 671         }
 672       else
 673         /* Don't bail out yet, if we are before the copy of sp. */
 674         if (updated_fp)
 675           break;
 676     }
 677
 678   return start_pc;
 679 }
 680
 681 static CORE_ADDR
 682 look_for_args_moves (CORE_ADDR start_pc, int media_mode)
 683 {
 684   CORE_ADDR here, end;
 685   int w;
 686   int insn_size = (media_mode ? 4 : 2);
 687
 688   for (here = start_pc, end = start_pc + (insn_size * 28); here < end;)
 689     {
 690       if (media_mode)
 691         {
 692           w = read_memory_integer (UNMAKE_ISA32_ADDR (here), insn_size);
 693           here += insn_size;
 694           if (IS_MEDIA_IND_ARG_MOV (w))
 695             {
 696               /* This must be followed by a store to r14, so the argument
 697                  is where the debug info says it is. This can happen after
 698                  the SP has been saved, unfortunately. */
 699
 700               int next_insn = read_memory_integer (UNMAKE_ISA32_ADDR (here),
 701                                                    insn_size);
 702               here += insn_size;
 703               if (IS_MEDIA_MOV_TO_R14 (next_insn))
 704                 start_pc = here;
 705             }
 706           else if (IS_MEDIA_ARG_MOV (w))
 707             {
 708               /* These instructions store directly the argument in r14. */
 709               start_pc = here;
 710             }
 711           else
 712             break;
 713         }
 714       else
 715         {
 716           w = read_memory_integer (here, insn_size);
 717           w = w & 0xffff;
 718           here += insn_size;
 719           if (IS_COMPACT_IND_ARG_MOV (w))
 720             {
 721               /* This must be followed by a store to r14, so the argument
 722                  is where the debug info says it is. This can happen after
 723                  the SP has been saved, unfortunately. */
 724
 725               int next_insn = 0xffff & read_memory_integer (here, insn_size);
 726               here += insn_size;
 727               if (IS_COMPACT_MOV_TO_R14 (next_insn))
 728                 start_pc = here;
 729             }
 730           else if (IS_COMPACT_ARG_MOV (w))
 731             {
 732               /* These instructions store directly the argument in r14. */
 733               start_pc = here;
 734             }
 735           else if (IS_MOVL_R0 (w))
 736             {
 737               /* There is a function that gcc calls to get the arguments
 738                  passed correctly to the function. Only after this
 739                  function call the arguments will be found at the place
 740                  where they are supposed to be. This happens in case the
 741                  argument has to be stored into a 64-bit register (for
 742                  instance doubles, long longs).  SHcompact doesn't have
 743                  access to the full 64-bits, so we store the register in
 744                  stack slot and store the address of the stack slot in
 745                  the register, then do a call through a wrapper that
 746                  loads the memory value into the register.  A SHcompact
 747                  callee calls an argument decoder
 748                  (GCC_shcompact_incoming_args) that stores the 64-bit
 749                  value in a stack slot and stores the address of the
 750                  stack slot in the register.  GCC thinks the argument is
 751                  just passed by transparent reference, but this is only
 752                  true after the argument decoder is called. Such a call
 753                  needs to be considered part of the prologue. */
 754
 755               /* This must be followed by a JSR @r0 instruction and by
 756                  a NOP instruction. After these, the prologue is over!  */
 757
 758               int next_insn = 0xffff & read_memory_integer (here, insn_size);
 759               here += insn_size;
 760               if (IS_JSR_R0 (next_insn))
 761                 {
 762                   next_insn = 0xffff & read_memory_integer (here, insn_size);
 763                   here += insn_size;
 764
 765                   if (IS_NOP (next_insn))
 766                     start_pc = here;
 767                 }
 768             }
 769           else
 770             break;
 771         }
 772     }
 773
 774   return start_pc;
 775 }
 776
 777 static CORE_ADDR
 778 sh64_skip_prologue_hard_way (CORE_ADDR start_pc)
 779 {
 780   CORE_ADDR here, end;
 781   int updated_fp = 0;
 782   int insn_size = 4;
 783   int media_mode = 1;
 784
 785   if (!start_pc)
 786     return 0;
 787
 788   if (pc_is_isa32 (start_pc) == 0)
 789     {
 790       insn_size = 2;
 791       media_mode = 0;
 792     }
 793
 794   for (here = start_pc, end = start_pc + (insn_size * 28); here < end;)
 795     {
 796
 797       if (media_mode)
 798         {
 799           int w = read_memory_integer (UNMAKE_ISA32_ADDR (here), insn_size);
 800           here += insn_size;
 801           if (IS_STQ_R18_R14 (w) || IS_STQ_R18_R15 (w) || IS_STQ_R14_R15 (w)
 802               || IS_STL_R14_R15 (w) || IS_STL_R18_R15 (w)
 803               || IS_ADDIL_SP_MEDIA (w) || IS_ADDI_SP_MEDIA (w) || IS_PTABSL_R18 (w))
 804             {
 805               start_pc = here;
 806             }
 807           else if (IS_MOV_SP_FP (w) || IS_MOV_SP_FP_MEDIA(w))
 808             {
 809               start_pc = here;
 810               updated_fp = 1;
 811             }
 812           else
 813             if (updated_fp)
 814               {
 815                 /* Don't bail out yet, we may have arguments stored in
 816                    registers here, according to the debug info, so that
 817                    gdb can print the frames correctly. */
 818                 start_pc = look_for_args_moves (here - insn_size, media_mode);
 819                 break;
 820               }
 821         }
 822       else
 823         {
 824           int w = 0xffff & read_memory_integer (here, insn_size);
 825           here += insn_size;
 826
 827           if (IS_STS_R0 (w) || IS_STS_PR (w)
 828               || IS_MOV_TO_R15 (w) || IS_MOV_R14 (w)
 829               || IS_MOV_R0 (w) || IS_ADD_SP_R0 (w) || IS_MOV_R14_R0 (w))
 830             {
 831               start_pc = here;
 832             }
 833           else if (IS_MOV_SP_FP (w))
 834             {
 835               start_pc = here;
 836               updated_fp = 1;
 837             }
 838           else
 839             if (updated_fp)
 840               {
 841                 /* Don't bail out yet, we may have arguments stored in
 842                    registers here, according to the debug info, so that
 843                    gdb can print the frames correctly. */
 844                 start_pc = look_for_args_moves (here - insn_size, media_mode);
 845                 break;
 846               }
 847         }
 848     }
 849
 850   return start_pc;
 851 }
 852
 853 static CORE_ADDR
 854 sh_skip_prologue (CORE_ADDR pc)
 855 {
 856   CORE_ADDR post_prologue_pc;
 857
 858   /* See if we can determine the end of the prologue via the symbol table.
 859      If so, then return either PC, or the PC after the prologue, whichever
 860      is greater.  */
 861   post_prologue_pc = after_prologue (pc);
 862
 863   /* If after_prologue returned a useful address, then use it.  Else
 864      fall back on the instruction skipping code. */
 865   if (post_prologue_pc != 0)
 866     return max (pc, post_prologue_pc);
 867   else
 868     return (skip_prologue_hard_way (pc));
 869 }
 870
 871 /* Immediately after a function call, return the saved pc.
 872    Can't always go through the frames for this because on some machines
 873    the new frame is not set up until the new function executes
 874    some instructions.
 875
 876    The return address is the value saved in the PR register + 4  */
 877 static CORE_ADDR
 878 sh_saved_pc_after_call (struct frame_info *frame)
 879 {
 880   return (ADDR_BITS_REMOVE (read_register (gdbarch_tdep (current_gdbarch)->PR_REGNUM)));
 881 }
 882
 883 /* Should call_function allocate stack space for a struct return?  */
 884 static int
 885 sh_use_struct_convention (int gcc_p, struct type *type)
 886 {
 887 #if 0
 888   return (TYPE_LENGTH (type) > 1);
 889 #else
 890   int len = TYPE_LENGTH (type);
 891   int nelem = TYPE_NFIELDS (type);
 892   return ((len != 1 && len != 2 && len != 4 && len != 8) || nelem != 1) &&
 893           (len != 8 || TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) != 4);
 894 #endif
 895 }
 896
 897 static int
 898 sh64_use_struct_convention (int gcc_p, struct type *type)
 899 {
 900   return (TYPE_LENGTH (type) > 8);
 901 }
 902
 903 /* Store the address of the place in which to copy the structure the
 904    subroutine will return.  This is called from call_function.
 905
 906    We store structs through a pointer passed in R2 */
 907 static void
 908 sh_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 909 {
 910   write_register (STRUCT_RETURN_REGNUM, (addr));
 911 }
 912
 913 /* Disassemble an instruction.  */
 914 static int
 915 gdb_print_insn_sh (bfd_vma memaddr, disassemble_info *info)
 916 {
 917   info->endian = TARGET_BYTE_ORDER;
 918   return print_insn_sh (memaddr, info);
 919 }
 920
 921 /* Given a GDB frame, determine the address of the calling function's
 922    frame.  This will be used to create a new GDB frame struct, and
 923    then INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC will be
 924    called for the new frame.
 925
 926    For us, the frame address is its stack pointer value, so we look up
 927    the function prologue to determine the caller's sp value, and return it.  */
 928 static CORE_ADDR
 929 sh_frame_chain (struct frame_info *frame)
 930 {
 931   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), frame->frame, frame->frame))
 932     return frame->frame;        /* dummy frame same as caller's frame */
 933   if (get_frame_pc (frame) && !inside_entry_file (get_frame_pc (frame)))
 934     return read_memory_integer (get_frame_base (frame) + frame->extra_info->f_offset, 4);
 935   else
 936     return 0;
 937 }
 938
 939 /* Given a register number RN as it appears in an assembly
 940    instruction, find the corresponding register number in the GDB
 941    scheme. */
 942 static int
 943 translate_insn_rn (int rn, int media_mode)
 944 {
 945   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 946
 947   /* FIXME: this assumes that the number rn is for a not pseudo
 948      register only. */
 949   if (media_mode)
 950     return rn;
 951   else
 952     {
 953       /* These registers don't have a corresponding compact one. */
 954       /* FIXME: This is probably not enough. */
 955 #if 0
 956       if ((rn >= 16 && rn <= 63) || (rn >= 93 && rn <= 140))
 957         return rn;
 958 #endif
 959       if (rn >= 0 && rn <= tdep->R0_C_REGNUM)
 960         return tdep->R0_C_REGNUM + rn;
 961       else
 962         return rn;
 963     }
 964 }
 965
 966 static CORE_ADDR
 967 sh64_frame_chain (struct frame_info *frame)
 968 {
 969   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), frame->frame, frame->frame))
 970     return frame->frame;        /* dummy frame same as caller's frame */
 971   if (get_frame_pc (frame) && !inside_entry_file (get_frame_pc (frame)))
 972     {
 973       int media_mode = pc_is_isa32 (get_frame_pc (frame));
 974       int size;
 975       if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
 976         size = 4;
 977       else
 978         size = REGISTER_RAW_SIZE (translate_insn_rn (FP_REGNUM, media_mode));
 979       return read_memory_integer (get_frame_base (frame) + frame->extra_info->f_offset, size);
 980     }
 981   else
 982     return 0;
 983 }
 984
 985 /* Find REGNUM on the stack.  Otherwise, it's in an active register.  One thing
 986    we might want to do here is to check REGNUM against the clobber mask, and
 987    somehow flag it as invalid if it isn't saved on the stack somewhere.  This
 988    would provide a graceful failure mode when trying to get the value of
 989    caller-saves registers for an inner frame.  */
 990 static CORE_ADDR
 991 sh_find_callers_reg (struct frame_info *fi, int regnum)
 992 {
 993   for (; fi; fi = fi->next)
 994     if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
 995       /* When the caller requests PR from the dummy frame, we return PC because
 996          that's where the previous routine appears to have done a call from. */
 997       return deprecated_read_register_dummy (get_frame_pc (fi), fi->frame, regnum);
 998     else
 999       {
1000         FRAME_INIT_SAVED_REGS (fi);
1001         if (!get_frame_pc (fi))
1002           return 0;
1003         if (fi->saved_regs[regnum] != 0)
1004           return read_memory_integer (fi->saved_regs[regnum],
1005                                       REGISTER_RAW_SIZE (regnum));
1006       }
1007   return read_register (regnum);
1008 }
1009
1010 static CORE_ADDR
1011 sh64_get_saved_pr (struct frame_info *fi, int pr_regnum)
1012 {
1013   int media_mode = 0;
1014
1015   for (; fi; fi = fi->next)
1016     if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
1017       /* When the caller requests PR from the dummy frame, we return PC because
1018          that's where the previous routine appears to have done a call from. */
1019       return deprecated_read_register_dummy (get_frame_pc (fi), fi->frame, pr_regnum);
1020     else
1021       {
1022         FRAME_INIT_SAVED_REGS (fi);
1023         if (!get_frame_pc (fi))
1024           return 0;
1025
1026         media_mode = pc_is_isa32 (get_frame_pc (fi));
1027
1028         if (fi->saved_regs[pr_regnum] != 0)
1029           {
1030             int gdb_reg_num = translate_insn_rn (pr_regnum, media_mode);
1031             int size = ((gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
1032                         ? 4
1033                         : REGISTER_RAW_SIZE (gdb_reg_num));
1034             return read_memory_integer (fi->saved_regs[pr_regnum], size);
1035           }
1036       }
1037   return read_register (pr_regnum);
1038 }
1039
1040 /* Put here the code to store, into a struct frame_saved_regs, the
1041    addresses of the saved registers of frame described by FRAME_INFO.
1042    This includes special registers such as pc and fp saved in special
1043    ways in the stack frame.  sp is even more special: the address we
1044    return for it IS the sp for the next frame. */
1045 static void
1046 sh_nofp_frame_init_saved_regs (struct frame_info *fi)
1047 {
1048   int *where = (int *) alloca ((NUM_REGS + NUM_PSEUDO_REGS) * sizeof(int));
1049   int rn;
1050   int have_fp = 0;
1051   int depth;
1052   int pc;
1053   int opc;
1054   int insn;
1055   int r3_val = 0;
1056   char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi), fi->frame);
1057
1058   if (fi->saved_regs == NULL)
1059     frame_saved_regs_zalloc (fi);
1060   else
1061     memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
1062
1063   if (dummy_regs)
1064     {
1065       /* DANGER!  This is ONLY going to work if the char buffer format of
1066          the saved registers is byte-for-byte identical to the
1067          CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */
1068       memcpy (fi->saved_regs, dummy_regs, sizeof (fi->saved_regs));
1069       return;
1070     }
1071
1072   fi->extra_info->leaf_function = 1;
1073   fi->extra_info->f_offset = 0;
1074
1075   for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++)
1076     where[rn] = -1;
1077
1078   depth = 0;
1079
1080   /* Loop around examining the prologue insns until we find something
1081      that does not appear to be part of the prologue.  But give up
1082      after 20 of them, since we're getting silly then. */
1083
1084   pc = get_pc_function_start (get_frame_pc (fi));
1085   if (!pc)
1086     {
1087       deprecated_update_frame_pc_hack (fi, 0);
1088       return;
1089     }
1090
1091   for (opc = pc + (2 * 28); pc < opc; pc += 2)
1092     {
1093       insn = read_memory_integer (pc, 2);
1094       /* See where the registers will be saved to */
1095       if (IS_PUSH (insn))
1096         {
1097           rn = GET_PUSHED_REG (insn);
1098           where[rn] = depth;
1099           depth += 4;
1100         }
1101       else if (IS_STS (insn))
1102         {
1103           where[gdbarch_tdep (current_gdbarch)->PR_REGNUM] = depth;
1104           /* If we're storing the pr then this isn't a leaf */
1105           fi->extra_info->leaf_function = 0;
1106           depth += 4;
1107         }
1108       else if (IS_MOV_R3 (insn))
1109         {
1110           r3_val = ((insn & 0xff) ^ 0x80) - 0x80;
1111         }
1112       else if (IS_SHLL_R3 (insn))
1113         {
1114           r3_val <<= 1;
1115         }
1116       else if (IS_ADD_R3SP (insn))
1117         {
1118           depth += -r3_val;
1119         }
1120       else if (IS_ADD_SP (insn))
1121         {
1122           depth -= ((insn & 0xff) ^ 0x80) - 0x80;
1123         }
1124       else if (IS_MOV_SP_FP (insn))
1125         break;
1126 #if 0 /* This used to just stop when it found an instruction that
1127          was not considered part of the prologue.  Now, we just
1128          keep going looking for likely instructions. */
1129       else
1130         break;
1131 #endif
1132     }
1133
1134   /* Now we know how deep things are, we can work out their addresses */
1135
1136   for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++)
1137     {
1138       if (where[rn] >= 0)
1139         {
1140           if (rn == FP_REGNUM)
1141             have_fp = 1;
1142
1143           fi->saved_regs[rn] = fi->frame - where[rn] + depth - 4;
1144         }
1145       else
1146         {
1147           fi->saved_regs[rn] = 0;
1148         }
1149     }
1150
1151   if (have_fp)
1152     {
1153       fi->saved_regs[SP_REGNUM] = read_memory_integer (fi->saved_regs[FP_REGNUM], 4);
1154     }
1155   else
1156     {
1157       fi->saved_regs[SP_REGNUM] = fi->frame - 4;
1158     }
1159
1160   fi->extra_info->f_offset = depth - where[FP_REGNUM] - 4;
1161   /* Work out the return pc - either from the saved pr or the pr
1162      value */
1163 }
1164
1165 /* For vectors of 4 floating point registers. */
1166 static int
1167 fv_reg_base_num (int fv_regnum)
1168 {
1169   int fp_regnum;
1170
1171   fp_regnum = FP0_REGNUM +
1172     (fv_regnum - gdbarch_tdep (current_gdbarch)->FV0_REGNUM) * 4;
1173   return fp_regnum;
1174 }
1175
1176 /* For double precision floating point registers, i.e 2 fp regs.*/
1177 static int
1178 dr_reg_base_num (int dr_regnum)
1179 {
1180   int fp_regnum;
1181
1182   fp_regnum = FP0_REGNUM +
1183     (dr_regnum - gdbarch_tdep (current_gdbarch)->DR0_REGNUM) * 2;
1184   return fp_regnum;
1185 }
1186
1187 /* For pairs of floating point registers */
1188 static int
1189 fpp_reg_base_num (int fpp_regnum)
1190 {
1191   int fp_regnum;
1192
1193   fp_regnum = FP0_REGNUM +
1194     (fpp_regnum - gdbarch_tdep (current_gdbarch)->FPP0_REGNUM) * 2;
1195   return fp_regnum;
1196 }
1197
1198 static int
1199 is_media_pseudo (int rn)
1200 {
1201   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1202
1203   return (rn >= tdep->DR0_REGNUM
1204           && rn <= tdep->FV_LAST_REGNUM);
1205 }
1206
1207 int
1208 sh64_get_gdb_regnum (int gcc_regnum, CORE_ADDR pc)
1209 {
1210   return translate_insn_rn (gcc_regnum, pc_is_isa32 (pc));
1211 }
1212
1213 static int
1214 sh64_media_reg_base_num (int reg_nr)
1215 {
1216   int base_regnum = -1;
1217   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1218
1219   if (reg_nr >= tdep->DR0_REGNUM
1220       && reg_nr <= tdep->DR_LAST_REGNUM)
1221     base_regnum = dr_reg_base_num (reg_nr);
1222
1223   else if (reg_nr >= tdep->FPP0_REGNUM
1224            && reg_nr <= tdep->FPP_LAST_REGNUM)
1225     base_regnum = fpp_reg_base_num (reg_nr);
1226
1227   else if (reg_nr >= tdep->FV0_REGNUM
1228            && reg_nr <= tdep->FV_LAST_REGNUM)
1229     base_regnum = fv_reg_base_num (reg_nr);
1230
1231   return base_regnum;
1232 }
1233
1234 /* *INDENT-OFF* */
1235 /*
1236     SH COMPACT MODE (ISA 16) (all pseudo) 221-272
1237        GDB_REGNUM  BASE_REGNUM
1238  r0_c       221      0
1239  r1_c       222      1
1240  r2_c       223      2
1241  r3_c       224      3
1242  r4_c       225      4
1243  r5_c       226      5
1244  r6_c       227      6
1245  r7_c       228      7
1246  r8_c       229      8
1247  r9_c       230      9
1248  r10_c      231      10
1249  r11_c      232      11
1250  r12_c      233      12
1251  r13_c      234      13
1252  r14_c      235      14
1253  r15_c      236      15
1254
1255  pc_c       237      64
1256  gbr_c      238      16
1257  mach_c     239      17
1258  macl_c     240      17
1259  pr_c       241      18
1260  t_c        242      19
1261  fpscr_c    243      76
1262  fpul_c     244      109
1263
1264  fr0_c      245      77
1265  fr1_c      246      78
1266  fr2_c      247      79
1267  fr3_c      248      80
1268  fr4_c      249      81
1269  fr5_c      250      82
1270  fr6_c      251      83
1271  fr7_c      252      84
1272  fr8_c      253      85
1273  fr9_c      254      86
1274  fr10_c     255      87
1275  fr11_c     256      88
1276  fr12_c     257      89
1277  fr13_c     258      90
1278  fr14_c     259      91
1279  fr15_c     260      92
1280
1281  dr0_c      261      77
1282  dr2_c      262      79
1283  dr4_c      263      81
1284  dr6_c      264      83
1285  dr8_c      265      85
1286  dr10_c     266      87
1287  dr12_c     267      89
1288  dr14_c     268      91
1289
1290  fv0_c      269      77
1291  fv4_c      270      81
1292  fv8_c      271      85
1293  fv12_c     272      91
1294 */
1295 /* *INDENT-ON* */
1296 static int
1297 sh64_compact_reg_base_num (int reg_nr)
1298 {
1299   int base_regnum = -1;
1300   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1301
1302   /* general register N maps to general register N */
1303   if (reg_nr >= tdep->R0_C_REGNUM
1304       && reg_nr <= tdep->R_LAST_C_REGNUM)
1305     base_regnum = reg_nr - tdep->R0_C_REGNUM;
1306
1307   /* floating point register N maps to floating point register N */
1308   else if (reg_nr >= tdep->FP0_C_REGNUM
1309             && reg_nr <= tdep->FP_LAST_C_REGNUM)
1310     base_regnum = reg_nr - tdep->FP0_C_REGNUM + FP0_REGNUM;
1311
1312   /* double prec register N maps to base regnum for double prec register N */
1313   else if (reg_nr >= tdep->DR0_C_REGNUM
1314             && reg_nr <= tdep->DR_LAST_C_REGNUM)
1315     base_regnum = dr_reg_base_num (tdep->DR0_REGNUM
1316                                    + reg_nr - tdep->DR0_C_REGNUM);
1317
1318   /* vector N maps to base regnum for vector register N */
1319   else if (reg_nr >= tdep->FV0_C_REGNUM
1320             && reg_nr <= tdep->FV_LAST_C_REGNUM)
1321     base_regnum = fv_reg_base_num (tdep->FV0_REGNUM
1322                                    + reg_nr - tdep->FV0_C_REGNUM);
1323
1324   else if (reg_nr == tdep->PC_C_REGNUM)
1325     base_regnum = PC_REGNUM;
1326
1327   else if (reg_nr == tdep->GBR_C_REGNUM)
1328     base_regnum = 16;
1329
1330   else if (reg_nr == tdep->MACH_C_REGNUM
1331            || reg_nr == tdep->MACL_C_REGNUM)
1332     base_regnum = 17;
1333
1334   else if (reg_nr == tdep->PR_C_REGNUM)
1335     base_regnum = 18;
1336
1337   else if (reg_nr == tdep->T_C_REGNUM)
1338     base_regnum = 19;
1339
1340   else if (reg_nr == tdep->FPSCR_C_REGNUM)
1341     base_regnum = tdep->FPSCR_REGNUM; /*???? this register is a mess. */
1342
1343   else if (reg_nr == tdep->FPUL_C_REGNUM)
1344     base_regnum = FP0_REGNUM + 32;
1345
1346   return base_regnum;
1347 }
1348
1349 /* Given a register number RN (according to the gdb scheme) , return
1350    its corresponding architectural register.  In media mode, only a
1351    subset of the registers is pseudo registers. For compact mode, all
1352    the registers are pseudo. */
1353 static int
1354 translate_rn_to_arch_reg_num (int rn, int media_mode)
1355 {
1356
1357   if (media_mode)
1358     {
1359       if (!is_media_pseudo (rn))
1360         return rn;
1361       else
1362         return sh64_media_reg_base_num (rn);
1363     }
1364   else
1365     /* All compact registers are pseudo. */
1366     return sh64_compact_reg_base_num (rn);
1367 }
1368
1369 static int
1370 sign_extend (int value, int bits)
1371 {
1372   value = value & ((1 << bits) - 1);
1373   return (value & (1 << (bits - 1))
1374           ? value | (~((1 << bits) - 1))
1375           : value);
1376 }
1377
1378 static void
1379 sh64_nofp_frame_init_saved_regs (struct frame_info *fi)
1380 {
1381   int *where = (int *) alloca ((NUM_REGS + NUM_PSEUDO_REGS) * sizeof (int));
1382   int rn;
1383   int have_fp = 0;
1384   int fp_regnum;
1385   int sp_regnum;
1386   int depth;
1387   int pc;
1388   int opc;
1389   int insn;
1390   int r0_val = 0;
1391   int media_mode = 0;
1392   int insn_size;
1393   int gdb_register_number;
1394   int register_number;
1395   char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi), fi->frame);
1396   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1397
1398   if (fi->saved_regs == NULL)
1399     frame_saved_regs_zalloc (fi);
1400   else
1401     memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
1402
1403   if (dummy_regs)
1404     {
1405       /* DANGER!  This is ONLY going to work if the char buffer format of
1406          the saved registers is byte-for-byte identical to the
1407          CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */
1408       memcpy (fi->saved_regs, dummy_regs, sizeof (fi->saved_regs));
1409       return;
1410     }
1411
1412   fi->extra_info->leaf_function = 1;
1413   fi->extra_info->f_offset = 0;
1414
1415   for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++)
1416     where[rn] = -1;
1417
1418   depth = 0;
1419
1420   /* Loop around examining the prologue insns until we find something
1421      that does not appear to be part of the prologue.  But give up
1422      after 20 of them, since we're getting silly then. */
1423
1424   pc = get_pc_function_start (get_frame_pc (fi));
1425   if (!pc)
1426     {
1427       deprecated_update_frame_pc_hack (fi, 0);
1428       return;
1429     }
1430
1431   if (pc_is_isa32 (pc))
1432     {
1433       media_mode = 1;
1434       insn_size = 4;
1435     }
1436   else
1437     {
1438       media_mode = 0;
1439       insn_size = 2;
1440     }
1441
1442  /* The frame pointer register is general register 14 in shmedia and
1443     shcompact modes. In sh compact it is a pseudo register.  Same goes
1444     for the stack pointer register, which is register 15. */
1445   fp_regnum = translate_insn_rn (FP_REGNUM, media_mode);
1446   sp_regnum = translate_insn_rn (SP_REGNUM, media_mode);
1447
1448   for (opc = pc + (insn_size * 28); pc < opc; pc += insn_size)
1449     {
1450       insn = read_memory_integer (media_mode ? UNMAKE_ISA32_ADDR (pc) : pc,
1451                                   insn_size);
1452
1453       if (media_mode == 0)
1454         {
1455           if (IS_STS_PR (insn))
1456             {
1457               int next_insn = read_memory_integer (pc + insn_size, insn_size);
1458               if (IS_MOV_TO_R15 (next_insn))
1459                 {
1460                   int reg_nr = tdep->PR_C_REGNUM;
1461
1462                   where[reg_nr] = depth - ((((next_insn & 0xf) ^ 0x8) - 0x8) << 2);
1463                   fi->extra_info->leaf_function = 0;
1464                   pc += insn_size;
1465                 }
1466             }
1467           else if (IS_MOV_R14 (insn))
1468             {
1469               where[fp_regnum] = depth - ((((insn & 0xf) ^ 0x8) - 0x8) << 2);
1470             }
1471
1472           else if (IS_MOV_R0 (insn))
1473             {
1474               /* Put in R0 the offset from SP at which to store some
1475                  registers. We are interested in this value, because it
1476                  will tell us where the given registers are stored within
1477                  the frame.  */
1478               r0_val = ((insn & 0xff) ^ 0x80) - 0x80;
1479             }
1480           else if (IS_ADD_SP_R0 (insn))
1481             {
1482               /* This instruction still prepares r0, but we don't care.
1483                  We already have the offset in r0_val. */
1484             }
1485           else if (IS_STS_R0 (insn))
1486             {
1487               /* Store PR at r0_val-4 from SP. Decrement r0 by 4*/
1488               int reg_nr = tdep->PR_C_REGNUM;
1489               where[reg_nr] = depth - (r0_val - 4);
1490               r0_val -= 4;
1491               fi->extra_info->leaf_function = 0;
1492             }
1493           else if (IS_MOV_R14_R0 (insn))
1494             {
1495               /* Store R14 at r0_val-4 from SP. Decrement r0 by 4 */
1496               where[fp_regnum] = depth - (r0_val - 4);
1497               r0_val -= 4;
1498             }
1499
1500           else if (IS_ADD_SP (insn))
1501             {
1502               depth -= ((insn & 0xff) ^ 0x80) - 0x80;
1503             }
1504           else if (IS_MOV_SP_FP (insn))
1505             break;
1506         }
1507       else
1508         {
1509           if (IS_ADDIL_SP_MEDIA (insn)
1510               || IS_ADDI_SP_MEDIA (insn))
1511             {
1512               depth -= sign_extend ((((insn & 0xffc00) ^ 0x80000) - 0x80000) >> 10, 9);
1513             }
1514
1515           else if (IS_STQ_R18_R15 (insn))
1516             {
1517               where[tdep->PR_REGNUM] =
1518                 depth - (sign_extend ((insn & 0xffc00) >> 10, 9) << 3);
1519               fi->extra_info->leaf_function = 0;
1520             }
1521
1522           else if (IS_STL_R18_R15 (insn))
1523             {
1524               where[tdep->PR_REGNUM] =
1525                 depth - (sign_extend ((insn & 0xffc00) >> 10, 9) << 2);
1526               fi->extra_info->leaf_function = 0;
1527             }
1528
1529           else if (IS_STQ_R14_R15 (insn))
1530             {
1531               where[fp_regnum] = depth - (sign_extend ((insn & 0xffc00) >> 10, 9) << 3);
1532             }
1533
1534           else if (IS_STL_R14_R15 (insn))
1535             {
1536               where[fp_regnum] = depth - (sign_extend ((insn & 0xffc00) >> 10, 9) << 2);
1537             }
1538
1539           else if (IS_MOV_SP_FP_MEDIA (insn))
1540             break;
1541         }
1542     }
1543
1544   /* Now we know how deep things are, we can work out their addresses. */
1545   for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++)
1546     {
1547       register_number = translate_rn_to_arch_reg_num (rn, media_mode);
1548
1549       if (where[rn] >= 0)
1550         {
1551           if (rn == fp_regnum)
1552             have_fp = 1;
1553
1554           /* Watch out! saved_regs is only for the real registers, and
1555              doesn't include space for the pseudo registers. */
1556           fi->saved_regs[register_number]= fi->frame - where[rn] + depth;
1557
1558         }
1559       else
1560         fi->saved_regs[register_number] = 0;
1561     }
1562
1563   if (have_fp)
1564     {
1565       /* SP_REGNUM is 15. For shmedia 15 is the real register. For
1566          shcompact 15 is the arch register corresponding to the pseudo
1567          register r15 which still is the SP register. */
1568       /* The place on the stack where fp is stored contains the sp of
1569          the caller. */
1570       /* Again, saved_registers contains only space for the real registers,
1571          so we store in FP_REGNUM position. */
1572       int size;
1573       if (tdep->sh_abi == SH_ABI_32)
1574         size = 4;
1575       else
1576         size = REGISTER_RAW_SIZE (fp_regnum);
1577       fi->saved_regs[sp_regnum] = read_memory_integer (fi->saved_regs[fp_regnum], size);
1578     }
1579   else
1580     fi->saved_regs[sp_regnum] = fi->frame;
1581
1582   fi->extra_info->f_offset = depth - where[fp_regnum];
1583 }
1584
1585 static void
1586 sh_fp_frame_init_saved_regs (struct frame_info *fi)
1587 {
1588   int *where = (int *) alloca ((NUM_REGS + NUM_PSEUDO_REGS) * sizeof (int));
1589   int rn;
1590   int have_fp = 0;
1591   int depth;
1592   int pc;
1593   int opc;
1594   int insn;
1595   int r3_val = 0;
1596   char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi), fi->frame);
1597   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1598
1599   if (fi->saved_regs == NULL)
1600     frame_saved_regs_zalloc (fi);
1601   else
1602     memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
1603
1604   if (dummy_regs)
1605     {
1606       /* DANGER!  This is ONLY going to work if the char buffer format of
1607          the saved registers is byte-for-byte identical to the
1608          CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */
1609       memcpy (fi->saved_regs, dummy_regs, sizeof (fi->saved_regs));
1610       return;
1611     }
1612
1613   fi->extra_info->leaf_function = 1;
1614   fi->extra_info->f_offset = 0;
1615
1616   for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++)
1617     where[rn] = -1;
1618
1619   depth = 0;
1620
1621   /* Loop around examining the prologue insns until we find something
1622      that does not appear to be part of the prologue.  But give up
1623      after 20 of them, since we're getting silly then. */
1624
1625   pc = get_pc_function_start (get_frame_pc (fi));
1626   if (!pc)
1627     {
1628       deprecated_update_frame_pc_hack (fi, 0);
1629       return;
1630     }
1631
1632   for (opc = pc + (2 * 28); pc < opc; pc += 2)
1633     {
1634       insn = read_memory_integer (pc, 2);
1635       /* See where the registers will be saved to */
1636       if (IS_PUSH (insn))
1637         {
1638           rn = GET_PUSHED_REG (insn);
1639           where[rn] = depth;
1640           depth += 4;
1641         }
1642       else if (IS_STS (insn))
1643         {
1644           where[tdep->PR_REGNUM] = depth;
1645           /* If we're storing the pr then this isn't a leaf */
1646           fi->extra_info->leaf_function = 0;
1647           depth += 4;
1648         }
1649       else if (IS_MOV_R3 (insn))
1650         {
1651           r3_val = ((insn & 0xff) ^ 0x80) - 0x80;
1652         }
1653       else if (IS_SHLL_R3 (insn))
1654         {
1655           r3_val <<= 1;
1656         }
1657       else if (IS_ADD_R3SP (insn))
1658         {
1659           depth += -r3_val;
1660         }
1661       else if (IS_ADD_SP (insn))
1662         {
1663           depth -= ((insn & 0xff) ^ 0x80) - 0x80;
1664         }
1665       else if (IS_FMOV (insn))
1666         {
1667           if (read_register (tdep->FPSCR_REGNUM) & FPSCR_SZ)
1668             {
1669               depth += 8;
1670             }
1671           else
1672             {
1673               depth += 4;
1674             }
1675         }
1676       else if (IS_MOV_SP_FP (insn))
1677         break;
1678 #if 0 /* This used to just stop when it found an instruction that
1679          was not considered part of the prologue.  Now, we just
1680          keep going looking for likely instructions. */
1681       else
1682         break;
1683 #endif
1684     }
1685
1686   /* Now we know how deep things are, we can work out their addresses */
1687
1688   for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++)
1689     {
1690       if (where[rn] >= 0)
1691         {
1692           if (rn == FP_REGNUM)
1693             have_fp = 1;
1694
1695           fi->saved_regs[rn] = fi->frame - where[rn] + depth - 4;
1696         }
1697       else
1698         {
1699           fi->saved_regs[rn] = 0;
1700         }
1701     }
1702
1703   if (have_fp)
1704     {
1705       fi->saved_regs[SP_REGNUM] =
1706         read_memory_integer (fi->saved_regs[FP_REGNUM], 4);
1707     }
1708   else
1709     {
1710       fi->saved_regs[SP_REGNUM] = fi->frame - 4;
1711     }
1712
1713   fi->extra_info->f_offset = depth - where[FP_REGNUM] - 4;
1714   /* Work out the return pc - either from the saved pr or the pr
1715      value */
1716 }
1717
1718 /* Initialize the extra info saved in a FRAME */
1719 static void
1720 sh_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1721 {
1722
1723   fi->extra_info = (struct frame_extra_info *)
1724     frame_obstack_alloc (sizeof (struct frame_extra_info));
1725
1726   if (fi->next)
1727     deprecated_update_frame_pc_hack (fi, FRAME_SAVED_PC (fi->next));
1728
1729   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
1730     {
1731       /* We need to setup fi->frame here because run_stack_dummy gets it wrong
1732          by assuming it's always FP.  */
1733       fi->frame = deprecated_read_register_dummy (get_frame_pc (fi), fi->frame,
1734                                                   SP_REGNUM);
1735       fi->extra_info->return_pc = deprecated_read_register_dummy (get_frame_pc (fi),
1736                                                                   fi->frame,
1737                                                                   PC_REGNUM);
1738       fi->extra_info->f_offset = -(CALL_DUMMY_LENGTH + 4);
1739       fi->extra_info->leaf_function = 0;
1740       return;
1741     }
1742   else
1743     {
1744       FRAME_INIT_SAVED_REGS (fi);
1745       fi->extra_info->return_pc =
1746         sh_find_callers_reg (fi, gdbarch_tdep (current_gdbarch)->PR_REGNUM);
1747     }
1748 }
1749
1750 static void
1751 sh64_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1752 {
1753   int media_mode = pc_is_isa32 (get_frame_pc (fi));
1754
1755   fi->extra_info = (struct frame_extra_info *)
1756     frame_obstack_alloc (sizeof (struct frame_extra_info));
1757
1758   if (fi->next)
1759     deprecated_update_frame_pc_hack (fi, FRAME_SAVED_PC (fi->next));
1760
1761   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), fi->frame, fi->frame))
1762     {
1763       /* We need to setup fi->frame here because run_stack_dummy gets it wrong
1764          by assuming it's always FP.  */
1765       fi->frame = deprecated_read_register_dummy (get_frame_pc (fi), fi->frame,
1766                                                   SP_REGNUM);
1767       fi->extra_info->return_pc =
1768         deprecated_read_register_dummy (get_frame_pc (fi), fi->frame, PC_REGNUM);
1769       fi->extra_info->f_offset = -(CALL_DUMMY_LENGTH + 4);
1770       fi->extra_info->leaf_function = 0;
1771       return;
1772     }
1773   else
1774     {
1775       FRAME_INIT_SAVED_REGS (fi);
1776       fi->extra_info->return_pc =
1777         sh64_get_saved_pr (fi, gdbarch_tdep (current_gdbarch)->PR_REGNUM);
1778     }
1779 }
1780
1781 void
1782 sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
1783                          struct frame_info *frame, int regnum,
1784                          enum lval_type *lval)
1785 {
1786   int media_mode;
1787   int live_regnum = regnum;
1788   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1789
1790   if (!target_has_registers)
1791     error ("No registers.");
1792
1793   /* Normal systems don't optimize out things with register numbers.  */
1794   if (optimized != NULL)
1795     *optimized = 0;
1796
1797   if (addrp)                    /* default assumption: not found in memory */
1798     *addrp = 0;
1799
1800   if (raw_buffer)
1801     memset (raw_buffer, 0, sizeof (raw_buffer));
1802
1803   /* We must do this here, before the following while loop changes
1804      frame, and makes it NULL. If this is a media register number,
1805      but we are in compact mode, it will become the corresponding
1806      compact pseudo register. If there is no corresponding compact
1807      pseudo-register what do we do?*/
1808   media_mode = pc_is_isa32 (get_frame_pc (frame));
1809   live_regnum = translate_insn_rn (regnum, media_mode);
1810
1811   /* Note: since the current frame's registers could only have been
1812      saved by frames INTERIOR TO the current frame, we skip examining
1813      the current frame itself: otherwise, we would be getting the
1814      previous frame's registers which were saved by the current frame.  */
1815
1816   while (frame && ((frame = frame->next) != NULL))
1817     {
1818       if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), frame->frame, frame->frame))
1819         {
1820           if (lval)             /* found it in a CALL_DUMMY frame */
1821             *lval = not_lval;
1822           if (raw_buffer)
1823             memcpy (raw_buffer,
1824                     (deprecated_generic_find_dummy_frame (get_frame_pc (frame), frame->frame)
1825                      + REGISTER_BYTE (regnum)),
1826                     REGISTER_RAW_SIZE (regnum));
1827           return;
1828         }
1829
1830       FRAME_INIT_SAVED_REGS (frame);
1831       if (frame->saved_regs != NULL
1832           && frame->saved_regs[regnum] != 0)
1833         {
1834           if (lval)             /* found it saved on the stack */
1835             *lval = lval_memory;
1836           if (regnum == SP_REGNUM)
1837             {
1838               if (raw_buffer)   /* SP register treated specially */
1839                 store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
1840                                frame->saved_regs[regnum]);
1841             }
1842           else
1843             { /* any other register */
1844
1845               if (addrp)
1846                 *addrp = frame->saved_regs[regnum];
1847               if (raw_buffer)
1848                 {
1849                   int size;
1850                   if (tdep->sh_abi == SH_ABI_32
1851                       && (live_regnum == FP_REGNUM
1852                           || live_regnum == tdep->PR_REGNUM))
1853                     size = 4;
1854                   else
1855                     size = REGISTER_RAW_SIZE (live_regnum);
1856                   if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
1857                     read_memory (frame->saved_regs[regnum], raw_buffer, size);
1858                   else
1859                     read_memory (frame->saved_regs[regnum],
1860                                  raw_buffer
1861                                  + REGISTER_RAW_SIZE (live_regnum)
1862                                  - size,
1863                                  size);
1864                 }
1865             }
1866           return;
1867         }
1868     }
1869
1870   /* If we get thru the loop to this point, it means the register was
1871      not saved in any frame.  Return the actual live-register value.  */
1872
1873   if (lval)                     /* found it in a live register */
1874     *lval = lval_register;
1875   if (addrp)
1876     *addrp = REGISTER_BYTE (live_regnum);
1877   if (raw_buffer)
1878     deprecated_read_register_gen (live_regnum, raw_buffer);
1879 }
1880
1881 /* Extract from an array REGBUF containing the (raw) register state
1882    the address in which a function should return its structure value,
1883    as a CORE_ADDR (or an expression that can be used as one).  */
1884 static CORE_ADDR
1885 sh_extract_struct_value_address (char *regbuf)
1886 {
1887   return (extract_address ((regbuf), REGISTER_RAW_SIZE (0)));
1888 }
1889
1890 static CORE_ADDR
1891 sh64_extract_struct_value_address (char *regbuf)
1892 {
1893   return (extract_address ((regbuf + REGISTER_BYTE (STRUCT_RETURN_REGNUM)),
1894                            REGISTER_RAW_SIZE (STRUCT_RETURN_REGNUM)));
1895 }
1896
1897 static CORE_ADDR
1898 sh_frame_saved_pc (struct frame_info *frame)
1899 {
1900   return ((frame)->extra_info->return_pc);
1901 }
1902
1903 /* Discard from the stack the innermost frame,
1904    restoring all saved registers.  */
1905 static void
1906 sh_pop_frame (void)
1907 {
1908   register struct frame_info *frame = get_current_frame ();
1909   register CORE_ADDR fp;
1910   register int regnum;
1911
1912   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), frame->frame, frame->frame))
1913     generic_pop_dummy_frame ();
1914   else
1915     {
1916       fp = get_frame_base (frame);
1917       FRAME_INIT_SAVED_REGS (frame);
1918
1919       /* Copy regs from where they were saved in the frame */
1920       for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
1921         if (frame->saved_regs[regnum])
1922           write_register (regnum,
1923                           read_memory_integer (frame->saved_regs[regnum], 4));
1924
1925       write_register (PC_REGNUM, frame->extra_info->return_pc);
1926       write_register (SP_REGNUM, fp + 4);
1927     }
1928   flush_cached_frames ();
1929 }
1930
1931 /* Used in the 'return' command. */
1932 static void
1933 sh64_pop_frame (void)
1934 {
1935   register struct frame_info *frame = get_current_frame ();
1936   register CORE_ADDR fp;
1937   register int regnum;
1938   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1939
1940   int media_mode = pc_is_isa32 (get_frame_pc (frame));
1941
1942   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame), frame->frame, frame->frame))
1943     generic_pop_dummy_frame ();
1944   else
1945     {
1946       fp = get_frame_base (frame);
1947       FRAME_INIT_SAVED_REGS (frame);
1948
1949       /* Copy regs from where they were saved in the frame */
1950       for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
1951         if (frame->saved_regs[regnum])
1952           {
1953             int size;
1954             if (tdep->sh_abi == SH_ABI_32
1955                 && (regnum == FP_REGNUM
1956                     || regnum ==  tdep->PR_REGNUM))
1957               size = 4;
1958             else
1959               size = REGISTER_RAW_SIZE (translate_insn_rn (regnum,
1960                                                            media_mode));
1961             write_register (regnum,
1962                             read_memory_integer (frame->saved_regs[regnum],
1963                                                  size));
1964           }
1965
1966       write_register (PC_REGNUM, frame->extra_info->return_pc);
1967       write_register (SP_REGNUM, fp + 8);
1968     }
1969   flush_cached_frames ();
1970 }
1971
1972 /* Function: push_arguments
1973    Setup the function arguments for calling a function in the inferior.
1974
1975    On the Hitachi SH architecture, there are four registers (R4 to R7)
1976    which are dedicated for passing function arguments.  Up to the first
1977    four arguments (depending on size) may go into these registers.
1978    The rest go on the stack.
1979
1980    Arguments that are smaller than 4 bytes will still take up a whole
1981    register or a whole 32-bit word on the stack, and will be
1982    right-justified in the register or the stack word.  This includes
1983    chars, shorts, and small aggregate types.
1984
1985    Arguments that are larger than 4 bytes may be split between two or
1986    more registers.  If there are not enough registers free, an argument
1987    may be passed partly in a register (or registers), and partly on the
1988    stack.  This includes doubles, long longs, and larger aggregates.
1989    As far as I know, there is no upper limit to the size of aggregates
1990    that will be passed in this way; in other words, the convention of
1991    passing a pointer to a large aggregate instead of a copy is not used.
1992
1993    An exceptional case exists for struct arguments (and possibly other
1994    aggregates such as arrays) if the size is larger than 4 bytes but
1995    not a multiple of 4 bytes.  In this case the argument is never split
1996    between the registers and the stack, but instead is copied in its
1997    entirety onto the stack, AND also copied into as many registers as
1998    there is room for.  In other words, space in registers permitting,
1999    two copies of the same argument are passed in.  As far as I can tell,
2000    only the one on the stack is used, although that may be a function
2001    of the level of compiler optimization.  I suspect this is a compiler
2002    bug.  Arguments of these odd sizes are left-justified within the
2003    word (as opposed to arguments smaller than 4 bytes, which are
2004    right-justified).
2005
2006    If the function is to return an aggregate type such as a struct, it
2007    is either returned in the normal return value register R0 (if its
2008    size is no greater than one byte), or else the caller must allocate
2009    space into which the callee will copy the return value (if the size
2010    is greater than one byte).  In this case, a pointer to the return
2011    value location is passed into the callee in register R2, which does
2012    not displace any of the other arguments passed in via registers R4
2013    to R7.   */
2014
2015 static CORE_ADDR
2016 sh_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
2017                    int struct_return, CORE_ADDR struct_addr)
2018 {
2019   int stack_offset, stack_alloc;
2020   int argreg;
2021   int argnum;
2022   struct type *type;
2023   CORE_ADDR regval;
2024   char *val;
2025   char valbuf[4];
2026   int len;
2027   int odd_sized_struct;
2028   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2029
2030   /* first force sp to a 4-byte alignment */
2031   sp = sp & ~3;
2032
2033   /* The "struct return pointer" pseudo-argument has its own dedicated
2034      register */
2035   if (struct_return)
2036     write_register (STRUCT_RETURN_REGNUM, struct_addr);
2037
2038   /* Now make sure there's space on the stack */
2039   for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
2040     stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3);
2041   sp -= stack_alloc;            /* make room on stack for args */
2042
2043   /* Now load as many as possible of the first arguments into
2044      registers, and push the rest onto the stack.  There are 16 bytes
2045      in four registers available.  Loop thru args from first to last.  */
2046
2047   argreg = tdep->ARG0_REGNUM;
2048   for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
2049     {
2050       type = VALUE_TYPE (args[argnum]);
2051       len = TYPE_LENGTH (type);
2052       memset (valbuf, 0, sizeof (valbuf));
2053       if (len < 4)
2054         {
2055           /* value gets right-justified in the register or stack word */
2056           if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2057             memcpy (valbuf + (4 - len),
2058                     (char *) VALUE_CONTENTS (args[argnum]), len);
2059           else
2060             memcpy (valbuf, (char *) VALUE_CONTENTS (args[argnum]), len);
2061           val = valbuf;
2062         }
2063       else
2064         val = (char *) VALUE_CONTENTS (args[argnum]);
2065
2066       if (len > 4 && (len & 3) != 0)
2067         odd_sized_struct = 1;   /* such structs go entirely on stack */
2068       else
2069         odd_sized_struct = 0;
2070       while (len > 0)
2071         {
2072           if (argreg > tdep->ARGLAST_REGNUM
2073               || odd_sized_struct)
2074             {
2075               /* must go on the stack */
2076               write_memory (sp + stack_offset, val, 4);
2077               stack_offset += 4;
2078             }
2079           /* NOTE WELL!!!!!  This is not an "else if" clause!!!
2080              That's because some *&^%$ things get passed on the stack
2081              AND in the registers!   */
2082           if (argreg <= tdep->ARGLAST_REGNUM)
2083             {
2084               /* there's room in a register */
2085               regval = extract_address (val, REGISTER_RAW_SIZE (argreg));
2086               write_register (argreg++, regval);
2087             }
2088           /* Store the value 4 bytes at a time.  This means that things
2089              larger than 4 bytes may go partly in registers and partly
2090              on the stack.  */
2091           len -= REGISTER_RAW_SIZE (argreg);
2092           val += REGISTER_RAW_SIZE (argreg);
2093         }
2094     }
2095   return sp;
2096 }
2097
2098 /* R2-R9 for integer types and integer equivalent (char, pointers) and
2099    non-scalar (struct, union) elements (even if the elements are
2100    floats).
2101    FR0-FR11 for single precision floating point (float)
2102    DR0-DR10 for double precision floating point (double)
2103
2104    If a float is argument number 3 (for instance) and arguments number
2105    1,2, and 4 are integer, the mapping will be:
2106    arg1 -->R2, arg2 --> R3, arg3 -->FR0, arg4 --> R5. I.e. R4 is not used.
2107
2108    If a float is argument number 10 (for instance) and arguments number
2109    1 through 10 are integer, the mapping will be:
2110    arg1->R2, arg2->R3, arg3->R4, arg4->R5, arg5->R6, arg6->R7, arg7->R8,
2111    arg8->R9, arg9->(0,SP)stack(8-byte aligned), arg10->FR0, arg11->stack(16,SP).
2112    I.e. there is hole in the stack.
2113
2114    Different rules apply for variable arguments functions, and for functions
2115    for which the prototype is not known. */
2116
2117 static CORE_ADDR
2118 sh64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
2119                      int struct_return, CORE_ADDR struct_addr)
2120 {
2121   int stack_offset, stack_alloc;
2122   int int_argreg;
2123   int float_argreg;
2124   int double_argreg;
2125   int float_arg_index = 0;
2126   int double_arg_index = 0;
2127   int argnum;
2128   struct type *type;
2129   CORE_ADDR regval;
2130   char *val;
2131   char valbuf[8];
2132   char valbuf_tmp[8];
2133   int len;
2134   int argreg_size;
2135   int fp_args[12];
2136   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2137
2138   memset (fp_args, 0, sizeof (fp_args));
2139
2140   /* first force sp to a 8-byte alignment */
2141   sp = sp & ~7;
2142
2143   /* The "struct return pointer" pseudo-argument has its own dedicated
2144      register */
2145
2146   if (struct_return)
2147     write_register (STRUCT_RETURN_REGNUM, struct_addr);
2148
2149   /* Now make sure there's space on the stack */
2150   for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
2151     stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 7) & ~7);
2152   sp -= stack_alloc;            /* make room on stack for args */
2153
2154   /* Now load as many as possible of the first arguments into
2155      registers, and push the rest onto the stack.  There are 64 bytes
2156      in eight registers available.  Loop thru args from first to last.  */
2157
2158   int_argreg = tdep->ARG0_REGNUM;
2159   float_argreg = FP0_REGNUM;
2160   double_argreg = tdep->DR0_REGNUM;
2161
2162   for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
2163     {
2164       type = VALUE_TYPE (args[argnum]);
2165       len = TYPE_LENGTH (type);
2166       memset (valbuf, 0, sizeof (valbuf));
2167
2168       if (TYPE_CODE (type) != TYPE_CODE_FLT)
2169         {
2170           argreg_size = REGISTER_RAW_SIZE (int_argreg);
2171
2172           if (len < argreg_size)
2173             {
2174               /* value gets right-justified in the register or stack word */
2175               if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2176                 memcpy (valbuf + argreg_size - len,
2177                         (char *) VALUE_CONTENTS (args[argnum]), len);
2178               else
2179                 memcpy (valbuf, (char *) VALUE_CONTENTS (args[argnum]), len);
2180
2181               val = valbuf;
2182             }
2183           else
2184             val = (char *) VALUE_CONTENTS (args[argnum]);
2185
2186           while (len > 0)
2187             {
2188               if (int_argreg > tdep->ARGLAST_REGNUM)
2189                 {
2190                   /* must go on the stack */
2191                   write_memory (sp + stack_offset, val, argreg_size);
2192                   stack_offset += 8;/*argreg_size;*/
2193                 }
2194               /* NOTE WELL!!!!!  This is not an "else if" clause!!!
2195                  That's because some *&^%$ things get passed on the stack
2196                  AND in the registers!   */
2197               if (int_argreg <= tdep->ARGLAST_REGNUM)
2198                 {
2199                   /* there's room in a register */
2200                   regval = extract_address (val, argreg_size);
2201                   write_register (int_argreg, regval);
2202                 }
2203               /* Store the value 8 bytes at a time.  This means that
2204                  things larger than 8 bytes may go partly in registers
2205                  and partly on the stack. FIXME: argreg is incremented
2206                  before we use its size. */
2207               len -= argreg_size;
2208               val += argreg_size;
2209               int_argreg++;
2210             }
2211         }
2212       else
2213         {
2214           val = (char *) VALUE_CONTENTS (args[argnum]);
2215           if (len == 4)
2216             {
2217               /* Where is it going to be stored? */
2218               while (fp_args[float_arg_index])
2219                 float_arg_index ++;
2220
2221               /* Now float_argreg points to the register where it
2222                  should be stored.  Are we still within the allowed
2223                  register set? */
2224               if (float_arg_index <= tdep->FLOAT_ARGLAST_REGNUM)
2225                 {
2226                   /* Goes in FR0...FR11 */
2227                   deprecated_write_register_gen (FP0_REGNUM + float_arg_index,
2228                                                  val);
2229                   fp_args[float_arg_index] = 1;
2230                   /* Skip the corresponding general argument register. */
2231                   int_argreg ++;
2232                 }
2233               else
2234                 ;
2235                 /* Store it as the integers, 8 bytes at the time, if
2236                    necessary spilling on the stack. */
2237
2238             }
2239             else if (len == 8)
2240               {
2241                 /* Where is it going to be stored? */
2242                 while (fp_args[double_arg_index])
2243                   double_arg_index += 2;
2244                 /* Now double_argreg points to the register
2245                    where it should be stored.
2246                    Are we still within the allowed register set? */
2247                 if (double_arg_index < tdep->FLOAT_ARGLAST_REGNUM)
2248                   {
2249                     /* Goes in DR0...DR10 */
2250                     /* The numbering of the DRi registers is consecutive,
2251                        i.e. includes odd numbers. */
2252                     int double_register_offset = double_arg_index / 2;
2253                     int regnum = tdep->DR0_REGNUM +
2254                                  double_register_offset;
2255 #if 0
2256                     if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
2257                       {
2258                         memset (valbuf_tmp, 0, sizeof (valbuf_tmp));
2259                         REGISTER_CONVERT_TO_VIRTUAL (regnum,
2260                                                      type, val, valbuf_tmp);
2261                         val = valbuf_tmp;
2262                       }
2263 #endif
2264                     /* Note: must use write_register_gen here instead
2265                        of regcache_raw_write, because
2266                        regcache_raw_write works only for real
2267                        registers, not pseudo.  write_register_gen will
2268                        call the gdbarch function to do register
2269                        writes, and that will properly know how to deal
2270                        with pseudoregs. */
2271                     deprecated_write_register_gen (regnum, val);
2272                     fp_args[double_arg_index] = 1;
2273                     fp_args[double_arg_index + 1] = 1;
2274                     /* Skip the corresponding general argument register. */
2275                     int_argreg ++;
2276                   }
2277                 else
2278                   ;
2279                   /* Store it as the integers, 8 bytes at the time, if
2280                      necessary spilling on the stack. */
2281               }
2282         }
2283     }
2284   return sp;
2285 }
2286
2287 /* Function: push_return_address (pc)
2288    Set up the return address for the inferior function call.
2289    Needed for targets where we don't actually execute a JSR/BSR instruction */
2290
2291 static CORE_ADDR
2292 sh_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
2293 {
2294   write_register (gdbarch_tdep (current_gdbarch)->PR_REGNUM,
2295                   CALL_DUMMY_ADDRESS ());
2296   return sp;
2297 }
2298
2299 /* Function: fix_call_dummy
2300    Poke the callee function's address into the destination part of
2301    the CALL_DUMMY.  The address is actually stored in a data word
2302    following the actualy CALL_DUMMY instructions, which will load
2303    it into a register using PC-relative addressing.  This function
2304    expects the CALL_DUMMY to look like this:
2305
2306    mov.w @(2,PC), R8
2307    jsr   @R8
2308    nop
2309    trap
2310    <destination>
2311  */
2312
2313 #if 0
2314 void
2315 sh_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
2316                    struct value **args, struct type *type, int gcc_p)
2317 {
2318   *(unsigned long *) (dummy + 8) = fun;
2319 }
2320 #endif
2321
2322 static int
2323 sh_coerce_float_to_double (struct type *formal, struct type *actual)
2324 {
2325   return 1;
2326 }
2327
2328 /* Find a function's return value in the appropriate registers (in
2329    regbuf), and copy it into valbuf.  Extract from an array REGBUF
2330    containing the (raw) register state a function return value of type
2331    TYPE, and copy that, in virtual format, into VALBUF.  */
2332 static void
2333 sh_extract_return_value (struct type *type, char *regbuf, char *valbuf)
2334 {
2335   int len = TYPE_LENGTH (type);
2336   int return_register = R0_REGNUM;
2337   int offset;
2338
2339   if (len <= 4)
2340     {
2341       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2342         offset = REGISTER_BYTE (return_register) + 4 - len;
2343       else
2344         offset = REGISTER_BYTE (return_register);
2345       memcpy (valbuf, regbuf + offset, len);
2346     }
2347   else if (len <= 8)
2348     {
2349       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2350         offset = REGISTER_BYTE (return_register) + 8 - len;
2351       else
2352         offset = REGISTER_BYTE (return_register);
2353       memcpy (valbuf, regbuf + offset, len);
2354     }
2355   else
2356     error ("bad size for return value");
2357 }
2358
2359 static void
2360 sh3e_sh4_extract_return_value (struct type *type, char *regbuf, char *valbuf)
2361 {
2362   int return_register;
2363   int offset;
2364   int len = TYPE_LENGTH (type);
2365
2366   if (TYPE_CODE (type) == TYPE_CODE_FLT)
2367     return_register = FP0_REGNUM;
2368   else
2369     return_register = R0_REGNUM;
2370
2371   if (len == 8 && TYPE_CODE (type) == TYPE_CODE_FLT)
2372     {
2373       DOUBLEST val;
2374       if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
2375         floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
2376                                  (char *) regbuf + REGISTER_BYTE (return_register),
2377                                  &val);
2378       else
2379         floatformat_to_doublest (&floatformat_ieee_double_big,
2380                                  (char *) regbuf + REGISTER_BYTE (return_register),
2381                                  &val);
2382       store_floating (valbuf, len, val);
2383     }
2384   else if (len <= 4)
2385     {
2386       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2387         offset = REGISTER_BYTE (return_register) + 4 - len;
2388       else
2389         offset = REGISTER_BYTE (return_register);
2390       memcpy (valbuf, regbuf + offset, len);
2391     }
2392   else if (len <= 8)
2393     {
2394       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2395         offset = REGISTER_BYTE (return_register) + 8 - len;
2396       else
2397         offset = REGISTER_BYTE (return_register);
2398       memcpy (valbuf, regbuf + offset, len);
2399     }
2400   else
2401     error ("bad size for return value");
2402 }
2403
2404 static void
2405 sh64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
2406 {
2407   int offset;
2408   int return_register;
2409   int len = TYPE_LENGTH (type);
2410   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2411
2412   if (TYPE_CODE (type) == TYPE_CODE_FLT)
2413     {
2414       if (len == 4)
2415         {
2416           /* Return value stored in FP0_REGNUM */
2417           return_register = FP0_REGNUM;
2418           offset = REGISTER_BYTE (return_register);
2419           memcpy (valbuf, (char *) regbuf + offset, len);
2420         }
2421       else if (len == 8)
2422         {
2423           /* return value stored in DR0_REGNUM */
2424           DOUBLEST val;
2425
2426           return_register = tdep->DR0_REGNUM;
2427           offset = REGISTER_BYTE (return_register);
2428
2429           if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
2430             floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
2431                                      (char *) regbuf + offset, &val);
2432           else
2433             floatformat_to_doublest (&floatformat_ieee_double_big,
2434                                      (char *) regbuf + offset, &val);
2435           store_floating (valbuf, len, val);
2436         }
2437     }
2438   else
2439     {
2440       if (len <= 8)
2441         {
2442           /* Result is in register 2. If smaller than 8 bytes, it is padded
2443              at the most significant end. */
2444           return_register = tdep->RETURN_REGNUM;
2445           if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2446             offset = REGISTER_BYTE (return_register) +
2447               REGISTER_RAW_SIZE (return_register) - len;
2448           else
2449             offset = REGISTER_BYTE (return_register);
2450           memcpy (valbuf, (char *) regbuf + offset, len);
2451         }
2452       else
2453         error ("bad size for return value");
2454     }
2455 }
2456
2457 /* Write into appropriate registers a function return value
2458    of type TYPE, given in virtual format.
2459    If the architecture is sh4 or sh3e, store a function's return value
2460    in the R0 general register or in the FP0 floating point register,
2461    depending on the type of the return value. In all the other cases
2462    the result is stored in r0, left-justified. */
2463 static void
2464 sh_default_store_return_value (struct type *type, char *valbuf)
2465 {
2466   char buf[32]; /* more than enough... */
2467
2468   if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (R0_REGNUM))
2469     {
2470       /* Add leading zeros to the value. */
2471       memset (buf, 0, REGISTER_RAW_SIZE (R0_REGNUM));
2472       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2473         memcpy (buf + REGISTER_RAW_SIZE (R0_REGNUM) - TYPE_LENGTH (type),
2474                 valbuf, TYPE_LENGTH (type));
2475       else
2476         memcpy (buf, valbuf, TYPE_LENGTH (type));
2477       deprecated_write_register_bytes (REGISTER_BYTE (R0_REGNUM), buf,
2478                                        REGISTER_RAW_SIZE (R0_REGNUM));
2479     }
2480   else
2481     deprecated_write_register_bytes (REGISTER_BYTE (R0_REGNUM), valbuf,
2482                                      TYPE_LENGTH (type));
2483 }
2484
2485 static void
2486 sh3e_sh4_store_return_value (struct type *type, char *valbuf)
2487 {
2488   if (TYPE_CODE (type) == TYPE_CODE_FLT)
2489     deprecated_write_register_bytes (REGISTER_BYTE (FP0_REGNUM),
2490                                      valbuf, TYPE_LENGTH (type));
2491   else
2492     sh_default_store_return_value (type, valbuf);
2493 }
2494
2495 static void
2496 sh64_store_return_value (struct type *type, char *valbuf)
2497 {
2498   char buf[64]; /* more than enough... */
2499   int len = TYPE_LENGTH (type);
2500
2501   if (TYPE_CODE (type) == TYPE_CODE_FLT)
2502     {
2503       if (len == 4)
2504         {
2505           /* Return value stored in FP0_REGNUM */
2506           deprecated_write_register_gen (FP0_REGNUM, valbuf);
2507         }
2508       if (len == 8)
2509         {
2510           /* return value stored in DR0_REGNUM */
2511           /* FIXME: Implement */
2512         }
2513     }
2514   else
2515     {
2516       int return_register = gdbarch_tdep (current_gdbarch)->RETURN_REGNUM;
2517       int offset = 0;
2518
2519       if (len <= REGISTER_RAW_SIZE (return_register))
2520         {
2521           /* Pad with zeros. */
2522           memset (buf, 0, REGISTER_RAW_SIZE (return_register));
2523           if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
2524             offset = 0; /*REGISTER_RAW_SIZE (return_register) - len;*/
2525           else
2526             offset = REGISTER_RAW_SIZE (return_register) - len;
2527
2528           memcpy (buf + offset, valbuf, len);
2529           deprecated_write_register_gen (return_register, buf);
2530         }
2531       else
2532         deprecated_write_register_gen (return_register, valbuf);
2533     }
2534 }
2535
2536 /* Print the registers in a form similar to the E7000 */
2537
2538 static void
2539 sh_generic_show_regs (void)
2540 {
2541   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2542
2543   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
2544                    paddr (read_register (PC_REGNUM)),
2545                    (long) read_register (tdep->SR_REGNUM),
2546                    (long) read_register (tdep->PR_REGNUM),
2547                    (long) read_register (MACH_REGNUM),
2548                    (long) read_register (MACL_REGNUM));
2549
2550   printf_filtered ("GBR=%08lx VBR=%08lx",
2551                    (long) read_register (GBR_REGNUM),
2552                    (long) read_register (VBR_REGNUM));
2553
2554   printf_filtered ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2555                    (long) read_register (0),
2556                    (long) read_register (1),
2557                    (long) read_register (2),
2558                    (long) read_register (3),
2559                    (long) read_register (4),
2560                    (long) read_register (5),
2561                    (long) read_register (6),
2562                    (long) read_register (7));
2563   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2564                    (long) read_register (8),
2565                    (long) read_register (9),
2566                    (long) read_register (10),
2567                    (long) read_register (11),
2568                    (long) read_register (12),
2569                    (long) read_register (13),
2570                    (long) read_register (14),
2571                    (long) read_register (15));
2572 }
2573
2574 static void
2575 sh3_show_regs (void)
2576 {
2577   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2578
2579   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
2580                    paddr (read_register (PC_REGNUM)),
2581                    (long) read_register (tdep->SR_REGNUM),
2582                    (long) read_register (tdep->PR_REGNUM),
2583                    (long) read_register (MACH_REGNUM),
2584                    (long) read_register (MACL_REGNUM));
2585
2586   printf_filtered ("GBR=%08lx VBR=%08lx",
2587                    (long) read_register (GBR_REGNUM),
2588                    (long) read_register (VBR_REGNUM));
2589   printf_filtered (" SSR=%08lx SPC=%08lx",
2590                    (long) read_register (tdep->SSR_REGNUM),
2591                    (long) read_register (tdep->SPC_REGNUM));
2592
2593   printf_filtered ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2594                    (long) read_register (0),
2595                    (long) read_register (1),
2596                    (long) read_register (2),
2597                    (long) read_register (3),
2598                    (long) read_register (4),
2599                    (long) read_register (5),
2600                    (long) read_register (6),
2601                    (long) read_register (7));
2602   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2603                    (long) read_register (8),
2604                    (long) read_register (9),
2605                    (long) read_register (10),
2606                    (long) read_register (11),
2607                    (long) read_register (12),
2608                    (long) read_register (13),
2609                    (long) read_register (14),
2610                    (long) read_register (15));
2611 }
2612
2613
2614 static void
2615 sh3e_show_regs (void)
2616 {
2617   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2618
2619   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
2620                    paddr (read_register (PC_REGNUM)),
2621                    (long) read_register (tdep->SR_REGNUM),
2622                    (long) read_register (tdep->PR_REGNUM),
2623                    (long) read_register (MACH_REGNUM),
2624                    (long) read_register (MACL_REGNUM));
2625
2626   printf_filtered ("GBR=%08lx VBR=%08lx",
2627                    (long) read_register (GBR_REGNUM),
2628                    (long) read_register (VBR_REGNUM));
2629   printf_filtered (" SSR=%08lx SPC=%08lx",
2630                    (long) read_register (tdep->SSR_REGNUM),
2631                    (long) read_register (tdep->SPC_REGNUM));
2632   printf_filtered (" FPUL=%08lx FPSCR=%08lx",
2633                    (long) read_register (tdep->FPUL_REGNUM),
2634                    (long) read_register (tdep->FPSCR_REGNUM));
2635
2636   printf_filtered ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2637                    (long) read_register (0),
2638                    (long) read_register (1),
2639                    (long) read_register (2),
2640                    (long) read_register (3),
2641                    (long) read_register (4),
2642                    (long) read_register (5),
2643                    (long) read_register (6),
2644                    (long) read_register (7));
2645   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2646                    (long) read_register (8),
2647                    (long) read_register (9),
2648                    (long) read_register (10),
2649                    (long) read_register (11),
2650                    (long) read_register (12),
2651                    (long) read_register (13),
2652                    (long) read_register (14),
2653                    (long) read_register (15));
2654
2655   printf_filtered (("FP0-FP7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
2656                    (long) read_register (FP0_REGNUM + 0),
2657                    (long) read_register (FP0_REGNUM + 1),
2658                    (long) read_register (FP0_REGNUM + 2),
2659                    (long) read_register (FP0_REGNUM + 3),
2660                    (long) read_register (FP0_REGNUM + 4),
2661                    (long) read_register (FP0_REGNUM + 5),
2662                    (long) read_register (FP0_REGNUM + 6),
2663                    (long) read_register (FP0_REGNUM + 7));
2664   printf_filtered (("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
2665                    (long) read_register (FP0_REGNUM + 8),
2666                    (long) read_register (FP0_REGNUM + 9),
2667                    (long) read_register (FP0_REGNUM + 10),
2668                    (long) read_register (FP0_REGNUM + 11),
2669                    (long) read_register (FP0_REGNUM + 12),
2670                    (long) read_register (FP0_REGNUM + 13),
2671                    (long) read_register (FP0_REGNUM + 14),
2672                    (long) read_register (FP0_REGNUM + 15));
2673 }
2674
2675 static void
2676 sh3_dsp_show_regs (void)
2677 {
2678   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2679
2680   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
2681                    paddr (read_register (PC_REGNUM)),
2682                    (long) read_register (tdep->SR_REGNUM),
2683                    (long) read_register (tdep->PR_REGNUM),
2684                    (long) read_register (MACH_REGNUM),
2685                    (long) read_register (MACL_REGNUM));
2686
2687   printf_filtered ("GBR=%08lx VBR=%08lx",
2688                    (long) read_register (GBR_REGNUM),
2689                    (long) read_register (VBR_REGNUM));
2690
2691   printf_filtered (" SSR=%08lx SPC=%08lx",
2692                    (long) read_register (tdep->SSR_REGNUM),
2693                    (long) read_register (tdep->SPC_REGNUM));
2694
2695   printf_filtered (" DSR=%08lx",
2696                    (long) read_register (tdep->DSR_REGNUM));
2697
2698   printf_filtered ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2699                    (long) read_register (0),
2700                    (long) read_register (1),
2701                    (long) read_register (2),
2702                    (long) read_register (3),
2703                    (long) read_register (4),
2704                    (long) read_register (5),
2705                    (long) read_register (6),
2706                    (long) read_register (7));
2707   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2708                    (long) read_register (8),
2709                    (long) read_register (9),
2710                    (long) read_register (10),
2711                    (long) read_register (11),
2712                    (long) read_register (12),
2713                    (long) read_register (13),
2714                    (long) read_register (14),
2715                    (long) read_register (15));
2716
2717   printf_filtered ("A0G=%02lx A0=%08lx M0=%08lx X0=%08lx Y0=%08lx RS=%08lx MOD=%08lx\n",
2718                    (long) read_register (tdep->A0G_REGNUM) & 0xff,
2719                    (long) read_register (tdep->A0_REGNUM),
2720                    (long) read_register (tdep->M0_REGNUM),
2721                    (long) read_register (tdep->X0_REGNUM),
2722                    (long) read_register (tdep->Y0_REGNUM),
2723                    (long) read_register (tdep->RS_REGNUM),
2724                    (long) read_register (tdep->MOD_REGNUM));
2725   printf_filtered ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
2726                    (long) read_register (tdep->A1G_REGNUM) & 0xff,
2727                    (long) read_register (tdep->A1_REGNUM),
2728                    (long) read_register (tdep->M1_REGNUM),
2729                    (long) read_register (tdep->X1_REGNUM),
2730                    (long) read_register (tdep->Y1_REGNUM),
2731                    (long) read_register (tdep->RE_REGNUM));
2732 }
2733
2734 static void
2735 sh4_show_regs (void)
2736 {
2737   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2738
2739   int pr = read_register (tdep->FPSCR_REGNUM) & 0x80000;
2740   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
2741                    paddr (read_register (PC_REGNUM)),
2742                    (long) read_register (tdep->SR_REGNUM),
2743                    (long) read_register (tdep->PR_REGNUM),
2744                    (long) read_register (MACH_REGNUM),
2745                    (long) read_register (MACL_REGNUM));
2746
2747   printf_filtered ("GBR=%08lx VBR=%08lx",
2748                    (long) read_register (GBR_REGNUM),
2749                    (long) read_register (VBR_REGNUM));
2750   printf_filtered (" SSR=%08lx SPC=%08lx",
2751                    (long) read_register (tdep->SSR_REGNUM),
2752                    (long) read_register (tdep->SPC_REGNUM));
2753   printf_filtered (" FPUL=%08lx FPSCR=%08lx",
2754                    (long) read_register (tdep->FPUL_REGNUM),
2755                    (long) read_register (tdep->FPSCR_REGNUM));
2756
2757   printf_filtered ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2758                    (long) read_register (0),
2759                    (long) read_register (1),
2760                    (long) read_register (2),
2761                    (long) read_register (3),
2762                    (long) read_register (4),
2763                    (long) read_register (5),
2764                    (long) read_register (6),
2765                    (long) read_register (7));
2766   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2767                    (long) read_register (8),
2768                    (long) read_register (9),
2769                    (long) read_register (10),
2770                    (long) read_register (11),
2771                    (long) read_register (12),
2772                    (long) read_register (13),
2773                    (long) read_register (14),
2774                    (long) read_register (15));
2775
2776   printf_filtered ((pr
2777                     ? "DR0-DR6  %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
2778                     : "FP0-FP7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
2779                    (long) read_register (FP0_REGNUM + 0),
2780                    (long) read_register (FP0_REGNUM + 1),
2781                    (long) read_register (FP0_REGNUM + 2),
2782                    (long) read_register (FP0_REGNUM + 3),
2783                    (long) read_register (FP0_REGNUM + 4),
2784                    (long) read_register (FP0_REGNUM + 5),
2785                    (long) read_register (FP0_REGNUM + 6),
2786                    (long) read_register (FP0_REGNUM + 7));
2787   printf_filtered ((pr
2788                     ? "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
2789                     : "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
2790                    (long) read_register (FP0_REGNUM + 8),
2791                    (long) read_register (FP0_REGNUM + 9),
2792                    (long) read_register (FP0_REGNUM + 10),
2793                    (long) read_register (FP0_REGNUM + 11),
2794                    (long) read_register (FP0_REGNUM + 12),
2795                    (long) read_register (FP0_REGNUM + 13),
2796                    (long) read_register (FP0_REGNUM + 14),
2797                    (long) read_register (FP0_REGNUM + 15));
2798 }
2799
2800 static void
2801 sh_dsp_show_regs (void)
2802 {
2803   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2804
2805   printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
2806                    paddr (read_register (PC_REGNUM)),
2807                    (long) read_register (tdep->SR_REGNUM),
2808                    (long) read_register (tdep->PR_REGNUM),
2809                    (long) read_register (MACH_REGNUM),
2810                    (long) read_register (MACL_REGNUM));
2811
2812   printf_filtered ("GBR=%08lx VBR=%08lx",
2813                    (long) read_register (GBR_REGNUM),
2814                    (long) read_register (VBR_REGNUM));
2815
2816   printf_filtered (" DSR=%08lx",
2817                    (long) read_register (tdep->DSR_REGNUM));
2818
2819   printf_filtered ("\nR0-R7  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2820                    (long) read_register (0),
2821                    (long) read_register (1),
2822                    (long) read_register (2),
2823                    (long) read_register (3),
2824                    (long) read_register (4),
2825                    (long) read_register (5),
2826                    (long) read_register (6),
2827                    (long) read_register (7));
2828   printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2829                    (long) read_register (8),
2830                    (long) read_register (9),
2831                    (long) read_register (10),
2832                    (long) read_register (11),
2833                    (long) read_register (12),
2834                    (long) read_register (13),
2835                    (long) read_register (14),
2836                    (long) read_register (15));
2837
2838   printf_filtered ("A0G=%02lx A0=%08lx M0=%08lx X0=%08lx Y0=%08lx RS=%08lx MOD=%08lx\n",
2839                    (long) read_register (tdep->A0G_REGNUM) & 0xff,
2840                    (long) read_register (tdep->A0_REGNUM),
2841                    (long) read_register (tdep->M0_REGNUM),
2842                    (long) read_register (tdep->X0_REGNUM),
2843                    (long) read_register (tdep->Y0_REGNUM),
2844                    (long) read_register (tdep->RS_REGNUM),
2845                    (long) read_register (tdep->MOD_REGNUM));
2846   printf_filtered ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
2847                    (long) read_register (tdep->A1G_REGNUM) & 0xff,
2848                    (long) read_register (tdep->A1_REGNUM),
2849                    (long) read_register (tdep->M1_REGNUM),
2850                    (long) read_register (tdep->X1_REGNUM),
2851                    (long) read_register (tdep->Y1_REGNUM),
2852                    (long) read_register (tdep->RE_REGNUM));
2853 }
2854
2855 static void
2856 sh64_show_media_regs (void)
2857 {
2858   int i;
2859   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2860
2861   printf_filtered ("PC=%s SR=%016llx \n",
2862                    paddr (read_register (PC_REGNUM)),
2863                    (long long) read_register (tdep->SR_REGNUM));
2864
2865   printf_filtered ("SSR=%016llx SPC=%016llx \n",
2866                    (long long) read_register (tdep->SSR_REGNUM),
2867                    (long long) read_register (tdep->SPC_REGNUM));
2868   printf_filtered ("FPSCR=%016lx\n ",
2869                    (long) read_register (tdep->FPSCR_REGNUM));
2870
2871   for (i = 0; i < 64; i = i + 4)
2872     printf_filtered ("\nR%d-R%d  %016llx %016llx %016llx %016llx\n",
2873                      i, i + 3,
2874                      (long long) read_register (i + 0),
2875                      (long long) read_register (i + 1),
2876                      (long long) read_register (i + 2),
2877                      (long long) read_register (i + 3));
2878
2879   printf_filtered ("\n");
2880
2881   for (i = 0; i < 64; i = i + 8)
2882     printf_filtered ("FR%d-FR%d  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2883                      i, i + 7,
2884                      (long) read_register (FP0_REGNUM + i + 0),
2885                      (long) read_register (FP0_REGNUM + i + 1),
2886                      (long) read_register (FP0_REGNUM + i + 2),
2887                      (long) read_register (FP0_REGNUM + i + 3),
2888                      (long) read_register (FP0_REGNUM + i + 4),
2889                      (long) read_register (FP0_REGNUM + i + 5),
2890                      (long) read_register (FP0_REGNUM + i + 6),
2891                      (long) read_register (FP0_REGNUM + i + 7));
2892 }
2893
2894 static void
2895 sh64_show_compact_regs (void)
2896 {
2897   int i;
2898   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2899
2900   printf_filtered ("PC=%s \n",
2901                    paddr (read_register (tdep->PC_C_REGNUM)));
2902
2903   printf_filtered ("GBR=%08lx MACH=%08lx MACL=%08lx PR=%08lx T=%08lx\n",
2904                    (long) read_register (tdep->GBR_C_REGNUM),
2905                    (long) read_register (tdep->MACH_C_REGNUM),
2906                    (long) read_register (tdep->MACL_C_REGNUM),
2907                    (long) read_register (tdep->PR_C_REGNUM),
2908                    (long) read_register (tdep->T_C_REGNUM));
2909   printf_filtered ("FPSCR=%08lx FPUL=%08lx\n",
2910                    (long) read_register (tdep->FPSCR_REGNUM),
2911                    (long) read_register (tdep->FPUL_REGNUM));
2912
2913   for (i = 0; i < 16; i = i + 4)
2914     printf_filtered ("\nR%d-R%d  %08lx %08lx %08lx %08lx\n",
2915                      i, i + 3,
2916                      (long) read_register (i + 0),
2917                      (long) read_register (i + 1),
2918                      (long) read_register (i + 2),
2919                      (long) read_register (i + 3));
2920
2921   printf_filtered ("\n");
2922
2923   for (i = 0; i < 16; i = i + 8)
2924     printf_filtered ("FR%d-FR%d  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
2925                      i, i + 7,
2926                      (long) read_register (FP0_REGNUM + i + 0),
2927                      (long) read_register (FP0_REGNUM + i + 1),
2928                      (long) read_register (FP0_REGNUM + i + 2),
2929                      (long) read_register (FP0_REGNUM + i + 3),
2930                      (long) read_register (FP0_REGNUM + i + 4),
2931                      (long) read_register (FP0_REGNUM + i + 5),
2932                      (long) read_register (FP0_REGNUM + i + 6),
2933                      (long) read_register (FP0_REGNUM + i + 7));
2934 }
2935
2936 /*FIXME!!! This only shows the registers for shmedia, excluding the
2937   pseudo registers. */
2938 static void
2939 sh64_show_regs (void)
2940 {
2941   if (pc_is_isa32 (get_frame_pc (deprecated_selected_frame)))
2942     sh64_show_media_regs ();
2943   else
2944     sh64_show_compact_regs ();
2945 }
2946
2947 void sh_show_regs_command (char *args, int from_tty)
2948 {
2949   if (sh_show_regs)
2950     (*sh_show_regs)();
2951 }
2952
2953 /* Index within `registers' of the first byte of the space for
2954    register N.  */
2955 static int
2956 sh_default_register_byte (int reg_nr)
2957 {
2958   return (reg_nr * 4);
2959 }
2960
2961 static int
2962 sh_sh4_register_byte (int reg_nr)
2963 {
2964   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2965
2966   if (reg_nr >= tdep->DR0_REGNUM
2967       && reg_nr <= tdep->DR_LAST_REGNUM)
2968     return (dr_reg_base_num (reg_nr) * 4);
2969   else if  (reg_nr >= tdep->FV0_REGNUM
2970             && reg_nr <= tdep->FV_LAST_REGNUM)
2971     return (fv_reg_base_num (reg_nr) * 4);
2972   else
2973     return (reg_nr * 4);
2974 }
2975
2976 /* *INDENT-OFF* */
2977 /*
2978     SH MEDIA MODE (ISA 32)
2979     general registers (64-bit) 0-63
2980 0    r0,   r1,   r2,   r3,   r4,   r5,   r6,   r7,
2981 64   r8,   r9,   r10,  r11,  r12,  r13,  r14,  r15,
2982 128  r16,  r17,  r18,  r19,  r20,  r21,  r22,  r23,
2983 192  r24,  r25,  r26,  r27,  r28,  r29,  r30,  r31,
2984 256  r32,  r33,  r34,  r35,  r36,  r37,  r38,  r39,
2985 320  r40,  r41,  r42,  r43,  r44,  r45,  r46,  r47,
2986 384  r48,  r49,  r50,  r51,  r52,  r53,  r54,  r55,
2987 448  r56,  r57,  r58,  r59,  r60,  r61,  r62,  r63,
2988
2989     pc (64-bit) 64
2990 512  pc,
2991
2992     status reg., saved status reg., saved pc reg. (64-bit) 65-67
2993 520  sr,  ssr,  spc,
2994
2995     target registers (64-bit) 68-75
2996 544  tr0,  tr1,  tr2,  tr3,  tr4,  tr5,  tr6,  tr7,
2997
2998     floating point state control register (32-bit) 76
2999 608  fpscr,
3000
3001     single precision floating point registers (32-bit) 77-140
3002 612  fr0,  fr1,  fr2,  fr3,  fr4,  fr5,  fr6,  fr7,
3003 644  fr8,  fr9,  fr10, fr11, fr12, fr13, fr14, fr15,
3004 676  fr16, fr17, fr18, fr19, fr20, fr21, fr22, fr23,
3005 708  fr24, fr25, fr26, fr27, fr28, fr29, fr30, fr31,
3006 740  fr32, fr33, fr34, fr35, fr36, fr37, fr38, fr39,
3007 772  fr40, fr41, fr42, fr43, fr44, fr45, fr46, fr47,
3008 804  fr48, fr49, fr50, fr51, fr52, fr53, fr54, fr55,
3009 836  fr56, fr57, fr58, fr59, fr60, fr61, fr62, fr63,
3010
3011 TOTAL SPACE FOR REGISTERS: 868 bytes
3012
3013 From here on they are all pseudo registers: no memory allocated.
3014 REGISTER_BYTE returns the register byte for the base register.
3015
3016     double precision registers (pseudo) 141-172
3017      dr0,  dr2,  dr4,  dr6,  dr8,  dr10, dr12, dr14,
3018      dr16, dr18, dr20, dr22, dr24, dr26, dr28, dr30,
3019      dr32, dr34, dr36, dr38, dr40, dr42, dr44, dr46,
3020      dr48, dr50, dr52, dr54, dr56, dr58, dr60, dr62,
3021
3022     floating point pairs (pseudo) 173-204
3023      fp0,  fp2,  fp4,  fp6,  fp8,  fp10, fp12, fp14,
3024      fp16, fp18, fp20, fp22, fp24, fp26, fp28, fp30,
3025      fp32, fp34, fp36, fp38, fp40, fp42, fp44, fp46,
3026      fp48, fp50, fp52, fp54, fp56, fp58, fp60, fp62,
3027
3028     floating point vectors (4 floating point regs) (pseudo) 205-220
3029      fv0,  fv4,  fv8,  fv12, fv16, fv20, fv24, fv28,
3030      fv32, fv36, fv40, fv44, fv48, fv52, fv56, fv60,
3031
3032     SH COMPACT MODE (ISA 16) (all pseudo) 221-272
3033      r0_c, r1_c, r2_c,  r3_c,  r4_c,  r5_c,  r6_c,  r7_c,
3034      r8_c, r9_c, r10_c, r11_c, r12_c, r13_c, r14_c, r15_c,
3035      pc_c,
3036      gbr_c, mach_c, macl_c, pr_c, t_c,
3037      fpscr_c, fpul_c,
3038      fr0_c, fr1_c, fr2_c,  fr3_c,  fr4_c,  fr5_c,  fr6_c,  fr7_c,
3039      fr8_c, fr9_c, fr10_c, fr11_c, fr12_c, fr13_c, fr14_c, fr15_c
3040      dr0_c, dr2_c, dr4_c,  dr6_c,  dr8_c,  dr10_c, dr12_c, dr14_c
3041      fv0_c, fv4_c, fv8_c,  fv12_c
3042 */
3043 /* *INDENT-ON* */
3044 static int
3045 sh_sh64_register_byte (int reg_nr)
3046 {
3047   int base_regnum = -1;
3048   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3049
3050   /* If it is a pseudo register, get the number of the first floating
3051      point register that is part of it. */
3052   if (reg_nr >= tdep->DR0_REGNUM
3053       && reg_nr <= tdep->DR_LAST_REGNUM)
3054     base_regnum = dr_reg_base_num (reg_nr);
3055
3056   else if (reg_nr >= tdep->FPP0_REGNUM
3057             && reg_nr <= tdep->FPP_LAST_REGNUM)
3058     base_regnum = fpp_reg_base_num (reg_nr);
3059
3060   else if (reg_nr >= tdep->FV0_REGNUM
3061             && reg_nr <= tdep->FV_LAST_REGNUM)
3062     base_regnum = fv_reg_base_num (reg_nr);
3063
3064   /* sh compact pseudo register. FPSCR is a pathological case, need to
3065      treat it as special. */
3066   else if ((reg_nr >= tdep->R0_C_REGNUM
3067             && reg_nr <= tdep->FV_LAST_C_REGNUM)
3068            && reg_nr != tdep->FPSCR_C_REGNUM)
3069     base_regnum = sh64_compact_reg_base_num (reg_nr);
3070
3071   /* Now return the offset in bytes within the register cache. */
3072   /* sh media pseudo register, i.e. any of DR, FFP, FV registers. */
3073   if (reg_nr >= tdep->DR0_REGNUM
3074       && reg_nr <= tdep->FV_LAST_REGNUM)
3075     return (base_regnum - FP0_REGNUM + 1) * 4
3076       + (tdep->TR7_REGNUM + 1) * 8;
3077
3078   /* sh compact pseudo register: general register */
3079   if ((reg_nr >= tdep->R0_C_REGNUM
3080        && reg_nr <= tdep->R_LAST_C_REGNUM))
3081     return (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
3082             ? base_regnum * 8 + 4
3083             : base_regnum * 8);
3084
3085   /* sh compact pseudo register: */
3086   if (reg_nr == tdep->PC_C_REGNUM
3087        || reg_nr == tdep->GBR_C_REGNUM
3088        || reg_nr == tdep->MACL_C_REGNUM
3089        || reg_nr == tdep->PR_C_REGNUM)
3090     return (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
3091             ? base_regnum * 8 + 4
3092             : base_regnum * 8);
3093
3094   if (reg_nr == tdep->MACH_C_REGNUM)
3095     return base_regnum * 8;
3096
3097   if (reg_nr == tdep->T_C_REGNUM)
3098     return base_regnum * 8; /* FIXME??? how do we get bit 0? Do we have to? */
3099
3100   /* sh compact pseudo register: floating point register */
3101   else if (reg_nr >=tdep->FP0_C_REGNUM
3102            && reg_nr <= tdep->FV_LAST_C_REGNUM)
3103     return (base_regnum  - FP0_REGNUM) * 4
3104       + (tdep->TR7_REGNUM + 1) * 8 + 4;
3105
3106   else if (reg_nr == tdep->FPSCR_C_REGNUM)
3107     /* This is complicated, for now return the beginning of the
3108        architectural FPSCR register. */
3109     return (tdep->TR7_REGNUM + 1) * 8;
3110
3111   else if (reg_nr == tdep->FPUL_C_REGNUM)
3112     return ((base_regnum - FP0_REGNUM) * 4 +
3113             (tdep->TR7_REGNUM + 1) * 8 + 4);
3114
3115   /* It is not a pseudo register. */
3116   /* It is a 64 bit register. */
3117   else if (reg_nr <= tdep->TR7_REGNUM)
3118     return reg_nr * 8;
3119
3120   /* It is a 32 bit register. */
3121   else
3122     if (reg_nr == tdep->FPSCR_REGNUM)
3123       return (tdep->FPSCR_REGNUM * 8);
3124
3125   /* It is floating point 32-bit register */
3126   else
3127     return ((tdep->TR7_REGNUM + 1) * 8
3128       + (reg_nr - FP0_REGNUM + 1) * 4);
3129 }
3130
3131 /* Number of bytes of storage in the actual machine representation for
3132    register REG_NR.  */
3133 static int
3134 sh_default_register_raw_size (int reg_nr)
3135 {
3136   return 4;
3137 }
3138
3139 static int
3140 sh_sh4_register_raw_size (int reg_nr)
3141 {
3142   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3143
3144   if (reg_nr >= tdep->DR0_REGNUM
3145       && reg_nr <= tdep->DR_LAST_REGNUM)
3146     return 8;
3147   else if  (reg_nr >= tdep->FV0_REGNUM
3148             && reg_nr <= tdep->FV_LAST_REGNUM)
3149     return 16;
3150   else
3151     return 4;
3152 }
3153
3154 static int
3155 sh_sh64_register_raw_size (int reg_nr)
3156 {
3157   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3158
3159   if ((reg_nr >= tdep->DR0_REGNUM
3160        && reg_nr <= tdep->DR_LAST_REGNUM)
3161       || (reg_nr >= tdep->FPP0_REGNUM
3162           && reg_nr <= tdep->FPP_LAST_REGNUM)
3163       || (reg_nr >= tdep->DR0_C_REGNUM
3164           && reg_nr <= tdep->DR_LAST_C_REGNUM)
3165       || (reg_nr <= tdep->TR7_REGNUM))
3166     return 8;
3167
3168   else if ((reg_nr >= tdep->FV0_REGNUM
3169             && reg_nr <= tdep->FV_LAST_REGNUM)
3170            || (reg_nr >= tdep->FV0_C_REGNUM
3171                && reg_nr <= tdep->FV_LAST_C_REGNUM))
3172     return 16;
3173
3174   else /* this covers also the 32-bit SH compact registers. */
3175     return 4;
3176 }
3177
3178 /* Number of bytes of storage in the program's representation
3179    for register N.  */
3180 static int
3181 sh_register_virtual_size (int reg_nr)
3182 {
3183   return 4;
3184 }
3185
3186 /* ??????? FIXME */
3187 static int
3188 sh_sh64_register_virtual_size (int reg_nr)
3189 {
3190   if (reg_nr >= FP0_REGNUM
3191       && reg_nr <= gdbarch_tdep (current_gdbarch)->FP_LAST_REGNUM)
3192     return 4;
3193   else
3194     return 8;
3195 }
3196
3197 /* Return the GDB type object for the "standard" data type
3198    of data in register N.  */
3199 static struct type *
3200 sh_sh3e_register_virtual_type (int reg_nr)
3201 {
3202   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3203
3204   if ((reg_nr >= FP0_REGNUM
3205        && (reg_nr <= tdep->FP_LAST_REGNUM))
3206       || (reg_nr == tdep->FPUL_REGNUM))
3207     return builtin_type_float;
3208   else
3209     return builtin_type_int;
3210 }
3211
3212 static struct type *
3213 sh_sh4_build_float_register_type (int high)
3214 {
3215   struct type *temp;
3216
3217   temp = create_range_type (NULL, builtin_type_int, 0, high);
3218   return create_array_type (NULL, builtin_type_float, temp);
3219 }
3220
3221 static struct type *
3222 sh_sh4_register_virtual_type (int reg_nr)
3223 {
3224   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3225
3226   if ((reg_nr >= FP0_REGNUM
3227        && (reg_nr <= tdep->FP_LAST_REGNUM))
3228       || (reg_nr == tdep->FPUL_REGNUM))
3229     return builtin_type_float;
3230   else if (reg_nr >= tdep->DR0_REGNUM
3231            && reg_nr <= tdep->DR_LAST_REGNUM)
3232     return builtin_type_double;
3233   else if  (reg_nr >= tdep->FV0_REGNUM
3234            && reg_nr <= tdep->FV_LAST_REGNUM)
3235     return sh_sh4_build_float_register_type (3);
3236   else
3237     return builtin_type_int;
3238 }
3239
3240 static struct type *
3241 sh_sh64_register_virtual_type (int reg_nr)
3242 {
3243   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3244
3245   if ((reg_nr >= FP0_REGNUM
3246        && reg_nr <= tdep->FP_LAST_REGNUM)
3247       || (reg_nr >= tdep->FP0_C_REGNUM
3248           && reg_nr <= tdep->FP_LAST_C_REGNUM))
3249     return builtin_type_float;
3250   else if ((reg_nr >= tdep->DR0_REGNUM
3251             && reg_nr <= tdep->DR_LAST_REGNUM)
3252            || (reg_nr >= tdep->DR0_C_REGNUM
3253                && reg_nr <= tdep->DR_LAST_C_REGNUM))
3254     return builtin_type_double;
3255   else if  (reg_nr >= tdep->FPP0_REGNUM
3256             && reg_nr <= tdep->FPP_LAST_REGNUM)
3257     return sh_sh4_build_float_register_type (1);
3258   else if ((reg_nr >= tdep->FV0_REGNUM
3259             && reg_nr <= tdep->FV_LAST_REGNUM)
3260            ||(reg_nr >= tdep->FV0_C_REGNUM
3261               && reg_nr <= tdep->FV_LAST_C_REGNUM))
3262     return sh_sh4_build_float_register_type (3);
3263   else if (reg_nr == tdep->FPSCR_REGNUM)
3264     return builtin_type_int;
3265   else if (reg_nr >= tdep->R0_C_REGNUM
3266            && reg_nr < tdep->FP0_C_REGNUM)
3267     return builtin_type_int;
3268   else
3269     return builtin_type_long_long;
3270 }
3271
3272 static struct type *
3273 sh_default_register_virtual_type (int reg_nr)
3274 {
3275   return builtin_type_int;
3276 }
3277
3278 /* On the sh4, the DRi pseudo registers are problematic if the target
3279    is little endian. When the user writes one of those registers, for
3280    instance with 'ser var $dr0=1', we want the double to be stored
3281    like this:
3282    fr0 = 0x00 0x00 0x00 0x00 0x00 0xf0 0x3f
3283    fr1 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
3284
3285    This corresponds to little endian byte order & big endian word
3286    order.  However if we let gdb write the register w/o conversion, it
3287    will write fr0 and fr1 this way:
3288    fr0 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
3289    fr1 = 0x00 0x00 0x00 0x00 0x00 0xf0 0x3f
3290    because it will consider fr0 and fr1 as a single LE stretch of memory.
3291
3292    To achieve what we want we must force gdb to store things in
3293    floatformat_ieee_double_littlebyte_bigword (which is defined in
3294    include/floatformat.h and libiberty/floatformat.c.
3295
3296    In case the target is big endian, there is no problem, the
3297    raw bytes will look like:
3298    fr0 = 0x3f 0xf0 0x00 0x00 0x00 0x00 0x00
3299    fr1 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
3300
3301    The other pseudo registers (the FVs) also don't pose a problem
3302    because they are stored as 4 individual FP elements. */
3303
3304 static void
3305 sh_sh4_register_convert_to_virtual (int regnum, struct type *type,
3306                                   char *from, char *to)
3307 {
3308   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3309
3310   if (regnum >= tdep->DR0_REGNUM
3311       && regnum <= tdep->DR_LAST_REGNUM)
3312     {
3313       DOUBLEST val;
3314       floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword, from, &val);
3315       store_floating (to, TYPE_LENGTH (type), val);
3316     }
3317   else
3318     error ("sh_register_convert_to_virtual called with non DR register number");
3319 }
3320
3321 void
3322 sh_sh64_register_convert_to_virtual (int regnum, struct type *type,
3323                                      char *from, char *to)
3324 {
3325   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3326
3327   if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
3328     {
3329       /* It is a no-op. */
3330       memcpy (to, from, REGISTER_RAW_SIZE (regnum));
3331       return;
3332     }
3333
3334   if ((regnum >= tdep->DR0_REGNUM
3335        && regnum <= tdep->DR_LAST_REGNUM)
3336       || (regnum >= tdep->DR0_C_REGNUM
3337           && regnum <= tdep->DR_LAST_C_REGNUM))
3338     {
3339       DOUBLEST val;
3340       floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword, from, &val);
3341       store_floating(to, TYPE_LENGTH(type), val);
3342     }
3343   else
3344     error("sh_register_convert_to_virtual called with non DR register number");
3345 }
3346
3347 static void
3348 sh_sh4_register_convert_to_raw (struct type *type, int regnum,
3349                                 const void *from, void *to)
3350 {
3351   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3352
3353   if (regnum >= tdep->DR0_REGNUM
3354       && regnum <= tdep->DR_LAST_REGNUM)
3355     {
3356       DOUBLEST val = extract_floating (from, TYPE_LENGTH(type));
3357       floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword, &val, to);
3358     }
3359   else
3360     error("sh_register_convert_to_raw called with non DR register number");
3361 }
3362
3363 void
3364 sh_sh64_register_convert_to_raw (struct type *type, int regnum,
3365                                  const void *from, void *to)
3366 {
3367   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3368
3369   if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
3370     {
3371       /* It is a no-op. */
3372       memcpy (to, from, REGISTER_RAW_SIZE (regnum));
3373       return;
3374     }
3375
3376   if ((regnum >= tdep->DR0_REGNUM
3377        && regnum <= tdep->DR_LAST_REGNUM)
3378       || (regnum >= tdep->DR0_C_REGNUM
3379           && regnum <= tdep->DR_LAST_C_REGNUM))
3380     {
3381       DOUBLEST val = extract_floating (from, TYPE_LENGTH(type));
3382       floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword, &val, to);
3383     }
3384   else
3385     error("sh_register_convert_to_raw called with non DR register number");
3386 }
3387
3388 void
3389 sh_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
3390                          int reg_nr, void *buffer)
3391 {
3392   int base_regnum, portion;
3393   char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
3394   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3395
3396   if (reg_nr >= tdep->DR0_REGNUM
3397       && reg_nr <= tdep->DR_LAST_REGNUM)
3398     {
3399       base_regnum = dr_reg_base_num (reg_nr);
3400
3401       /* Build the value in the provided buffer. */
3402       /* Read the real regs for which this one is an alias.  */
3403       for (portion = 0; portion < 2; portion++)
3404         regcache_raw_read (regcache, base_regnum + portion,
3405                            (temp_buffer
3406                             + REGISTER_RAW_SIZE (base_regnum) * portion));
3407       /* We must pay attention to the endiannes. */
3408       sh_sh4_register_convert_to_virtual (reg_nr,
3409                                           REGISTER_VIRTUAL_TYPE (reg_nr),
3410                                           temp_buffer, buffer);
3411     }
3412   else if (reg_nr >= tdep->FV0_REGNUM
3413            && reg_nr <= tdep->FV_LAST_REGNUM)
3414     {
3415       base_regnum = fv_reg_base_num (reg_nr);
3416
3417       /* Read the real regs for which this one is an alias.  */
3418       for (portion = 0; portion < 4; portion++)
3419         regcache_raw_read (regcache, base_regnum + portion,
3420                            ((char *) buffer
3421                             + REGISTER_RAW_SIZE (base_regnum) * portion));
3422     }
3423 }
3424
3425 static void
3426 sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
3427                            int reg_nr, void *buffer)
3428 {
3429   int base_regnum;
3430   int portion;
3431   int offset = 0;
3432   char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
3433   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3434
3435   if (reg_nr >= tdep->DR0_REGNUM
3436       && reg_nr <= tdep->DR_LAST_REGNUM)
3437     {
3438       base_regnum = dr_reg_base_num (reg_nr);
3439
3440       /* Build the value in the provided buffer. */
3441       /* DR regs are double precision registers obtained by
3442          concatenating 2 single precision floating point registers. */
3443       for (portion = 0; portion < 2; portion++)
3444         regcache_raw_read (regcache, base_regnum + portion,
3445                            (temp_buffer
3446                             + REGISTER_RAW_SIZE (base_regnum) * portion));
3447
3448       /* We must pay attention to the endiannes. */
3449       sh_sh64_register_convert_to_virtual (reg_nr, REGISTER_VIRTUAL_TYPE (reg_nr),
3450                                            temp_buffer, buffer);
3451
3452     }
3453
3454   else if (reg_nr >= tdep->FPP0_REGNUM
3455            && reg_nr <= tdep->FPP_LAST_REGNUM)
3456     {
3457       base_regnum = fpp_reg_base_num (reg_nr);
3458
3459       /* Build the value in the provided buffer. */
3460       /* FPP regs are pairs of single precision registers obtained by
3461          concatenating 2 single precision floating point registers. */
3462       for (portion = 0; portion < 2; portion++)
3463         regcache_raw_read (regcache, base_regnum + portion,
3464                            ((char *) buffer
3465                             + REGISTER_RAW_SIZE (base_regnum) * portion));
3466     }
3467
3468   else if (reg_nr >= tdep->FV0_REGNUM
3469            && reg_nr <= tdep->FV_LAST_REGNUM)
3470     {
3471       base_regnum = fv_reg_base_num (reg_nr);
3472
3473       /* Build the value in the provided buffer. */
3474       /* FV regs are vectors of single precision registers obtained by
3475          concatenating 4 single precision floating point registers. */
3476       for (portion = 0; portion < 4; portion++)
3477         regcache_raw_read (regcache, base_regnum + portion,
3478                            ((char *) buffer
3479                             + REGISTER_RAW_SIZE (base_regnum) * portion));
3480     }
3481
3482   /* sh compact pseudo registers. 1-to-1 with a shmedia register */
3483   else if (reg_nr >= tdep->R0_C_REGNUM
3484            && reg_nr <= tdep->T_C_REGNUM)
3485     {
3486       base_regnum = sh64_compact_reg_base_num (reg_nr);
3487
3488       /* Build the value in the provided buffer. */
3489       regcache_raw_read (regcache, base_regnum, temp_buffer);
3490       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3491         offset = 4;
3492       memcpy (buffer, temp_buffer + offset, 4); /* get LOWER 32 bits only????*/
3493     }
3494
3495   else if (reg_nr >= tdep->FP0_C_REGNUM
3496            && reg_nr <= tdep->FP_LAST_C_REGNUM)
3497     {
3498       base_regnum = sh64_compact_reg_base_num (reg_nr);
3499
3500       /* Build the value in the provided buffer. */
3501       /* Floating point registers map 1-1 to the media fp regs,
3502          they have the same size and endienness. */
3503       regcache_raw_read (regcache, base_regnum, buffer);
3504     }
3505
3506   else if (reg_nr >= tdep->DR0_C_REGNUM
3507            && reg_nr <= tdep->DR_LAST_C_REGNUM)
3508     {
3509       base_regnum = sh64_compact_reg_base_num (reg_nr);
3510
3511       /* DR_C regs are double precision registers obtained by
3512          concatenating 2 single precision floating point registers. */
3513       for (portion = 0; portion < 2; portion++)
3514         regcache_raw_read (regcache, base_regnum + portion,
3515                            (temp_buffer
3516                             + REGISTER_RAW_SIZE (base_regnum) * portion));
3517
3518       /* We must pay attention to the endiannes. */
3519       sh_sh64_register_convert_to_virtual (reg_nr, REGISTER_VIRTUAL_TYPE (reg_nr),
3520                                            temp_buffer, buffer);
3521     }
3522
3523   else if (reg_nr >= tdep->FV0_C_REGNUM
3524            && reg_nr <= tdep->FV_LAST_C_REGNUM)
3525     {
3526       base_regnum = sh64_compact_reg_base_num (reg_nr);
3527
3528       /* Build the value in the provided buffer. */
3529       /* FV_C regs are vectors of single precision registers obtained by
3530          concatenating 4 single precision floating point registers. */
3531       for (portion = 0; portion < 4; portion++)
3532         regcache_raw_read (regcache, base_regnum + portion,
3533                            ((char *) buffer
3534                             + REGISTER_RAW_SIZE (base_regnum) * portion));
3535     }
3536
3537   else if (reg_nr == tdep->FPSCR_C_REGNUM)
3538     {
3539       int fpscr_base_regnum;
3540       int sr_base_regnum;
3541       unsigned int fpscr_value;
3542       unsigned int sr_value;
3543       unsigned int fpscr_c_value;
3544       unsigned int fpscr_c_part1_value;
3545       unsigned int fpscr_c_part2_value;
3546
3547       fpscr_base_regnum = tdep->FPSCR_REGNUM;
3548       sr_base_regnum = tdep->SR_REGNUM;
3549
3550       /* Build the value in the provided buffer. */
3551       /* FPSCR_C is a very weird register that contains sparse bits
3552          from the FPSCR and the SR architectural registers.
3553          Specifically: */
3554       /* *INDENT-OFF* */
3555       /*
3556          FPSRC_C bit
3557             0         Bit 0 of FPSCR
3558             1         reserved
3559             2-17      Bit 2-18 of FPSCR
3560             18-20     Bits 12,13,14 of SR
3561             21-31     reserved
3562        */
3563       /* *INDENT-ON* */
3564       /* Get FPSCR into a local buffer */
3565       regcache_raw_read (regcache, fpscr_base_regnum, temp_buffer);
3566       /* Get value as an int. */
3567       fpscr_value = extract_unsigned_integer (temp_buffer, 4);
3568       /* Get SR into a local buffer */
3569       regcache_raw_read (regcache, sr_base_regnum, temp_buffer);
3570       /* Get value as an int. */
3571       sr_value = extract_unsigned_integer (temp_buffer, 4);
3572       /* Build the new value. */
3573       fpscr_c_part1_value = fpscr_value & 0x3fffd;
3574       fpscr_c_part2_value = (sr_value & 0x7000) << 6;
3575       fpscr_c_value = fpscr_c_part1_value | fpscr_c_part2_value;
3576       /* Store that in out buffer!!! */
3577       store_unsigned_integer (buffer, 4, fpscr_c_value);
3578       /* FIXME There is surely an endianness gotcha here. */
3579     }
3580
3581   else if (reg_nr == tdep->FPUL_C_REGNUM)
3582     {
3583       base_regnum = sh64_compact_reg_base_num (reg_nr);
3584
3585       /* FPUL_C register is floating point register 32,
3586          same size, same endianness. */
3587       regcache_raw_read (regcache, base_regnum, buffer);
3588     }
3589 }
3590
3591 void
3592 sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
3593                           int reg_nr, const void *buffer)
3594 {
3595   int base_regnum, portion;
3596   char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
3597   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3598
3599   if (reg_nr >= tdep->DR0_REGNUM
3600       && reg_nr <= tdep->DR_LAST_REGNUM)
3601     {
3602       base_regnum = dr_reg_base_num (reg_nr);
3603
3604       /* We must pay attention to the endiannes. */
3605       sh_sh4_register_convert_to_raw (REGISTER_VIRTUAL_TYPE (reg_nr), reg_nr,
3606                                       buffer, temp_buffer);
3607
3608       /* Write the real regs for which this one is an alias.  */
3609       for (portion = 0; portion < 2; portion++)
3610         regcache_raw_write (regcache, base_regnum + portion,
3611                             (temp_buffer
3612                              + REGISTER_RAW_SIZE (base_regnum) * portion));
3613     }
3614   else if (reg_nr >= tdep->FV0_REGNUM
3615            && reg_nr <= tdep->FV_LAST_REGNUM)
3616     {
3617       base_regnum = fv_reg_base_num (reg_nr);
3618
3619       /* Write the real regs for which this one is an alias.  */
3620       for (portion = 0; portion < 4; portion++)
3621         regcache_raw_write (regcache, base_regnum + portion,
3622                             ((char *) buffer
3623                              + REGISTER_RAW_SIZE (base_regnum) * portion));
3624     }
3625 }
3626
3627 void
3628 sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
3629                             int reg_nr, const void *buffer)
3630 {
3631   int base_regnum, portion;
3632   int offset;
3633   char *temp_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
3634   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3635
3636   if (reg_nr >= tdep->DR0_REGNUM
3637       && reg_nr <= tdep->DR_LAST_REGNUM)
3638     {
3639       base_regnum = dr_reg_base_num (reg_nr);
3640       /* We must pay attention to the endiannes. */
3641       sh_sh64_register_convert_to_raw (REGISTER_VIRTUAL_TYPE (reg_nr), reg_nr,
3642                                        buffer, temp_buffer);
3643
3644
3645       /* Write the real regs for which this one is an alias.  */
3646       for (portion = 0; portion < 2; portion++)
3647         regcache_raw_write (regcache, base_regnum + portion,
3648                             (temp_buffer
3649                              + REGISTER_RAW_SIZE (base_regnum) * portion));
3650     }
3651
3652   else if (reg_nr >= tdep->FPP0_REGNUM
3653            && reg_nr <= tdep->FPP_LAST_REGNUM)
3654     {
3655       base_regnum = fpp_reg_base_num (reg_nr);
3656
3657       /* Write the real regs for which this one is an alias.  */
3658       for (portion = 0; portion < 2; portion++)
3659         regcache_raw_write (regcache, base_regnum + portion,
3660                             ((char *) buffer
3661                              + REGISTER_RAW_SIZE (base_regnum) * portion));
3662     }
3663
3664   else if (reg_nr >= tdep->FV0_REGNUM
3665            && reg_nr <= tdep->FV_LAST_REGNUM)
3666     {
3667       base_regnum = fv_reg_base_num (reg_nr);
3668
3669       /* Write the real regs for which this one is an alias.  */
3670       for (portion = 0; portion < 4; portion++)
3671         regcache_raw_write (regcache, base_regnum + portion,
3672                             ((char *) buffer
3673                              + REGISTER_RAW_SIZE (base_regnum) * portion));
3674     }
3675
3676   /* sh compact general pseudo registers. 1-to-1 with a shmedia
3677      register but only 4 bytes of it.  */
3678   else if (reg_nr >= tdep->R0_C_REGNUM
3679            && reg_nr <= tdep->T_C_REGNUM)
3680     {
3681       base_regnum = sh64_compact_reg_base_num (reg_nr);
3682       /* reg_nr is 32 bit here, and base_regnum is 64 bits. */
3683       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
3684         offset = 4;
3685       else
3686         offset = 0;
3687       /* Let's read the value of the base register into a temporary
3688          buffer, so that overwriting the last four bytes with the new
3689          value of the pseudo will leave the upper 4 bytes unchanged. */
3690       regcache_raw_read (regcache, base_regnum, temp_buffer);
3691       /* Write as an 8 byte quantity */
3692       memcpy (temp_buffer + offset, buffer, 4);
3693       regcache_raw_write (regcache, base_regnum, temp_buffer);
3694     }
3695
3696   /* sh floating point compact pseudo registers. 1-to-1 with a shmedia
3697      registers. Both are 4 bytes. */
3698   else if (reg_nr >= tdep->FP0_C_REGNUM
3699                && reg_nr <= tdep->FP_LAST_C_REGNUM)
3700     {
3701       base_regnum = sh64_compact_reg_base_num (reg_nr);
3702       regcache_raw_write (regcache, base_regnum, buffer);
3703     }
3704
3705   else if (reg_nr >= tdep->DR0_C_REGNUM
3706            && reg_nr <= tdep->DR_LAST_C_REGNUM)
3707     {
3708       base_regnum = sh64_compact_reg_base_num (reg_nr);
3709       for (portion = 0; portion < 2; portion++)
3710         {
3711           /* We must pay attention to the endiannes. */
3712           sh_sh64_register_convert_to_raw (REGISTER_VIRTUAL_TYPE (reg_nr), reg_nr,
3713                                            buffer, temp_buffer);
3714
3715           regcache_raw_write (regcache, base_regnum + portion,
3716                               (temp_buffer
3717                                + REGISTER_RAW_SIZE (base_regnum) * portion));
3718         }
3719     }
3720
3721   else if (reg_nr >= tdep->FV0_C_REGNUM
3722            && reg_nr <= tdep->FV_LAST_C_REGNUM)
3723     {
3724       base_regnum = sh64_compact_reg_base_num (reg_nr);
3725
3726       for (portion = 0; portion < 4; portion++)
3727         {
3728           regcache_raw_write (regcache, base_regnum + portion,
3729                               ((char *) buffer
3730                                + REGISTER_RAW_SIZE (base_regnum) * portion));
3731         }
3732     }
3733
3734   else if (reg_nr == tdep->FPSCR_C_REGNUM)
3735     {
3736       int fpscr_base_regnum;
3737       int sr_base_regnum;
3738       unsigned int fpscr_value;
3739       unsigned int sr_value;
3740       unsigned int old_fpscr_value;
3741       unsigned int old_sr_value;
3742       unsigned int fpscr_c_value;
3743       unsigned int fpscr_mask;
3744       unsigned int sr_mask;
3745
3746       fpscr_base_regnum = tdep->FPSCR_REGNUM;
3747       sr_base_regnum = tdep->SR_REGNUM;
3748
3749       /* FPSCR_C is a very weird register that contains sparse bits
3750          from the FPSCR and the SR architectural registers.
3751          Specifically: */
3752       /* *INDENT-OFF* */
3753       /*
3754          FPSRC_C bit
3755             0         Bit 0 of FPSCR
3756             1         reserved
3757             2-17      Bit 2-18 of FPSCR
3758             18-20     Bits 12,13,14 of SR
3759             21-31     reserved
3760        */
3761       /* *INDENT-ON* */
3762       /* Get value as an int. */
3763       fpscr_c_value = extract_unsigned_integer (buffer, 4);
3764
3765       /* Build the new values. */
3766       fpscr_mask = 0x0003fffd;
3767       sr_mask = 0x001c0000;
3768
3769       fpscr_value = fpscr_c_value & fpscr_mask;
3770       sr_value = (fpscr_value & sr_mask) >> 6;
3771
3772       regcache_raw_read (regcache, fpscr_base_regnum, temp_buffer);
3773       old_fpscr_value = extract_unsigned_integer (temp_buffer, 4);
3774       old_fpscr_value &= 0xfffc0002;
3775       fpscr_value |= old_fpscr_value;
3776       store_unsigned_integer (temp_buffer, 4, fpscr_value);
3777       regcache_raw_write (regcache, fpscr_base_regnum, temp_buffer);
3778
3779       regcache_raw_read (regcache, sr_base_regnum, temp_buffer);
3780       old_sr_value = extract_unsigned_integer (temp_buffer, 4);
3781       old_sr_value &= 0xffff8fff;
3782       sr_value |= old_sr_value;
3783       store_unsigned_integer (temp_buffer, 4, sr_value);
3784       regcache_raw_write (regcache, sr_base_regnum, temp_buffer);
3785     }
3786
3787   else if (reg_nr == tdep->FPUL_C_REGNUM)
3788     {
3789       base_regnum = sh64_compact_reg_base_num (reg_nr);
3790       regcache_raw_write (regcache, base_regnum, buffer);
3791     }
3792 }
3793
3794 /* Floating point vector of 4 float registers. */
3795 static void
3796 do_fv_register_info (int fv_regnum)
3797 {
3798   int first_fp_reg_num = fv_reg_base_num (fv_regnum);
3799   printf_filtered ("fv%d\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n",
3800                      fv_regnum - gdbarch_tdep (current_gdbarch)->FV0_REGNUM,
3801                      (int) read_register (first_fp_reg_num),
3802                      (int) read_register (first_fp_reg_num + 1),
3803                      (int) read_register (first_fp_reg_num + 2),
3804                      (int) read_register (first_fp_reg_num + 3));
3805 }
3806
3807 /* Floating point vector of 4 float registers, compact mode. */
3808 static void
3809 do_fv_c_register_info (int fv_regnum)
3810 {
3811   int first_fp_reg_num = sh64_compact_reg_base_num (fv_regnum);
3812   printf_filtered ("fv%d_c\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n",
3813                      fv_regnum - gdbarch_tdep (current_gdbarch)->FV0_C_REGNUM,
3814                      (int) read_register (first_fp_reg_num),
3815                      (int) read_register (first_fp_reg_num + 1),
3816                      (int) read_register (first_fp_reg_num + 2),
3817                      (int) read_register (first_fp_reg_num + 3));
3818 }
3819
3820 /* Pairs of single regs. The DR are instead double precision
3821    registers. */
3822 static void
3823 do_fpp_register_info (int fpp_regnum)
3824 {
3825   int first_fp_reg_num = fpp_reg_base_num (fpp_regnum);
3826
3827   printf_filtered ("fpp%d\t0x%08x\t0x%08x\n",
3828                     fpp_regnum - gdbarch_tdep (current_gdbarch)->FPP0_REGNUM,
3829                     (int) read_register (first_fp_reg_num),
3830                     (int) read_register (first_fp_reg_num + 1));
3831 }
3832
3833 /* Double precision registers. */
3834 static void
3835 do_dr_register_info (int dr_regnum)
3836 {
3837   int first_fp_reg_num = dr_reg_base_num (dr_regnum);
3838
3839   printf_filtered ("dr%d\t0x%08x%08x\n",
3840                     dr_regnum - gdbarch_tdep (current_gdbarch)->DR0_REGNUM,
3841                     (int) read_register (first_fp_reg_num),
3842                     (int) read_register (first_fp_reg_num + 1));
3843 }
3844
3845 /* Double precision registers, compact mode. */
3846 static void
3847 do_dr_c_register_info (int dr_regnum)
3848 {
3849  int first_fp_reg_num = sh64_compact_reg_base_num (dr_regnum);
3850
3851  printf_filtered ("dr%d_c\t0x%08x%08x\n",
3852                   dr_regnum - gdbarch_tdep (current_gdbarch)->DR0_C_REGNUM,
3853                   (int) read_register (first_fp_reg_num),
3854                   (int) read_register (first_fp_reg_num +1));
3855 }
3856
3857 /* General register in compact mode. */
3858 static void
3859 do_r_c_register_info (int r_c_regnum)
3860 {
3861   int regnum =  sh64_compact_reg_base_num (r_c_regnum);
3862
3863   printf_filtered ("r%d_c\t0x%08x\n",
3864                     r_c_regnum - gdbarch_tdep (current_gdbarch)->R0_C_REGNUM,
3865                    /*FIXME!!!*/  (int) read_register (regnum));
3866 }
3867
3868 /* FIXME:!! THIS SHOULD TAKE CARE OF GETTING THE RIGHT PORTION OF THE
3869    shmedia REGISTERS. */
3870 /* Control registers, compact mode. */
3871 static void
3872 do_cr_c_register_info (int cr_c_regnum)
3873 {
3874   switch (cr_c_regnum)
3875     {
3876     case 237: printf_filtered ("pc_c\t0x%08x\n", (int) read_register (cr_c_regnum));
3877       break;
3878     case 238: printf_filtered ("gbr_c\t0x%08x\n", (int) read_register (cr_c_regnum));
3879       break;
3880     case 239: printf_filtered ("mach_c\t0x%08x\n", (int) read_register (cr_c_regnum));
3881       break;
3882     case 240: printf_filtered ("macl_c\t0x%08x\n", (int) read_register (cr_c_regnum));
3883       break;
3884     case 241: printf_filtered ("pr_c\t0x%08x\n", (int) read_register (cr_c_regnum));
3885       break;
3886     case 242: printf_filtered ("t_c\t0x%08x\n", (int) read_register (cr_c_regnum));
3887       break;
3888     case 243: printf_filtered ("fpscr_c\t0x%08x\n", (int) read_register (cr_c_regnum));
3889       break;
3890     case 244: printf_filtered ("fpul_c\t0x%08x\n", (int)read_register (cr_c_regnum));
3891       break;
3892     }
3893 }
3894
3895 static void
3896 sh_do_pseudo_register (int regnum)
3897 {
3898   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3899
3900   if (regnum < NUM_REGS || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
3901     internal_error (__FILE__, __LINE__,
3902                     "Invalid pseudo register number %d\n", regnum);
3903   else if (regnum >= tdep->DR0_REGNUM
3904            && regnum < tdep->DR_LAST_REGNUM)
3905     do_dr_register_info (regnum);
3906   else if (regnum >= tdep->FV0_REGNUM
3907            && regnum <= tdep->FV_LAST_REGNUM)
3908     do_fv_register_info (regnum);
3909 }
3910
3911 static void
3912 sh_do_fp_register (int regnum)
3913 {                               /* do values for FP (float) regs */
3914   char *raw_buffer;
3915   double flt;   /* double extracted from raw hex data */
3916   int inv;
3917   int j;
3918
3919   /* Allocate space for the float. */
3920   raw_buffer = (char *) alloca (REGISTER_RAW_SIZE (FP0_REGNUM));
3921
3922   /* Get the data in raw format.  */
3923   if (!frame_register_read (deprecated_selected_frame, regnum, raw_buffer))
3924     error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
3925
3926   /* Get the register as a number */
3927   flt = unpack_double (builtin_type_float, raw_buffer, &inv);
3928
3929   /* Print the name and some spaces. */
3930   fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
3931   print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), gdb_stdout);
3932
3933   /* Print the value. */
3934   if (inv)
3935     printf_filtered ("<invalid float>");
3936   else
3937     printf_filtered ("%-10.9g", flt);
3938
3939   /* Print the fp register as hex. */
3940   printf_filtered ("\t(raw 0x");
3941   for (j = 0; j < REGISTER_RAW_SIZE (regnum); j++)
3942     {
3943       register int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j
3944         : REGISTER_RAW_SIZE (regnum) - 1 - j;
3945       printf_filtered ("%02x", (unsigned char) raw_buffer[idx]);
3946     }
3947   printf_filtered (")");
3948   printf_filtered ("\n");
3949 }
3950
3951 static void
3952 sh64_do_pseudo_register (int regnum)
3953 {
3954   /* All the sh64-compact mode registers are pseudo registers. */
3955   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
3956
3957   if (regnum < NUM_REGS
3958       || regnum >= NUM_REGS + NUM_PSEUDO_REGS_SH_MEDIA + NUM_PSEUDO_REGS_SH_COMPACT)
3959     internal_error (__FILE__, __LINE__,
3960                     "Invalid pseudo register number %d\n", regnum);
3961
3962   else if ((regnum >= tdep->DR0_REGNUM
3963             && regnum <= tdep->DR_LAST_REGNUM))
3964     do_dr_register_info (regnum);
3965
3966   else if ((regnum >= tdep->DR0_C_REGNUM
3967             && regnum <= tdep->DR_LAST_C_REGNUM))
3968     do_dr_c_register_info (regnum);
3969
3970   else if ((regnum >= tdep->FV0_REGNUM
3971             && regnum <= tdep->FV_LAST_REGNUM))
3972     do_fv_register_info (regnum);
3973
3974   else if ((regnum >= tdep->FV0_C_REGNUM
3975             && regnum <= tdep->FV_LAST_C_REGNUM))
3976     do_fv_c_register_info (regnum);
3977
3978   else if (regnum >= tdep->FPP0_REGNUM
3979            && regnum <= tdep->FPP_LAST_REGNUM)
3980     do_fpp_register_info (regnum);
3981
3982   else if (regnum >= tdep->R0_C_REGNUM
3983            && regnum <= tdep->R_LAST_C_REGNUM)
3984     do_r_c_register_info (regnum); /* FIXME, this function will not print the right format */
3985
3986   else if (regnum >= tdep->FP0_C_REGNUM
3987            && regnum <= tdep->FP_LAST_C_REGNUM)
3988     sh_do_fp_register (regnum); /* this should work also for pseudoregs */
3989
3990   else if (regnum >= tdep->PC_C_REGNUM
3991            && regnum <= tdep->FPUL_C_REGNUM)
3992     do_cr_c_register_info (regnum);
3993
3994 }
3995
3996 static void
3997 sh_do_register (int regnum)
3998 {
3999   char raw_buffer[MAX_REGISTER_RAW_SIZE];
4000
4001   fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
4002   print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), gdb_stdout);
4003
4004   /* Get the data in raw format.  */
4005   if (!frame_register_read (deprecated_selected_frame, regnum, raw_buffer))
4006     printf_filtered ("*value not available*\n");
4007
4008   val_print (REGISTER_VIRTUAL_TYPE (regnum), raw_buffer, 0, 0,
4009              gdb_stdout, 'x', 1, 0, Val_pretty_default);
4010   printf_filtered ("\t");
4011   val_print (REGISTER_VIRTUAL_TYPE (regnum), raw_buffer, 0, 0,
4012              gdb_stdout, 0, 1, 0, Val_pretty_default);
4013   printf_filtered ("\n");
4014 }
4015
4016 static void
4017 sh_print_register (int regnum)
4018 {
4019   if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
4020     internal_error (__FILE__, __LINE__,
4021                     "Invalid register number %d\n", regnum);
4022
4023   else if (regnum >= 0 && regnum < NUM_REGS)
4024     {
4025       if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
4026         sh_do_fp_register (regnum);     /* FP regs */
4027       else
4028         sh_do_register (regnum);        /* All other regs */
4029     }
4030
4031   else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
4032     do_pseudo_register (regnum);
4033 }
4034
4035 void
4036 sh_do_registers_info (int regnum, int fpregs)
4037 {
4038   if (regnum != -1)             /* do one specified register */
4039     {
4040       if (*(REGISTER_NAME (regnum)) == '\0')
4041         error ("Not a valid register for the current processor type");
4042
4043       sh_print_register (regnum);
4044     }
4045   else
4046     /* do all (or most) registers */
4047     {
4048       regnum = 0;
4049       while (regnum < NUM_REGS)
4050         {
4051           /* If the register name is empty, it is undefined for this
4052              processor, so don't display anything.  */
4053           if (REGISTER_NAME (regnum) == NULL
4054               || *(REGISTER_NAME (regnum)) == '\0')
4055             {
4056               regnum++;
4057               continue;
4058             }
4059
4060           if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
4061             {
4062               if (fpregs)
4063                 {
4064                   /* true for "INFO ALL-REGISTERS" command */
4065                   sh_do_fp_register (regnum);   /* FP regs */
4066                   regnum ++;
4067                 }
4068               else
4069                 regnum += (gdbarch_tdep (current_gdbarch)->FP_LAST_REGNUM - FP0_REGNUM);        /* skip FP regs */
4070             }
4071           else
4072             {
4073               sh_do_register (regnum);  /* All other regs */
4074               regnum++;
4075             }
4076         }
4077
4078       if (fpregs)
4079         while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
4080           {
4081             do_pseudo_register (regnum);
4082             regnum++;
4083           }
4084     }
4085 }
4086
4087 void
4088 sh_compact_do_registers_info (int regnum, int fpregs)
4089 {
4090   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
4091   if (regnum != -1)             /* do one specified register */
4092     {
4093       if (*(REGISTER_NAME (regnum)) == '\0')
4094         error ("Not a valid register for the current processor type");
4095
4096       if (regnum >= 0 && regnum < tdep->R0_C_REGNUM)
4097         error ("Not a valid register for the current processor mode.");
4098
4099       sh_print_register (regnum);
4100     }
4101   else
4102     /* do all compact registers */
4103     {
4104       regnum = tdep->R0_C_REGNUM;
4105       while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
4106         {
4107           do_pseudo_register (regnum);
4108           regnum++;
4109         }
4110     }
4111 }
4112
4113 void
4114 sh64_do_registers_info (int regnum, int fpregs)
4115 {
4116   if (pc_is_isa32 (get_frame_pc (deprecated_selected_frame)))
4117    sh_do_registers_info (regnum, fpregs);
4118   else
4119    sh_compact_do_registers_info (regnum, fpregs);
4120 }
4121
4122 #ifdef SVR4_SHARED_LIBS
4123
4124 /* Fetch (and possibly build) an appropriate link_map_offsets structure
4125    for native i386 linux targets using the struct offsets defined in
4126    link.h (but without actual reference to that file).
4127
4128    This makes it possible to access i386-linux shared libraries from
4129    a gdb that was not built on an i386-linux host (for cross debugging).
4130    */
4131
4132 struct link_map_offsets *
4133 sh_linux_svr4_fetch_link_map_offsets (void)
4134 {
4135   static struct link_map_offsets lmo;
4136   static struct link_map_offsets *lmp = 0;
4137
4138   if (lmp == 0)
4139     {
4140       lmp = &lmo;
4141
4142       lmo.r_debug_size = 8;     /* 20 not actual size but all we need */
4143
4144       lmo.r_map_offset = 4;
4145       lmo.r_map_size   = 4;
4146
4147       lmo.link_map_size = 20;   /* 552 not actual size but all we need */
4148
4149       lmo.l_addr_offset = 0;
4150       lmo.l_addr_size   = 4;
4151
4152       lmo.l_name_offset = 4;
4153       lmo.l_name_size   = 4;
4154
4155       lmo.l_next_offset = 12;
4156       lmo.l_next_size   = 4;
4157
4158       lmo.l_prev_offset = 16;
4159       lmo.l_prev_size   = 4;
4160     }
4161
4162     return lmp;
4163 }
4164 #endif /* SVR4_SHARED_LIBS */
4165
4166 \f
4167 enum
4168 {
4169    DSP_DSR_REGNUM = 24,
4170    DSP_A0G_REGNUM,
4171    DSP_A0_REGNUM,
4172    DSP_A1G_REGNUM,
4173    DSP_A1_REGNUM,
4174    DSP_M0_REGNUM,
4175    DSP_M1_REGNUM,
4176    DSP_X0_REGNUM,
4177    DSP_X1_REGNUM,
4178    DSP_Y0_REGNUM,
4179    DSP_Y1_REGNUM,
4180
4181    DSP_MOD_REGNUM = 40,
4182
4183    DSP_RS_REGNUM = 43,
4184    DSP_RE_REGNUM,
4185
4186    DSP_R0_BANK_REGNUM = 51,
4187    DSP_R7_BANK_REGNUM = DSP_R0_BANK_REGNUM + 7
4188 };
4189
4190 static int
4191 sh_dsp_register_sim_regno (int nr)
4192 {
4193   if (legacy_register_sim_regno (nr) < 0)
4194     return legacy_register_sim_regno (nr);
4195   if (nr >= DSP_DSR_REGNUM && nr < DSP_Y1_REGNUM)
4196     return nr - DSP_DSR_REGNUM + SIM_SH_DSR_REGNUM;
4197   if (nr == DSP_MOD_REGNUM)
4198     return SIM_SH_MOD_REGNUM;
4199   if (nr == DSP_RS_REGNUM)
4200     return SIM_SH_RS_REGNUM;
4201   if (nr == DSP_RE_REGNUM)
4202     return SIM_SH_RE_REGNUM;
4203   if (nr >= DSP_R0_BANK_REGNUM && nr <= DSP_R7_BANK_REGNUM)
4204     return nr - DSP_R0_BANK_REGNUM + SIM_SH_R0_BANK_REGNUM;
4205   return nr;
4206 }
4207 \f
4208 static gdbarch_init_ftype sh_gdbarch_init;
4209
4210 static struct gdbarch *
4211 sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
4212 {
4213   static LONGEST sh_call_dummy_words[] = {0};
4214   struct gdbarch *gdbarch;
4215   struct gdbarch_tdep *tdep;
4216   gdbarch_register_name_ftype *sh_register_name;
4217   gdbarch_deprecated_store_return_value_ftype *sh_store_return_value;
4218   gdbarch_register_virtual_type_ftype *sh_register_virtual_type;
4219   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
4220
4221   /* Try to determine the ABI of the object we are loading.  */
4222
4223   if (info.abfd != NULL)
4224     {
4225       osabi = gdbarch_lookup_osabi (info.abfd);
4226       /* If we get "unknown" back, just leave it that way.  */
4227     }
4228
4229   /* Find a candidate among the list of pre-declared architectures. */
4230   for (arches = gdbarch_list_lookup_by_info (arches, &info);
4231        arches != NULL;
4232        arches = gdbarch_list_lookup_by_info (arches->next, &info))
4233     {
4234       /* Make sure the ABI selection matches.  */
4235       tdep = gdbarch_tdep (arches->gdbarch);
4236       if (tdep && tdep->osabi == osabi)
4237         return arches->gdbarch;
4238     }
4239
4240   /* None found, create a new architecture from the information
4241      provided. */
4242   tdep = XMALLOC (struct gdbarch_tdep);
4243   gdbarch = gdbarch_alloc (&info, tdep);
4244
4245   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
4246      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
4247   set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
4248
4249   tdep->osabi = osabi;
4250
4251   /* Initialize the register numbers that are not common to all the
4252      variants to -1, if necessary thse will be overwritten in the case
4253      statement below. */
4254   tdep->FPUL_REGNUM = -1;
4255   tdep->FPSCR_REGNUM = -1;
4256   tdep->PR_REGNUM = 17;
4257   tdep->SR_REGNUM = 22;
4258   tdep->DSR_REGNUM = -1;
4259   tdep->FP_LAST_REGNUM = -1;
4260   tdep->A0G_REGNUM = -1;
4261   tdep->A0_REGNUM = -1;
4262   tdep->A1G_REGNUM = -1;
4263   tdep->A1_REGNUM = -1;
4264   tdep->M0_REGNUM = -1;
4265   tdep->M1_REGNUM = -1;
4266   tdep->X0_REGNUM = -1;
4267   tdep->X1_REGNUM = -1;
4268   tdep->Y0_REGNUM = -1;
4269   tdep->Y1_REGNUM = -1;
4270   tdep->MOD_REGNUM = -1;
4271   tdep->RS_REGNUM = -1;
4272   tdep->RE_REGNUM = -1;
4273   tdep->SSR_REGNUM = -1;
4274   tdep->SPC_REGNUM = -1;
4275   tdep->DR0_REGNUM = -1;
4276   tdep->DR_LAST_REGNUM = -1;
4277   tdep->FV0_REGNUM = -1;
4278   tdep->FV_LAST_REGNUM = -1;
4279   tdep->ARG0_REGNUM = 4;
4280   tdep->ARGLAST_REGNUM = 7;
4281   tdep->RETURN_REGNUM = 0;
4282   tdep->FLOAT_ARGLAST_REGNUM = -1;
4283
4284   tdep->sh_abi = SH_ABI_UNKNOWN;
4285
4286   set_gdbarch_fp0_regnum (gdbarch, -1);
4287   set_gdbarch_num_pseudo_regs (gdbarch, 0);
4288   set_gdbarch_max_register_raw_size (gdbarch, 4);
4289   set_gdbarch_max_register_virtual_size (gdbarch, 4);
4290   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
4291   set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
4292   set_gdbarch_num_regs (gdbarch, SH_DEFAULT_NUM_REGS);
4293   set_gdbarch_sp_regnum (gdbarch, 15);
4294   set_gdbarch_fp_regnum (gdbarch, 14);
4295   set_gdbarch_pc_regnum (gdbarch, 16);
4296   set_gdbarch_register_size (gdbarch, 4);
4297   set_gdbarch_register_bytes (gdbarch, SH_DEFAULT_NUM_REGS * 4);
4298   set_gdbarch_deprecated_do_registers_info (gdbarch, sh_do_registers_info);
4299   set_gdbarch_breakpoint_from_pc (gdbarch, sh_breakpoint_from_pc);
4300   set_gdbarch_frame_chain (gdbarch, sh_frame_chain);
4301   set_gdbarch_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
4302   set_gdbarch_init_extra_frame_info (gdbarch, sh_init_extra_frame_info);
4303   set_gdbarch_deprecated_extract_return_value (gdbarch, sh_extract_return_value);
4304   set_gdbarch_push_arguments (gdbarch, sh_push_arguments);
4305   set_gdbarch_store_struct_return (gdbarch, sh_store_struct_return);
4306   set_gdbarch_use_struct_convention (gdbarch, sh_use_struct_convention);
4307   set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sh_extract_struct_value_address);
4308   set_gdbarch_pop_frame (gdbarch, sh_pop_frame);
4309   set_gdbarch_print_insn (gdbarch, gdb_print_insn_sh);
4310   set_gdbarch_register_sim_regno (gdbarch, legacy_register_sim_regno);
4311   skip_prologue_hard_way = sh_skip_prologue_hard_way;
4312   do_pseudo_register = sh_do_pseudo_register;
4313
4314   switch (info.bfd_arch_info->mach)
4315     {
4316     case bfd_mach_sh:
4317       sh_register_name = sh_sh_register_name;
4318       sh_show_regs = sh_generic_show_regs;
4319       sh_store_return_value = sh_default_store_return_value;
4320       sh_register_virtual_type = sh_default_register_virtual_type;
4321       set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
4322       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
4323       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
4324       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
4325       break;
4326     case bfd_mach_sh2:
4327       sh_register_name = sh_sh_register_name;
4328       sh_show_regs = sh_generic_show_regs;
4329       sh_store_return_value = sh_default_store_return_value;
4330       sh_register_virtual_type = sh_default_register_virtual_type;
4331       set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
4332       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
4333       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
4334       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
4335       break;
4336     case bfd_mach_sh_dsp:
4337       sh_register_name = sh_sh_dsp_register_name;
4338       sh_show_regs = sh_dsp_show_regs;
4339       sh_store_return_value = sh_default_store_return_value;
4340       sh_register_virtual_type = sh_default_register_virtual_type;
4341       set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
4342       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
4343       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
4344       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
4345       set_gdbarch_register_sim_regno (gdbarch, sh_dsp_register_sim_regno);
4346       tdep->DSR_REGNUM = 24;
4347       tdep->A0G_REGNUM = 25;
4348       tdep->A0_REGNUM = 26;
4349       tdep->A1G_REGNUM = 27;
4350       tdep->A1_REGNUM = 28;
4351       tdep->M0_REGNUM = 29;
4352       tdep->M1_REGNUM = 30;
4353       tdep->X0_REGNUM = 31;
4354       tdep->X1_REGNUM = 32;
4355       tdep->Y0_REGNUM = 33;
4356       tdep->Y1_REGNUM = 34;
4357       tdep->MOD_REGNUM = 40;
4358       tdep->RS_REGNUM = 43;
4359       tdep->RE_REGNUM = 44;
4360       break;
4361     case bfd_mach_sh3:
4362       sh_register_name = sh_sh3_register_name;
4363       sh_show_regs = sh3_show_regs;
4364       sh_store_return_value = sh_default_store_return_value;
4365       sh_register_virtual_type = sh_default_register_virtual_type;
4366       set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
4367       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
4368       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
4369       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
4370       tdep->SSR_REGNUM = 41;
4371       tdep->SPC_REGNUM = 42;
4372       break;
4373     case bfd_mach_sh3e:
4374       sh_register_name = sh_sh3e_register_name;
4375       sh_show_regs = sh3e_show_regs;
4376       sh_store_return_value = sh3e_sh4_store_return_value;
4377       sh_register_virtual_type = sh_sh3e_register_virtual_type;
4378       set_gdbarch_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs);
4379       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
4380       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
4381       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
4382       set_gdbarch_deprecated_extract_return_value (gdbarch, sh3e_sh4_extract_return_value);
4383       set_gdbarch_fp0_regnum (gdbarch, 25);
4384       tdep->FPUL_REGNUM = 23;
4385       tdep->FPSCR_REGNUM = 24;
4386       tdep->FP_LAST_REGNUM = 40;
4387       tdep->SSR_REGNUM = 41;
4388       tdep->SPC_REGNUM = 42;
4389       break;
4390     case bfd_mach_sh3_dsp:
4391       sh_register_name = sh_sh3_dsp_register_name;
4392       sh_show_regs = sh3_dsp_show_regs;
4393       sh_store_return_value = sh_default_store_return_value;
4394       sh_register_virtual_type = sh_default_register_virtual_type;
4395       set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
4396       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
4397       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
4398       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
4399       tdep->DSR_REGNUM = 24;
4400       tdep->A0G_REGNUM = 25;
4401       tdep->A0_REGNUM = 26;
4402       tdep->A1G_REGNUM = 27;
4403       tdep->A1_REGNUM = 28;
4404       tdep->M0_REGNUM = 29;
4405       tdep->M1_REGNUM = 30;
4406       tdep->X0_REGNUM = 31;
4407       tdep->X1_REGNUM = 32;
4408       tdep->Y0_REGNUM = 33;
4409       tdep->Y1_REGNUM = 34;
4410       tdep->MOD_REGNUM = 40;
4411       tdep->RS_REGNUM = 43;
4412       tdep->RE_REGNUM = 44;
4413       tdep->SSR_REGNUM = 41;
4414       tdep->SPC_REGNUM = 42;
4415       break;
4416     case bfd_mach_sh4:
4417       sh_register_name = sh_sh4_register_name;
4418       sh_show_regs = sh4_show_regs;
4419       sh_store_return_value = sh3e_sh4_store_return_value;
4420       sh_register_virtual_type = sh_sh4_register_virtual_type;
4421       set_gdbarch_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs);
4422       set_gdbarch_deprecated_extract_return_value (gdbarch, sh3e_sh4_extract_return_value);
4423       set_gdbarch_fp0_regnum (gdbarch, 25);
4424       set_gdbarch_register_raw_size (gdbarch, sh_sh4_register_raw_size);
4425       set_gdbarch_register_virtual_size (gdbarch, sh_sh4_register_raw_size);
4426       set_gdbarch_register_byte (gdbarch, sh_sh4_register_byte);
4427       set_gdbarch_num_pseudo_regs (gdbarch, 12);
4428       set_gdbarch_max_register_raw_size (gdbarch, 4 * 4);
4429       set_gdbarch_max_register_virtual_size (gdbarch, 4 * 4);
4430       set_gdbarch_pseudo_register_read (gdbarch, sh_pseudo_register_read);
4431       set_gdbarch_pseudo_register_write (gdbarch, sh_pseudo_register_write);
4432       tdep->FPUL_REGNUM = 23;
4433       tdep->FPSCR_REGNUM = 24;
4434       tdep->FP_LAST_REGNUM = 40;
4435       tdep->SSR_REGNUM = 41;
4436       tdep->SPC_REGNUM = 42;
4437       tdep->DR0_REGNUM = 59;
4438       tdep->DR_LAST_REGNUM = 66;
4439       tdep->FV0_REGNUM = 67;
4440       tdep->FV_LAST_REGNUM = 70;
4441       break;
4442     case bfd_mach_sh5:
4443       tdep->PR_REGNUM = 18;
4444       tdep->SR_REGNUM = 65;
4445       tdep->FPSCR_REGNUM = SIM_SH64_FPCSR_REGNUM;
4446       tdep->FP_LAST_REGNUM = SIM_SH64_FR0_REGNUM + SIM_SH64_NR_FP_REGS - 1;
4447       tdep->SSR_REGNUM = SIM_SH64_SSR_REGNUM;
4448       tdep->SPC_REGNUM = SIM_SH64_SPC_REGNUM;
4449       tdep->TR7_REGNUM = SIM_SH64_TR0_REGNUM + 7;
4450       tdep->FPP0_REGNUM = 173;
4451       tdep->FPP_LAST_REGNUM = 204;
4452       tdep->DR0_REGNUM = 141;
4453       tdep->DR_LAST_REGNUM = 172;
4454       tdep->FV0_REGNUM = 205;
4455       tdep->FV_LAST_REGNUM = 220;
4456       tdep->R0_C_REGNUM = 221;
4457       tdep->R_LAST_C_REGNUM = 236;
4458       tdep->PC_C_REGNUM = 237;
4459       tdep->GBR_C_REGNUM = 238;
4460       tdep->MACH_C_REGNUM = 239;
4461       tdep->MACL_C_REGNUM = 240;
4462       tdep->PR_C_REGNUM = 241;
4463       tdep->T_C_REGNUM = 242;
4464       tdep->FPSCR_C_REGNUM = 243;
4465       tdep->FPUL_C_REGNUM = 244;
4466       tdep->FP0_C_REGNUM = 245;
4467       tdep->FP_LAST_C_REGNUM = 260;
4468       tdep->DR0_C_REGNUM = 261;
4469       tdep->DR_LAST_C_REGNUM = 268;
4470       tdep->FV0_C_REGNUM = 269;
4471       tdep->FV_LAST_C_REGNUM = 272;
4472       tdep->ARG0_REGNUM = 2;
4473       tdep->ARGLAST_REGNUM = 9;
4474       tdep->RETURN_REGNUM = 2;
4475       tdep->FLOAT_ARGLAST_REGNUM = 11;
4476
4477       set_gdbarch_num_pseudo_regs (gdbarch, NUM_PSEUDO_REGS_SH_MEDIA + NUM_PSEUDO_REGS_SH_COMPACT);
4478       set_gdbarch_fp0_regnum (gdbarch, SIM_SH64_FR0_REGNUM);
4479       set_gdbarch_pc_regnum (gdbarch, 64);
4480
4481       /* Determine the ABI */
4482       if (bfd_get_arch_size (info.abfd) == 64)
4483         {
4484           /* If the ABI is the 64-bit one, it can only be sh-media. */
4485           tdep->sh_abi = SH_ABI_64;
4486           set_gdbarch_ptr_bit (gdbarch, 8 * TARGET_CHAR_BIT);
4487           set_gdbarch_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
4488         }
4489       else
4490         {
4491           /* If the ABI is the 32-bit one it could be either media or
4492              compact. */
4493           tdep->sh_abi = SH_ABI_32;
4494           set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
4495           set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
4496         }
4497
4498       /* the number of real registers is the same whether we are in
4499          ISA16(compact) or ISA32(media). */
4500       set_gdbarch_num_regs (gdbarch, SIM_SH64_NR_REGS);
4501       set_gdbarch_register_size (gdbarch, 8); /*????*/
4502       set_gdbarch_register_bytes (gdbarch,
4503                                   ((SIM_SH64_NR_FP_REGS + 1) * 4)
4504                                   + (SIM_SH64_NR_REGS - SIM_SH64_NR_FP_REGS -1) * 8);
4505
4506       sh_register_name = sh_sh64_register_name;
4507       sh_show_regs = sh64_show_regs;
4508       sh_register_virtual_type = sh_sh64_register_virtual_type;
4509       sh_store_return_value = sh64_store_return_value;
4510       skip_prologue_hard_way = sh64_skip_prologue_hard_way;
4511       do_pseudo_register = sh64_do_pseudo_register;
4512       set_gdbarch_register_raw_size (gdbarch, sh_sh64_register_raw_size);
4513       set_gdbarch_register_virtual_size (gdbarch, sh_sh64_register_raw_size);
4514       set_gdbarch_register_byte (gdbarch, sh_sh64_register_byte);
4515       /* This seems awfully wrong!*/
4516       /*set_gdbarch_max_register_raw_size (gdbarch, 8);*/
4517       /* should include the size of the pseudo regs. */
4518       set_gdbarch_max_register_raw_size (gdbarch, 4 * 4);
4519       /* Or should that go in the virtual_size? */
4520       /*set_gdbarch_max_register_virtual_size (gdbarch, 8);*/
4521       set_gdbarch_max_register_virtual_size (gdbarch, 4 * 4);
4522       set_gdbarch_pseudo_register_read (gdbarch, sh64_pseudo_register_read);
4523       set_gdbarch_pseudo_register_write (gdbarch, sh64_pseudo_register_write);
4524
4525       set_gdbarch_deprecated_do_registers_info (gdbarch, sh64_do_registers_info);
4526       set_gdbarch_frame_init_saved_regs (gdbarch, sh64_nofp_frame_init_saved_regs);
4527       set_gdbarch_breakpoint_from_pc (gdbarch, sh_sh64_breakpoint_from_pc);
4528       set_gdbarch_init_extra_frame_info (gdbarch, sh64_init_extra_frame_info);
4529       set_gdbarch_frame_chain (gdbarch, sh64_frame_chain);
4530       set_gdbarch_get_saved_register (gdbarch, sh64_get_saved_register);
4531       set_gdbarch_deprecated_extract_return_value (gdbarch, sh64_extract_return_value);
4532       set_gdbarch_push_arguments (gdbarch, sh64_push_arguments);
4533       /*set_gdbarch_store_struct_return (gdbarch, sh64_store_struct_return);*/
4534       set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sh64_extract_struct_value_address);
4535       set_gdbarch_use_struct_convention (gdbarch, sh64_use_struct_convention);
4536       set_gdbarch_pop_frame (gdbarch, sh64_pop_frame);
4537       set_gdbarch_elf_make_msymbol_special (gdbarch,
4538                                             sh64_elf_make_msymbol_special);
4539       break;
4540     default:
4541       sh_register_name = sh_generic_register_name;
4542       sh_show_regs = sh_generic_show_regs;
4543       sh_store_return_value = sh_default_store_return_value;
4544       sh_register_virtual_type = sh_default_register_virtual_type;
4545       set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
4546       set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
4547       set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
4548       set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
4549       break;
4550     }
4551
4552   set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
4553   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
4554   set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
4555   set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
4556   set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
4557
4558   set_gdbarch_register_name (gdbarch, sh_register_name);
4559   set_gdbarch_register_virtual_type (gdbarch, sh_register_virtual_type);
4560
4561   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
4562   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
4563   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
4564   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
4565   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
4566   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
4567
4568   set_gdbarch_call_dummy_length (gdbarch, 0);
4569   set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
4570   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1); /*???*/
4571   set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
4572   set_gdbarch_call_dummy_start_offset (gdbarch, 0);
4573   set_gdbarch_call_dummy_words (gdbarch, sh_call_dummy_words);
4574   set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (sh_call_dummy_words));
4575   set_gdbarch_call_dummy_p (gdbarch, 1);
4576   set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
4577   set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
4578   set_gdbarch_coerce_float_to_double (gdbarch,
4579                                       sh_coerce_float_to_double);
4580
4581   set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
4582   set_gdbarch_push_return_address (gdbarch, sh_push_return_address);
4583
4584   set_gdbarch_deprecated_store_return_value (gdbarch, sh_store_return_value);
4585   set_gdbarch_skip_prologue (gdbarch, sh_skip_prologue);
4586   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
4587   set_gdbarch_decr_pc_after_break (gdbarch, 0);
4588   set_gdbarch_function_start_offset (gdbarch, 0);
4589
4590   set_gdbarch_frame_args_skip (gdbarch, 0);
4591   set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue);
4592   set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
4593   set_gdbarch_frame_saved_pc (gdbarch, sh_frame_saved_pc);
4594   set_gdbarch_saved_pc_after_call (gdbarch, sh_saved_pc_after_call);
4595   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
4596   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
4597
4598   /* Hook in ABI-specific overrides, if they have been registered.
4599
4600      FIXME: if the ABI is unknown, this is probably an embedded target,
4601      so we should not warn about this situation.  */
4602   gdbarch_init_osabi (info, gdbarch, osabi);
4603
4604   return gdbarch;
4605 }
4606
4607 static void
4608 sh_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
4609 {
4610   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
4611
4612   if (tdep == NULL)
4613     return;
4614
4615   fprintf_unfiltered (file, "sh_dump_tdep: OS ABI = %s\n",
4616                       gdbarch_osabi_name (tdep->osabi));
4617 }
4618
4619 void
4620 _initialize_sh_tdep (void)
4621 {
4622   struct cmd_list_element *c;
4623
4624   gdbarch_register (bfd_arch_sh, sh_gdbarch_init, sh_dump_tdep);
4625
4626   add_com ("regs", class_vars, sh_show_regs_command, "Print all registers");
4627 }