gdb/sh64-tdep.c

   1 /* Target-dependent code for Renesas Super-H, for GDB.
   2    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   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"
  37 #include "gdb_string.h"
  38 #include "arch-utils.h"
  39 #include "floatformat.h"
  40 #include "regcache.h"
  41 #include "doublest.h"
  42 #include "osabi.h"
  43
  44 #include "elf-bfd.h"
  45 #include "solib-svr4.h"
  46
  47 /* sh flags */
  48 #include "elf/sh.h"
  49 /* registers numbers shared with the simulator */
  50 #include "gdb/sim-sh.h"
  51
  52 /* Information that is dependent on the processor variant.  */
  53 enum sh_abi
  54   {
  55     SH_ABI_UNKNOWN,
  56     SH_ABI_32,
  57     SH_ABI_64
  58   };
  59
  60 struct gdbarch_tdep
  61   {
  62     enum sh_abi sh_abi;
  63   };
  64
  65 /* Registers of SH5 */
  66 enum
  67   {
  68     R0_REGNUM = 0,
  69     DEFAULT_RETURN_REGNUM = 2,
  70     STRUCT_RETURN_REGNUM = 2,
  71     ARG0_REGNUM = 2,
  72     ARGLAST_REGNUM = 9,
  73     FLOAT_ARGLAST_REGNUM = 11,
  74     PR_REGNUM = 18,
  75     SR_REGNUM = 65,
  76     DR0_REGNUM = 141,
  77     DR_LAST_REGNUM = 172,
  78     /* FPP stands for Floating Point Pair, to avoid confusion with
  79        GDB's FP0_REGNUM, which is the number of the first Floating
  80        point register. Unfortunately on the sh5, the floating point
  81        registers are called FR, and the floating point pairs are called FP.  */
  82     FPP0_REGNUM = 173,
  83     FPP_LAST_REGNUM = 204,
  84     FV0_REGNUM = 205,
  85     FV_LAST_REGNUM = 220,
  86     R0_C_REGNUM = 221,
  87     R_LAST_C_REGNUM = 236,
  88     PC_C_REGNUM = 237,
  89     GBR_C_REGNUM = 238,
  90     MACH_C_REGNUM = 239,
  91     MACL_C_REGNUM = 240,
  92     PR_C_REGNUM = 241,
  93     T_C_REGNUM = 242,
  94     FPSCR_C_REGNUM = 243,
  95     FPUL_C_REGNUM = 244,
  96     FP0_C_REGNUM = 245,
  97     FP_LAST_C_REGNUM = 260,
  98     DR0_C_REGNUM = 261,
  99     DR_LAST_C_REGNUM = 268,
 100     FV0_C_REGNUM = 269,
 101     FV_LAST_C_REGNUM = 272,
 102     FPSCR_REGNUM = SIM_SH64_FPCSR_REGNUM,
 103     SSR_REGNUM = SIM_SH64_SSR_REGNUM,
 104     SPC_REGNUM = SIM_SH64_SPC_REGNUM,
 105     TR7_REGNUM = SIM_SH64_TR0_REGNUM + 7,
 106     FP_LAST_REGNUM = SIM_SH64_FR0_REGNUM + SIM_SH64_NR_FP_REGS - 1
 107   };
 108
 109
 110 /* Define other aspects of the stack frame.
 111    we keep a copy of the worked out return pc lying around, since it
 112    is a useful bit of info */
 113
 114 struct frame_extra_info
 115 {
 116   CORE_ADDR return_pc;
 117   int leaf_function;
 118   int f_offset;
 119 };
 120
 121 static const char *
 122 sh64_register_name (int reg_nr)
 123 {
 124   static char *register_names[] =
 125   {
 126     /* SH MEDIA MODE (ISA 32) */
 127     /* general registers (64-bit) 0-63 */
 128     "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 129     "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 130     "r16",  "r17",  "r18",  "r19",  "r20",  "r21",  "r22",  "r23",
 131     "r24",  "r25",  "r26",  "r27",  "r28",  "r29",  "r30",  "r31",
 132     "r32",  "r33",  "r34",  "r35",  "r36",  "r37",  "r38",  "r39",
 133     "r40",  "r41",  "r42",  "r43",  "r44",  "r45",  "r46",  "r47",
 134     "r48",  "r49",  "r50",  "r51",  "r52",  "r53",  "r54",  "r55",
 135     "r56",  "r57",  "r58",  "r59",  "r60",  "r61",  "r62",  "r63",
 136
 137     /* pc (64-bit) 64 */
 138     "pc",
 139
 140     /* status reg., saved status reg., saved pc reg. (64-bit) 65-67 */
 141     "sr",  "ssr",  "spc",
 142
 143     /* target registers (64-bit) 68-75*/
 144     "tr0",  "tr1",  "tr2",  "tr3",  "tr4",  "tr5",  "tr6",  "tr7",
 145
 146     /* floating point state control register (32-bit) 76 */
 147     "fpscr",
 148
 149     /* single precision floating point registers (32-bit) 77-140*/
 150     "fr0",  "fr1",  "fr2",  "fr3",  "fr4",  "fr5",  "fr6",  "fr7",
 151     "fr8",  "fr9",  "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 152     "fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23",
 153     "fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31",
 154     "fr32", "fr33", "fr34", "fr35", "fr36", "fr37", "fr38", "fr39",
 155     "fr40", "fr41", "fr42", "fr43", "fr44", "fr45", "fr46", "fr47",
 156     "fr48", "fr49", "fr50", "fr51", "fr52", "fr53", "fr54", "fr55",
 157     "fr56", "fr57", "fr58", "fr59", "fr60", "fr61", "fr62", "fr63",
 158
 159     /* double precision registers (pseudo) 141-172 */
 160     "dr0",  "dr2",  "dr4",  "dr6",  "dr8",  "dr10", "dr12", "dr14",
 161     "dr16", "dr18", "dr20", "dr22", "dr24", "dr26", "dr28", "dr30",
 162     "dr32", "dr34", "dr36", "dr38", "dr40", "dr42", "dr44", "dr46",
 163     "dr48", "dr50", "dr52", "dr54", "dr56", "dr58", "dr60", "dr62",
 164
 165     /* floating point pairs (pseudo) 173-204*/
 166     "fp0",  "fp2",  "fp4",  "fp6",  "fp8",  "fp10", "fp12", "fp14",
 167     "fp16", "fp18", "fp20", "fp22", "fp24", "fp26", "fp28", "fp30",
 168     "fp32", "fp34", "fp36", "fp38", "fp40", "fp42", "fp44", "fp46",
 169     "fp48", "fp50", "fp52", "fp54", "fp56", "fp58", "fp60", "fp62",
 170
 171     /* floating point vectors (4 floating point regs) (pseudo) 205-220*/
 172     "fv0",  "fv4",  "fv8",  "fv12", "fv16", "fv20", "fv24", "fv28",
 173     "fv32", "fv36", "fv40", "fv44", "fv48", "fv52", "fv56", "fv60",
 174
 175     /* SH COMPACT MODE (ISA 16) (all pseudo) 221-272*/
 176     "r0_c", "r1_c", "r2_c",  "r3_c",  "r4_c",  "r5_c",  "r6_c",  "r7_c",
 177     "r8_c", "r9_c", "r10_c", "r11_c", "r12_c", "r13_c", "r14_c", "r15_c",
 178     "pc_c",
 179     "gbr_c", "mach_c", "macl_c", "pr_c", "t_c",
 180     "fpscr_c", "fpul_c",
 181     "fr0_c", "fr1_c", "fr2_c",  "fr3_c",  "fr4_c",  "fr5_c",  "fr6_c",  "fr7_c",
 182     "fr8_c", "fr9_c", "fr10_c", "fr11_c", "fr12_c", "fr13_c", "fr14_c", "fr15_c",
 183     "dr0_c", "dr2_c", "dr4_c",  "dr6_c",  "dr8_c",  "dr10_c", "dr12_c", "dr14_c",
 184     "fv0_c", "fv4_c", "fv8_c",  "fv12_c",
 185     /* FIXME!!!! XF0 XF15, XD0 XD14 ?????*/
 186   };
 187
 188   if (reg_nr < 0)
 189     return NULL;
 190   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 191     return NULL;
 192   return register_names[reg_nr];
 193 }
 194
 195 #define NUM_PSEUDO_REGS_SH_MEDIA 80
 196 #define NUM_PSEUDO_REGS_SH_COMPACT 51
 197
 198 /* Macros and functions for setting and testing a bit in a minimal
 199    symbol that marks it as 32-bit function.  The MSB of the minimal
 200    symbol's "info" field is used for this purpose.
 201
 202    ELF_MAKE_MSYMBOL_SPECIAL
 203    tests whether an ELF symbol is "special", i.e. refers
 204    to a 32-bit function, and sets a "special" bit in a
 205    minimal symbol to mark it as a 32-bit function
 206    MSYMBOL_IS_SPECIAL   tests the "special" bit in a minimal symbol  */
 207
 208 #define MSYMBOL_IS_SPECIAL(msym) \
 209   (((long) MSYMBOL_INFO (msym) & 0x80000000) != 0)
 210
 211 static void
 212 sh64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
 213 {
 214   if (msym == NULL)
 215     return;
 216
 217   if (((elf_symbol_type *)(sym))->internal_elf_sym.st_other == STO_SH5_ISA32)
 218     {
 219       MSYMBOL_INFO (msym) = (char *) (((long) MSYMBOL_INFO (msym)) | 0x80000000);
 220       SYMBOL_VALUE_ADDRESS (msym) |= 1;
 221     }
 222 }
 223
 224 /* ISA32 (shmedia) function addresses are odd (bit 0 is set).  Here
 225    are some macros to test, set, or clear bit 0 of addresses.  */
 226 #define IS_ISA32_ADDR(addr)      ((addr) & 1)
 227 #define MAKE_ISA32_ADDR(addr)    ((addr) | 1)
 228 #define UNMAKE_ISA32_ADDR(addr)  ((addr) & ~1)
 229
 230 static int
 231 pc_is_isa32 (bfd_vma memaddr)
 232 {
 233   struct minimal_symbol *sym;
 234
 235   /* If bit 0 of the address is set, assume this is a
 236      ISA32 (shmedia) address.  */
 237   if (IS_ISA32_ADDR (memaddr))
 238     return 1;
 239
 240   /* A flag indicating that this is a ISA32 function is stored by elfread.c in
 241      the high bit of the info field.  Use this to decide if the function is
 242      ISA16 or ISA32.  */
 243   sym = lookup_minimal_symbol_by_pc (memaddr);
 244   if (sym)
 245     return MSYMBOL_IS_SPECIAL (sym);
 246   else
 247     return 0;
 248 }
 249
 250 static const unsigned char *
 251 sh64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 252 {
 253   /* The BRK instruction for shmedia is
 254      01101111 11110101 11111111 11110000
 255      which translates in big endian mode to 0x6f, 0xf5, 0xff, 0xf0
 256      and in little endian mode to 0xf0, 0xff, 0xf5, 0x6f */
 257
 258   /* The BRK instruction for shcompact is
 259      00000000 00111011
 260      which translates in big endian mode to 0x0, 0x3b
 261      and in little endian mode to 0x3b, 0x0*/
 262
 263   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 264     {
 265       if (pc_is_isa32 (*pcptr))
 266         {
 267           static unsigned char big_breakpoint_media[] = {0x6f, 0xf5, 0xff, 0xf0};
 268           *pcptr = UNMAKE_ISA32_ADDR (*pcptr);
 269           *lenptr = sizeof (big_breakpoint_media);
 270           return big_breakpoint_media;
 271         }
 272       else
 273         {
 274           static unsigned char big_breakpoint_compact[] = {0x0, 0x3b};
 275           *lenptr = sizeof (big_breakpoint_compact);
 276           return big_breakpoint_compact;
 277         }
 278     }
 279   else
 280     {
 281       if (pc_is_isa32 (*pcptr))
 282         {
 283           static unsigned char little_breakpoint_media[] = {0xf0, 0xff, 0xf5, 0x6f};
 284           *pcptr = UNMAKE_ISA32_ADDR (*pcptr);
 285           *lenptr = sizeof (little_breakpoint_media);
 286           return little_breakpoint_media;
 287         }
 288       else
 289         {
 290           static unsigned char little_breakpoint_compact[] = {0x3b, 0x0};
 291           *lenptr = sizeof (little_breakpoint_compact);
 292           return little_breakpoint_compact;
 293         }
 294     }
 295 }
 296
 297 /* Prologue looks like
 298    [mov.l       <regs>,@-r15]...
 299    [sts.l       pr,@-r15]
 300    [mov.l       r14,@-r15]
 301    [mov         r15,r14]
 302
 303    Actually it can be more complicated than this.  For instance, with
 304    newer gcc's:
 305
 306    mov.l   r14,@-r15
 307    add     #-12,r15
 308    mov     r15,r14
 309    mov     r4,r1
 310    mov     r5,r2
 311    mov.l   r6,@(4,r14)
 312    mov.l   r7,@(8,r14)
 313    mov.b   r1,@r14
 314    mov     r14,r1
 315    mov     r14,r1
 316    add     #2,r1
 317    mov.w   r2,@r1
 318
 319  */
 320
 321 /* PTABS/L Rn, TRa       0110101111110001nnnnnnl00aaa0000
 322    with l=1 and n = 18   0110101111110001010010100aaa0000 */
 323 #define IS_PTABSL_R18(x)  (((x) & 0xffffff8f) == 0x6bf14a00)
 324
 325 /* STS.L PR,@-r0   0100000000100010
 326    r0-4-->r0, PR-->(r0) */
 327 #define IS_STS_R0(x)            ((x) == 0x4022)
 328
 329 /* STS PR, Rm      0000mmmm00101010
 330    PR-->Rm */
 331 #define IS_STS_PR(x)            (((x) & 0xf0ff) == 0x2a)
 332
 333 /* MOV.L Rm,@(disp,r15)  00011111mmmmdddd
 334    Rm-->(dispx4+r15) */
 335 #define IS_MOV_TO_R15(x)              (((x) & 0xff00) == 0x1f00)
 336
 337 /* MOV.L R14,@(disp,r15)  000111111110dddd
 338    R14-->(dispx4+r15) */
 339 #define IS_MOV_R14(x)              (((x) & 0xfff0) == 0x1fe0)
 340
 341 /* ST.Q R14, disp, R18    101011001110dddddddddd0100100000
 342    R18-->(dispx8+R14) */
 343 #define IS_STQ_R18_R14(x)          (((x) & 0xfff003ff) == 0xace00120)
 344
 345 /* ST.Q R15, disp, R18    101011001111dddddddddd0100100000
 346    R18-->(dispx8+R15) */
 347 #define IS_STQ_R18_R15(x)          (((x) & 0xfff003ff) == 0xacf00120)
 348
 349 /* ST.L R15, disp, R18    101010001111dddddddddd0100100000
 350    R18-->(dispx4+R15) */
 351 #define IS_STL_R18_R15(x)          (((x) & 0xfff003ff) == 0xa8f00120)
 352
 353 /* ST.Q R15, disp, R14    1010 1100 1111 dddd dddd dd00 1110 0000
 354    R14-->(dispx8+R15) */
 355 #define IS_STQ_R14_R15(x)          (((x) & 0xfff003ff) == 0xacf000e0)
 356
 357 /* ST.L R15, disp, R14    1010 1000 1111 dddd dddd dd00 1110 0000
 358    R14-->(dispx4+R15) */
 359 #define IS_STL_R14_R15(x)          (((x) & 0xfff003ff) == 0xa8f000e0)
 360
 361 /* ADDI.L R15,imm,R15     1101 0100 1111 ssss ssss ss00 1111 0000
 362    R15 + imm --> R15 */
 363 #define IS_ADDIL_SP_MEDIA(x)         (((x) & 0xfff003ff) == 0xd4f000f0)
 364
 365 /* ADDI R15,imm,R15     1101 0000 1111 ssss ssss ss00 1111 0000
 366    R15 + imm --> R15 */
 367 #define IS_ADDI_SP_MEDIA(x)         (((x) & 0xfff003ff) == 0xd0f000f0)
 368
 369 /* ADD.L R15,R63,R14    0000 0000 1111 1000 1111 1100 1110 0000
 370    R15 + R63 --> R14 */
 371 #define IS_ADDL_SP_FP_MEDIA(x)          ((x) == 0x00f8fce0)
 372
 373 /* ADD R15,R63,R14    0000 0000 1111 1001 1111 1100 1110 0000
 374    R15 + R63 --> R14 */
 375 #define IS_ADD_SP_FP_MEDIA(x)   ((x) == 0x00f9fce0)
 376
 377 #define IS_MOV_SP_FP_MEDIA(x)   (IS_ADDL_SP_FP_MEDIA(x) || IS_ADD_SP_FP_MEDIA(x))
 378
 379 /* MOV #imm, R0    1110 0000 ssss ssss
 380    #imm-->R0 */
 381 #define IS_MOV_R0(x)            (((x) & 0xff00) == 0xe000)
 382
 383 /* MOV.L @(disp,PC), R0    1101 0000 iiii iiii  */
 384 #define IS_MOVL_R0(x)           (((x) & 0xff00) == 0xd000)
 385
 386 /* ADD r15,r0      0011 0000 1111 1100
 387    r15+r0-->r0 */
 388 #define IS_ADD_SP_R0(x)         ((x) == 0x30fc)
 389
 390 /* MOV.L R14 @-R0  0010 0000 1110 0110
 391    R14-->(R0-4), R0-4-->R0 */
 392 #define IS_MOV_R14_R0(x)        ((x) == 0x20e6)
 393
 394 /* ADD Rm,R63,Rn  Rm+R63-->Rn  0000 00mm mmmm 1001 1111 11nn nnnn 0000
 395    where Rm is one of r2-r9 which are the argument registers.  */
 396 /* FIXME: Recognize the float and double register moves too! */
 397 #define IS_MEDIA_IND_ARG_MOV(x) \
 398 ((((x) & 0xfc0ffc0f) == 0x0009fc00) && (((x) & 0x03f00000) >= 0x00200000 && ((x) & 0x03f00000) <= 0x00900000))
 399
 400 /* ST.Q Rn,0,Rm  Rm-->Rn+0  1010 11nn nnnn 0000 0000 00mm mmmm 0000
 401    or ST.L Rn,0,Rm  Rm-->Rn+0  1010 10nn nnnn 0000 0000 00mm mmmm 0000
 402    where Rm is one of r2-r9 which are the argument registers.  */
 403 #define IS_MEDIA_ARG_MOV(x) \
 404 (((((x) & 0xfc0ffc0f) == 0xac000000) || (((x) & 0xfc0ffc0f) == 0xa8000000)) \
 405    && (((x) & 0x000003f0) >= 0x00000020 && ((x) & 0x000003f0) <= 0x00000090))
 406
 407 /* ST.B R14,0,Rn     Rn-->(R14+0) 1010 0000 1110 0000 0000 00nn nnnn 0000*/
 408 /* ST.W R14,0,Rn     Rn-->(R14+0) 1010 0100 1110 0000 0000 00nn nnnn 0000*/
 409 /* ST.L R14,0,Rn     Rn-->(R14+0) 1010 1000 1110 0000 0000 00nn nnnn 0000*/
 410 /* FST.S R14,0,FRn   Rn-->(R14+0) 1011 0100 1110 0000 0000 00nn nnnn 0000*/
 411 /* FST.D R14,0,DRn   Rn-->(R14+0) 1011 1100 1110 0000 0000 00nn nnnn 0000*/
 412 #define IS_MEDIA_MOV_TO_R14(x)  \
 413 ((((x) & 0xfffffc0f) == 0xa0e00000) \
 414 || (((x) & 0xfffffc0f) == 0xa4e00000) \
 415 || (((x) & 0xfffffc0f) == 0xa8e00000) \
 416 || (((x) & 0xfffffc0f) == 0xb4e00000) \
 417 || (((x) & 0xfffffc0f) == 0xbce00000))
 418
 419 /* MOV Rm, Rn  Rm-->Rn 0110 nnnn mmmm 0011
 420    where Rm is r2-r9 */
 421 #define IS_COMPACT_IND_ARG_MOV(x) \
 422 ((((x) & 0xf00f) == 0x6003) && (((x) & 0x00f0) >= 0x0020) && (((x) & 0x00f0) <= 0x0090))
 423
 424 /* compact direct arg move!
 425    MOV.L Rn, @r14     0010 1110 mmmm 0010 */
 426 #define IS_COMPACT_ARG_MOV(x) \
 427 (((((x) & 0xff0f) == 0x2e02) && (((x) & 0x00f0) >= 0x0020) && ((x) & 0x00f0) <= 0x0090))
 428
 429 /* MOV.B Rm, @R14     0010 1110 mmmm 0000
 430    MOV.W Rm, @R14     0010 1110 mmmm 0001 */
 431 #define IS_COMPACT_MOV_TO_R14(x) \
 432 ((((x) & 0xff0f) == 0x2e00) || (((x) & 0xff0f) == 0x2e01))
 433
 434 #define IS_JSR_R0(x)           ((x) == 0x400b)
 435 #define IS_NOP(x)              ((x) == 0x0009)
 436
 437
 438 /* MOV r15,r14     0110111011110011
 439    r15-->r14  */
 440 #define IS_MOV_SP_FP(x)         ((x) == 0x6ef3)
 441
 442 /* ADD #imm,r15    01111111iiiiiiii
 443    r15+imm-->r15 */
 444 #define IS_ADD_SP(x)            (((x) & 0xff00) == 0x7f00)
 445
 446 /* Skip any prologue before the guts of a function */
 447
 448 /* Skip the prologue using the debug information.  If this fails we'll
 449    fall back on the 'guess' method below.  */
 450 static CORE_ADDR
 451 after_prologue (CORE_ADDR pc)
 452 {
 453   struct symtab_and_line sal;
 454   CORE_ADDR func_addr, func_end;
 455
 456   /* If we can not find the symbol in the partial symbol table, then
 457      there is no hope we can determine the function's start address
 458      with this code.  */
 459   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 460     return 0;
 461
 462   /* Get the line associated with FUNC_ADDR.  */
 463   sal = find_pc_line (func_addr, 0);
 464
 465   /* There are only two cases to consider.  First, the end of the source line
 466      is within the function bounds.  In that case we return the end of the
 467      source line.  Second is the end of the source line extends beyond the
 468      bounds of the current function.  We need to use the slow code to
 469      examine instructions in that case.  */
 470   if (sal.end < func_end)
 471     return sal.end;
 472   else
 473     return 0;
 474 }
 475
 476 static CORE_ADDR
 477 look_for_args_moves (CORE_ADDR start_pc, int media_mode)
 478 {
 479   CORE_ADDR here, end;
 480   int w;
 481   int insn_size = (media_mode ? 4 : 2);
 482
 483   for (here = start_pc, end = start_pc + (insn_size * 28); here < end;)
 484     {
 485       if (media_mode)
 486         {
 487           w = read_memory_integer (UNMAKE_ISA32_ADDR (here), insn_size);
 488           here += insn_size;
 489           if (IS_MEDIA_IND_ARG_MOV (w))
 490             {
 491               /* This must be followed by a store to r14, so the argument
 492                  is where the debug info says it is. This can happen after
 493                  the SP has been saved, unfortunately.  */
 494
 495               int next_insn = read_memory_integer (UNMAKE_ISA32_ADDR (here),
 496                                                    insn_size);
 497               here += insn_size;
 498               if (IS_MEDIA_MOV_TO_R14 (next_insn))
 499                 start_pc = here;
 500             }
 501           else if (IS_MEDIA_ARG_MOV (w))
 502             {
 503               /* These instructions store directly the argument in r14.  */
 504               start_pc = here;
 505             }
 506           else
 507             break;
 508         }
 509       else
 510         {
 511           w = read_memory_integer (here, insn_size);
 512           w = w & 0xffff;
 513           here += insn_size;
 514           if (IS_COMPACT_IND_ARG_MOV (w))
 515             {
 516               /* This must be followed by a store to r14, so the argument
 517                  is where the debug info says it is. This can happen after
 518                  the SP has been saved, unfortunately.  */
 519
 520               int next_insn = 0xffff & read_memory_integer (here, insn_size);
 521               here += insn_size;
 522               if (IS_COMPACT_MOV_TO_R14 (next_insn))
 523                 start_pc = here;
 524             }
 525           else if (IS_COMPACT_ARG_MOV (w))
 526             {
 527               /* These instructions store directly the argument in r14.  */
 528               start_pc = here;
 529             }
 530           else if (IS_MOVL_R0 (w))
 531             {
 532               /* There is a function that gcc calls to get the arguments
 533                  passed correctly to the function. Only after this
 534                  function call the arguments will be found at the place
 535                  where they are supposed to be. This happens in case the
 536                  argument has to be stored into a 64-bit register (for
 537                  instance doubles, long longs).  SHcompact doesn't have
 538                  access to the full 64-bits, so we store the register in
 539                  stack slot and store the address of the stack slot in
 540                  the register, then do a call through a wrapper that
 541                  loads the memory value into the register.  A SHcompact
 542                  callee calls an argument decoder
 543                  (GCC_shcompact_incoming_args) that stores the 64-bit
 544                  value in a stack slot and stores the address of the
 545                  stack slot in the register.  GCC thinks the argument is
 546                  just passed by transparent reference, but this is only
 547                  true after the argument decoder is called. Such a call
 548                  needs to be considered part of the prologue.  */
 549
 550               /* This must be followed by a JSR @r0 instruction and by
 551                  a NOP instruction. After these, the prologue is over!  */
 552
 553               int next_insn = 0xffff & read_memory_integer (here, insn_size);
 554               here += insn_size;
 555               if (IS_JSR_R0 (next_insn))
 556                 {
 557                   next_insn = 0xffff & read_memory_integer (here, insn_size);
 558                   here += insn_size;
 559
 560                   if (IS_NOP (next_insn))
 561                     start_pc = here;
 562                 }
 563             }
 564           else
 565             break;
 566         }
 567     }
 568
 569   return start_pc;
 570 }
 571
 572 static CORE_ADDR
 573 sh64_skip_prologue_hard_way (CORE_ADDR start_pc)
 574 {
 575   CORE_ADDR here, end;
 576   int updated_fp = 0;
 577   int insn_size = 4;
 578   int media_mode = 1;
 579
 580   if (!start_pc)
 581     return 0;
 582
 583   if (pc_is_isa32 (start_pc) == 0)
 584     {
 585       insn_size = 2;
 586       media_mode = 0;
 587     }
 588
 589   for (here = start_pc, end = start_pc + (insn_size * 28); here < end;)
 590     {
 591
 592       if (media_mode)
 593         {
 594           int w = read_memory_integer (UNMAKE_ISA32_ADDR (here), insn_size);
 595           here += insn_size;
 596           if (IS_STQ_R18_R14 (w) || IS_STQ_R18_R15 (w) || IS_STQ_R14_R15 (w)
 597               || IS_STL_R14_R15 (w) || IS_STL_R18_R15 (w)
 598               || IS_ADDIL_SP_MEDIA (w) || IS_ADDI_SP_MEDIA (w) || IS_PTABSL_R18 (w))
 599             {
 600               start_pc = here;
 601             }
 602           else if (IS_MOV_SP_FP (w) || IS_MOV_SP_FP_MEDIA(w))
 603             {
 604               start_pc = here;
 605               updated_fp = 1;
 606             }
 607           else
 608             if (updated_fp)
 609               {
 610                 /* Don't bail out yet, we may have arguments stored in
 611                    registers here, according to the debug info, so that
 612                    gdb can print the frames correctly.  */
 613                 start_pc = look_for_args_moves (here - insn_size, media_mode);
 614                 break;
 615               }
 616         }
 617       else
 618         {
 619           int w = 0xffff & read_memory_integer (here, insn_size);
 620           here += insn_size;
 621
 622           if (IS_STS_R0 (w) || IS_STS_PR (w)
 623               || IS_MOV_TO_R15 (w) || IS_MOV_R14 (w)
 624               || IS_MOV_R0 (w) || IS_ADD_SP_R0 (w) || IS_MOV_R14_R0 (w))
 625             {
 626               start_pc = here;
 627             }
 628           else if (IS_MOV_SP_FP (w))
 629             {
 630               start_pc = here;
 631               updated_fp = 1;
 632             }
 633           else
 634             if (updated_fp)
 635               {
 636                 /* Don't bail out yet, we may have arguments stored in
 637                    registers here, according to the debug info, so that
 638                    gdb can print the frames correctly.  */
 639                 start_pc = look_for_args_moves (here - insn_size, media_mode);
 640                 break;
 641               }
 642         }
 643     }
 644
 645   return start_pc;
 646 }
 647
 648 static CORE_ADDR
 649 sh_skip_prologue (CORE_ADDR pc)
 650 {
 651   CORE_ADDR post_prologue_pc;
 652
 653   /* See if we can determine the end of the prologue via the symbol table.
 654      If so, then return either PC, or the PC after the prologue, whichever
 655      is greater.  */
 656   post_prologue_pc = after_prologue (pc);
 657
 658   /* If after_prologue returned a useful address, then use it.  Else
 659      fall back on the instruction skipping code.  */
 660   if (post_prologue_pc != 0)
 661     return max (pc, post_prologue_pc);
 662   else
 663     return sh64_skip_prologue_hard_way (pc);
 664 }
 665
 666 /* Immediately after a function call, return the saved pc.
 667    Can't always go through the frames for this because on some machines
 668    the new frame is not set up until the new function executes
 669    some instructions.
 670
 671    The return address is the value saved in the PR register + 4  */
 672 static CORE_ADDR
 673 sh_saved_pc_after_call (struct frame_info *frame)
 674 {
 675   return (ADDR_BITS_REMOVE (read_register (PR_REGNUM)));
 676 }
 677
 678 /* Should call_function allocate stack space for a struct return?  */
 679 static int
 680 sh64_use_struct_convention (int gcc_p, struct type *type)
 681 {
 682   return (TYPE_LENGTH (type) > 8);
 683 }
 684
 685 /* Store the address of the place in which to copy the structure the
 686    subroutine will return.  This is called from call_function.
 687
 688    We store structs through a pointer passed in R2 */
 689 static void
 690 sh64_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 691 {
 692   write_register (STRUCT_RETURN_REGNUM, (addr));
 693 }
 694
 695 /* Disassemble an instruction.  */
 696 static int
 697 gdb_print_insn_sh (bfd_vma memaddr, disassemble_info *info)
 698 {
 699   info->endian = TARGET_BYTE_ORDER;
 700   return print_insn_sh (memaddr, info);
 701 }
 702
 703 /* Given a register number RN as it appears in an assembly
 704    instruction, find the corresponding register number in the GDB
 705    scheme.  */
 706 static int
 707 translate_insn_rn (int rn, int media_mode)
 708 {
 709   /* FIXME: this assumes that the number rn is for a not pseudo
 710      register only.  */
 711   if (media_mode)
 712     return rn;
 713   else
 714     {
 715       /* These registers don't have a corresponding compact one.  */
 716       /* FIXME: This is probably not enough.  */
 717 #if 0
 718       if ((rn >= 16 && rn <= 63) || (rn >= 93 && rn <= 140))
 719         return rn;
 720 #endif
 721       if (rn >= 0 && rn <= R0_C_REGNUM)
 722         return R0_C_REGNUM + rn;
 723       else
 724         return rn;
 725     }
 726 }
 727
 728 /* Given a GDB frame, determine the address of the calling function's
 729    frame.  This will be used to create a new GDB frame struct, and
 730    then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC
 731    will be called for the new frame.
 732
 733    For us, the frame address is its stack pointer value, so we look up
 734    the function prologue to determine the caller's sp value, and return it.  */
 735 static CORE_ADDR
 736 sh64_frame_chain (struct frame_info *frame)
 737 {
 738   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
 739                                    get_frame_base (frame),
 740                                    get_frame_base (frame)))
 741     return get_frame_base (frame);    /* dummy frame same as caller's frame */
 742   if (get_frame_pc (frame)
 743       && !deprecated_inside_entry_file (get_frame_pc (frame)))
 744     {
 745       int media_mode = pc_is_isa32 (get_frame_pc (frame));
 746       int size;
 747       if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
 748         size = 4;
 749       else
 750         size = register_size (current_gdbarch,
 751                               translate_insn_rn (DEPRECATED_FP_REGNUM,
 752                                                  media_mode));
 753       return read_memory_integer (get_frame_base (frame)
 754                                   + get_frame_extra_info (frame)->f_offset,
 755                                   size);
 756     }
 757   else
 758     return 0;
 759 }
 760
 761 static CORE_ADDR
 762 sh64_get_saved_pr (struct frame_info *fi, int pr_regnum)
 763 {
 764   int media_mode = 0;
 765
 766   for (; fi; fi = get_next_frame (fi))
 767     if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
 768                                      get_frame_base (fi)))
 769       /* When the caller requests PR from the dummy frame, we return
 770          PC because that's where the previous routine appears to have
 771          done a call from.  */
 772       return deprecated_read_register_dummy (get_frame_pc (fi),
 773                                              get_frame_base (fi), pr_regnum);
 774     else
 775       {
 776         DEPRECATED_FRAME_INIT_SAVED_REGS (fi);
 777         if (!get_frame_pc (fi))
 778           return 0;
 779
 780         media_mode = pc_is_isa32 (get_frame_pc (fi));
 781
 782         if (deprecated_get_frame_saved_regs (fi)[pr_regnum] != 0)
 783           {
 784             int gdb_reg_num = translate_insn_rn (pr_regnum, media_mode);
 785             int size = ((gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32)
 786                         ? 4
 787                         : register_size (current_gdbarch, gdb_reg_num));
 788             return read_memory_integer (deprecated_get_frame_saved_regs (fi)[pr_regnum], size);
 789           }
 790       }
 791   return read_register (pr_regnum);
 792 }
 793
 794 /* For vectors of 4 floating point registers.  */
 795 static int
 796 fv_reg_base_num (int fv_regnum)
 797 {
 798   int fp_regnum;
 799
 800   fp_regnum = FP0_REGNUM +
 801     (fv_regnum - FV0_REGNUM) * 4;
 802   return fp_regnum;
 803 }
 804
 805 /* For double precision floating point registers, i.e 2 fp regs.*/
 806 static int
 807 dr_reg_base_num (int dr_regnum)
 808 {
 809   int fp_regnum;
 810
 811   fp_regnum = FP0_REGNUM +
 812     (dr_regnum - DR0_REGNUM) * 2;
 813   return fp_regnum;
 814 }
 815
 816 /* For pairs of floating point registers */
 817 static int
 818 fpp_reg_base_num (int fpp_regnum)
 819 {
 820   int fp_regnum;
 821
 822   fp_regnum = FP0_REGNUM +
 823     (fpp_regnum - FPP0_REGNUM) * 2;
 824   return fp_regnum;
 825 }
 826
 827 static int
 828 is_media_pseudo (int rn)
 829 {
 830   return (rn >= DR0_REGNUM && rn <= FV_LAST_REGNUM);
 831 }
 832
 833 static int
 834 sh64_get_gdb_regnum (int gcc_regnum, CORE_ADDR pc)
 835 {
 836   return translate_insn_rn (gcc_regnum, pc_is_isa32 (pc));
 837 }
 838
 839 static int
 840 sh64_media_reg_base_num (int reg_nr)
 841 {
 842   int base_regnum = -1;
 843
 844   if (reg_nr >= DR0_REGNUM
 845       && reg_nr <= DR_LAST_REGNUM)
 846     base_regnum = dr_reg_base_num (reg_nr);
 847
 848   else if (reg_nr >= FPP0_REGNUM
 849            && reg_nr <= FPP_LAST_REGNUM)
 850     base_regnum = fpp_reg_base_num (reg_nr);
 851
 852   else if (reg_nr >= FV0_REGNUM
 853            && reg_nr <= FV_LAST_REGNUM)
 854     base_regnum = fv_reg_base_num (reg_nr);
 855
 856   return base_regnum;
 857 }
 858
 859 /* *INDENT-OFF* */
 860 /*
 861     SH COMPACT MODE (ISA 16) (all pseudo) 221-272
 862        GDB_REGNUM  BASE_REGNUM
 863  r0_c       221      0
 864  r1_c       222      1
 865  r2_c       223      2
 866  r3_c       224      3
 867  r4_c       225      4
 868  r5_c       226      5
 869  r6_c       227      6
 870  r7_c       228      7
 871  r8_c       229      8
 872  r9_c       230      9
 873  r10_c      231      10
 874  r11_c      232      11
 875  r12_c      233      12
 876  r13_c      234      13
 877  r14_c      235      14
 878  r15_c      236      15
 879
 880  pc_c       237      64
 881  gbr_c      238      16
 882  mach_c     239      17
 883  macl_c     240      17
 884  pr_c       241      18
 885  t_c        242      19
 886  fpscr_c    243      76
 887  fpul_c     244      109
 888
 889  fr0_c      245      77
 890  fr1_c      246      78
 891  fr2_c      247      79
 892  fr3_c      248      80
 893  fr4_c      249      81
 894  fr5_c      250      82
 895  fr6_c      251      83
 896  fr7_c      252      84
 897  fr8_c      253      85
 898  fr9_c      254      86
 899  fr10_c     255      87
 900  fr11_c     256      88
 901  fr12_c     257      89
 902  fr13_c     258      90
 903  fr14_c     259      91
 904  fr15_c     260      92
 905
 906  dr0_c      261      77
 907  dr2_c      262      79
 908  dr4_c      263      81
 909  dr6_c      264      83
 910  dr8_c      265      85
 911  dr10_c     266      87
 912  dr12_c     267      89
 913  dr14_c     268      91
 914
 915  fv0_c      269      77
 916  fv4_c      270      81
 917  fv8_c      271      85
 918  fv12_c     272      91
 919 */
 920 /* *INDENT-ON* */
 921 static int
 922 sh64_compact_reg_base_num (int reg_nr)
 923 {
 924   int base_regnum = -1;
 925
 926   /* general register N maps to general register N */
 927   if (reg_nr >= R0_C_REGNUM
 928       && reg_nr <= R_LAST_C_REGNUM)
 929     base_regnum = reg_nr - R0_C_REGNUM;
 930
 931   /* floating point register N maps to floating point register N */
 932   else if (reg_nr >= FP0_C_REGNUM
 933             && reg_nr <= FP_LAST_C_REGNUM)
 934     base_regnum = reg_nr - FP0_C_REGNUM + FP0_REGNUM;
 935
 936   /* double prec register N maps to base regnum for double prec register N */
 937   else if (reg_nr >= DR0_C_REGNUM
 938             && reg_nr <= DR_LAST_C_REGNUM)
 939     base_regnum = dr_reg_base_num (DR0_REGNUM
 940                                    + reg_nr - DR0_C_REGNUM);
 941
 942   /* vector N maps to base regnum for vector register N */
 943   else if (reg_nr >= FV0_C_REGNUM
 944             && reg_nr <= FV_LAST_C_REGNUM)
 945     base_regnum = fv_reg_base_num (FV0_REGNUM
 946                                    + reg_nr - FV0_C_REGNUM);
 947
 948   else if (reg_nr == PC_C_REGNUM)
 949     base_regnum = PC_REGNUM;
 950
 951   else if (reg_nr == GBR_C_REGNUM)
 952     base_regnum = 16;
 953
 954   else if (reg_nr == MACH_C_REGNUM
 955            || reg_nr == MACL_C_REGNUM)
 956     base_regnum = 17;
 957
 958   else if (reg_nr == PR_C_REGNUM)
 959     base_regnum = 18;
 960
 961   else if (reg_nr == T_C_REGNUM)
 962     base_regnum = 19;
 963
 964   else if (reg_nr == FPSCR_C_REGNUM)
 965     base_regnum = FPSCR_REGNUM; /*???? this register is a mess.  */
 966
 967   else if (reg_nr == FPUL_C_REGNUM)
 968     base_regnum = FP0_REGNUM + 32;
 969
 970   return base_regnum;
 971 }
 972
 973 /* Given a register number RN (according to the gdb scheme) , return
 974    its corresponding architectural register.  In media mode, only a
 975    subset of the registers is pseudo registers. For compact mode, all
 976    the registers are pseudo.  */
 977 static int
 978 translate_rn_to_arch_reg_num (int rn, int media_mode)
 979 {
 980
 981   if (media_mode)
 982     {
 983       if (!is_media_pseudo (rn))
 984         return rn;
 985       else
 986         return sh64_media_reg_base_num (rn);
 987     }
 988   else
 989     /* All compact registers are pseudo.  */
 990     return sh64_compact_reg_base_num (rn);
 991 }
 992
 993 static int
 994 sign_extend (int value, int bits)
 995 {
 996   value = value & ((1 << bits) - 1);
 997   return (value & (1 << (bits - 1))
 998           ? value | (~((1 << bits) - 1))
 999           : value);
1000 }
1001
1002 static void
1003 sh64_nofp_frame_init_saved_regs (struct frame_info *fi)
1004 {
1005   int *where = (int *) alloca ((NUM_REGS + NUM_PSEUDO_REGS) * sizeof (int));
1006   int rn;
1007   int have_fp = 0;
1008   int fp_regnum;
1009   int sp_regnum;
1010   int depth;
1011   int pc;
1012   int opc;
1013   int insn;
1014   int r0_val = 0;
1015   int media_mode = 0;
1016   int insn_size;
1017   int gdb_register_number;
1018   int register_number;
1019   char *dummy_regs = deprecated_generic_find_dummy_frame (get_frame_pc (fi),
1020                                                           get_frame_base (fi));
1021   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1022
1023   if (deprecated_get_frame_saved_regs (fi) == NULL)
1024     frame_saved_regs_zalloc (fi);
1025   else
1026     memset (deprecated_get_frame_saved_regs (fi), 0, SIZEOF_FRAME_SAVED_REGS);
1027
1028   if (dummy_regs)
1029     {
1030       /* DANGER!  This is ONLY going to work if the char buffer format of
1031          the saved registers is byte-for-byte identical to the
1032          CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */
1033       memcpy (deprecated_get_frame_saved_regs (fi), dummy_regs, SIZEOF_FRAME_SAVED_REGS);
1034       return;
1035     }
1036
1037   get_frame_extra_info (fi)->leaf_function = 1;
1038   get_frame_extra_info (fi)->f_offset = 0;
1039
1040   for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++)
1041     where[rn] = -1;
1042
1043   depth = 0;
1044
1045   /* Loop around examining the prologue insns until we find something
1046      that does not appear to be part of the prologue.  But give up
1047      after 20 of them, since we're getting silly then.  */
1048
1049   pc = get_frame_func (fi);
1050   if (!pc)
1051     {
1052       deprecated_update_frame_pc_hack (fi, 0);
1053       return;
1054     }
1055
1056   if (pc_is_isa32 (pc))
1057     {
1058       media_mode = 1;
1059       insn_size = 4;
1060     }
1061   else
1062     {
1063       media_mode = 0;
1064       insn_size = 2;
1065     }
1066
1067  /* The frame pointer register is general register 14 in shmedia and
1068     shcompact modes. In sh compact it is a pseudo register.  Same goes
1069     for the stack pointer register, which is register 15.  */
1070   fp_regnum = translate_insn_rn (DEPRECATED_FP_REGNUM, media_mode);
1071   sp_regnum = translate_insn_rn (SP_REGNUM, media_mode);
1072
1073   for (opc = pc + (insn_size * 28); pc < opc; pc += insn_size)
1074     {
1075       insn = read_memory_integer (media_mode ? UNMAKE_ISA32_ADDR (pc) : pc,
1076                                   insn_size);
1077
1078       if (media_mode == 0)
1079         {
1080           if (IS_STS_PR (insn))
1081             {
1082               int next_insn = read_memory_integer (pc + insn_size, insn_size);
1083               if (IS_MOV_TO_R15 (next_insn))
1084                 {
1085                   int reg_nr = PR_C_REGNUM;
1086
1087                   where[reg_nr] = depth - ((((next_insn & 0xf) ^ 0x8) - 0x8) << 2);
1088                   get_frame_extra_info (fi)->leaf_function = 0;
1089                   pc += insn_size;
1090                 }
1091             }
1092           else if (IS_MOV_R14 (insn))
1093             {
1094               where[fp_regnum] = depth - ((((insn & 0xf) ^ 0x8) - 0x8) << 2);
1095             }
1096
1097           else if (IS_MOV_R0 (insn))
1098             {
1099               /* Put in R0 the offset from SP at which to store some
1100                  registers. We are interested in this value, because it
1101                  will tell us where the given registers are stored within
1102                  the frame.  */
1103               r0_val = ((insn & 0xff) ^ 0x80) - 0x80;
1104             }
1105           else if (IS_ADD_SP_R0 (insn))
1106             {
1107               /* This instruction still prepares r0, but we don't care.
1108                  We already have the offset in r0_val.  */
1109             }
1110           else if (IS_STS_R0 (insn))
1111             {
1112               /* Store PR at r0_val-4 from SP. Decrement r0 by 4*/
1113               int reg_nr = PR_C_REGNUM;
1114               where[reg_nr] = depth - (r0_val - 4);
1115               r0_val -= 4;
1116               get_frame_extra_info (fi)->leaf_function = 0;
1117             }
1118           else if (IS_MOV_R14_R0 (insn))
1119             {
1120               /* Store R14 at r0_val-4 from SP. Decrement r0 by 4 */
1121               where[fp_regnum] = depth - (r0_val - 4);
1122               r0_val -= 4;
1123             }
1124
1125           else if (IS_ADD_SP (insn))
1126             {
1127               depth -= ((insn & 0xff) ^ 0x80) - 0x80;
1128             }
1129           else if (IS_MOV_SP_FP (insn))
1130             break;
1131         }
1132       else
1133         {
1134           if (IS_ADDIL_SP_MEDIA (insn)
1135               || IS_ADDI_SP_MEDIA (insn))
1136             {
1137               depth -= sign_extend ((((insn & 0xffc00) ^ 0x80000) - 0x80000) >> 10, 9);
1138             }
1139
1140           else if (IS_STQ_R18_R15 (insn))
1141             {
1142               where[PR_REGNUM] =
1143                 depth - (sign_extend ((insn & 0xffc00) >> 10, 9) << 3);
1144               get_frame_extra_info (fi)->leaf_function = 0;
1145             }
1146
1147           else if (IS_STL_R18_R15 (insn))
1148             {
1149               where[PR_REGNUM] =
1150                 depth - (sign_extend ((insn & 0xffc00) >> 10, 9) << 2);
1151               get_frame_extra_info (fi)->leaf_function = 0;
1152             }
1153
1154           else if (IS_STQ_R14_R15 (insn))
1155             {
1156               where[fp_regnum] = depth - (sign_extend ((insn & 0xffc00) >> 10, 9) << 3);
1157             }
1158
1159           else if (IS_STL_R14_R15 (insn))
1160             {
1161               where[fp_regnum] = depth - (sign_extend ((insn & 0xffc00) >> 10, 9) << 2);
1162             }
1163
1164           else if (IS_MOV_SP_FP_MEDIA (insn))
1165             break;
1166         }
1167     }
1168
1169   /* Now we know how deep things are, we can work out their addresses.  */
1170   for (rn = 0; rn < NUM_REGS + NUM_PSEUDO_REGS; rn++)
1171     {
1172       register_number = translate_rn_to_arch_reg_num (rn, media_mode);
1173
1174       if (where[rn] >= 0)
1175         {
1176           if (rn == fp_regnum)
1177             have_fp = 1;
1178
1179           /* Watch out! saved_regs is only for the real registers, and
1180              doesn't include space for the pseudo registers.  */
1181           deprecated_get_frame_saved_regs (fi)[register_number]
1182             = get_frame_base (fi) - where[rn] + depth;
1183         }
1184       else
1185         deprecated_get_frame_saved_regs (fi)[register_number] = 0;
1186     }
1187
1188   if (have_fp)
1189     {
1190       /* SP_REGNUM is 15. For shmedia 15 is the real register. For
1191          shcompact 15 is the arch register corresponding to the pseudo
1192          register r15 which still is the SP register.  */
1193       /* The place on the stack where fp is stored contains the sp of
1194          the caller.  */
1195       /* Again, saved_registers contains only space for the real
1196          registers, so we store in DEPRECATED_FP_REGNUM position.  */
1197       int size;
1198       if (tdep->sh_abi == SH_ABI_32)
1199         size = 4;
1200       else
1201         size = register_size (current_gdbarch, fp_regnum);
1202       deprecated_get_frame_saved_regs (fi)[sp_regnum]
1203         = read_memory_integer (deprecated_get_frame_saved_regs (fi)[fp_regnum],
1204                                size);
1205     }
1206   else
1207     deprecated_get_frame_saved_regs (fi)[sp_regnum] = get_frame_base (fi);
1208
1209   get_frame_extra_info (fi)->f_offset = depth - where[fp_regnum];
1210 }
1211
1212 /* Initialize the extra info saved in a FRAME */
1213 static void
1214 sh64_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1215 {
1216   int media_mode = pc_is_isa32 (get_frame_pc (fi));
1217
1218   frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
1219
1220   if (get_next_frame (fi))
1221     deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
1222
1223   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
1224                                    get_frame_base (fi)))
1225     {
1226       /* We need to setup fi->frame here because call_function_by_hand
1227          gets it wrong by assuming it's always FP.  */
1228       deprecated_update_frame_base_hack (fi, deprecated_read_register_dummy (get_frame_pc (fi), get_frame_base (fi), SP_REGNUM));
1229       get_frame_extra_info (fi)->return_pc =
1230         deprecated_read_register_dummy (get_frame_pc (fi),
1231                                         get_frame_base (fi), PC_REGNUM);
1232       get_frame_extra_info (fi)->f_offset = -(DEPRECATED_CALL_DUMMY_LENGTH + 4);
1233       get_frame_extra_info (fi)->leaf_function = 0;
1234       return;
1235     }
1236   else
1237     {
1238       DEPRECATED_FRAME_INIT_SAVED_REGS (fi);
1239       get_frame_extra_info (fi)->return_pc =
1240         sh64_get_saved_pr (fi, PR_REGNUM);
1241     }
1242 }
1243
1244 static void
1245 sh64_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
1246                          struct frame_info *frame, int regnum,
1247                          enum lval_type *lval)
1248 {
1249   int media_mode;
1250   int live_regnum = regnum;
1251   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1252
1253   if (!target_has_registers)
1254     error ("No registers.");
1255
1256   /* Normal systems don't optimize out things with register numbers.  */
1257   if (optimized != NULL)
1258     *optimized = 0;
1259
1260   if (addrp)                    /* default assumption: not found in memory */
1261     *addrp = 0;
1262
1263   if (raw_buffer)
1264     memset (raw_buffer, 0, sizeof (raw_buffer));
1265
1266   /* We must do this here, before the following while loop changes
1267      frame, and makes it NULL. If this is a media register number,
1268      but we are in compact mode, it will become the corresponding
1269      compact pseudo register. If there is no corresponding compact
1270      pseudo-register what do we do?*/
1271   media_mode = pc_is_isa32 (get_frame_pc (frame));
1272   live_regnum = translate_insn_rn (regnum, media_mode);
1273
1274   /* Note: since the current frame's registers could only have been
1275      saved by frames INTERIOR TO the current frame, we skip examining
1276      the current frame itself: otherwise, we would be getting the
1277      previous frame's registers which were saved by the current frame.  */
1278
1279   while (frame && ((frame = get_next_frame (frame)) != NULL))
1280     {
1281       if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
1282                                        get_frame_base (frame),
1283                                        get_frame_base (frame)))
1284         {
1285           if (lval)             /* found it in a CALL_DUMMY frame */
1286             *lval = not_lval;
1287           if (raw_buffer)
1288             memcpy (raw_buffer,
1289                     (deprecated_generic_find_dummy_frame (get_frame_pc (frame), get_frame_base (frame))
1290                      + DEPRECATED_REGISTER_BYTE (regnum)),
1291                     register_size (current_gdbarch, regnum));
1292           return;
1293         }
1294
1295       DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
1296       if (deprecated_get_frame_saved_regs (frame) != NULL
1297           && deprecated_get_frame_saved_regs (frame)[regnum] != 0)
1298         {
1299           if (lval)             /* found it saved on the stack */
1300             *lval = lval_memory;
1301           if (regnum == SP_REGNUM)
1302             {
1303               if (raw_buffer)   /* SP register treated specially */
1304                 store_unsigned_integer (raw_buffer,
1305                                         register_size (current_gdbarch,
1306                                                        regnum),
1307                                         deprecated_get_frame_saved_regs (frame)[regnum]);
1308             }
1309           else
1310             { /* any other register */
1311
1312               if (addrp)
1313                 *addrp = deprecated_get_frame_saved_regs (frame)[regnum];
1314               if (raw_buffer)
1315                 {
1316                   int size;
1317                   if (tdep->sh_abi == SH_ABI_32
1318                       && (live_regnum == DEPRECATED_FP_REGNUM
1319                           || live_regnum == PR_REGNUM))
1320                     size = 4;
1321                   else
1322                     size = register_size (current_gdbarch, live_regnum);
1323                   if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
1324                     read_memory (deprecated_get_frame_saved_regs (frame)[regnum],
1325                                  raw_buffer, size);
1326                   else
1327                     read_memory (deprecated_get_frame_saved_regs (frame)[regnum],
1328                                  raw_buffer
1329                                  + register_size (current_gdbarch, live_regnum)
1330                                  - size,
1331                                  size);
1332                 }
1333             }
1334           return;
1335         }
1336     }
1337
1338   /* If we get thru the loop to this point, it means the register was
1339      not saved in any frame.  Return the actual live-register value.  */
1340
1341   if (lval)                     /* found it in a live register */
1342     *lval = lval_register;
1343   if (addrp)
1344     *addrp = DEPRECATED_REGISTER_BYTE (live_regnum);
1345   if (raw_buffer)
1346     deprecated_read_register_gen (live_regnum, raw_buffer);
1347 }
1348
1349 static CORE_ADDR
1350 sh64_extract_struct_value_address (char *regbuf)
1351 {
1352   return (extract_unsigned_integer ((regbuf + DEPRECATED_REGISTER_BYTE (STRUCT_RETURN_REGNUM)),
1353                                     register_size (current_gdbarch,
1354                                                    STRUCT_RETURN_REGNUM)));
1355 }
1356
1357 static CORE_ADDR
1358 sh_frame_saved_pc (struct frame_info *frame)
1359 {
1360   return (get_frame_extra_info (frame)->return_pc);
1361 }
1362
1363 /* Discard from the stack the innermost frame, restoring all saved registers.
1364    Used in the 'return' command.  */
1365 static void
1366 sh64_pop_frame (void)
1367 {
1368   struct frame_info *frame = get_current_frame ();
1369   CORE_ADDR fp;
1370   int regnum;
1371   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1372
1373   int media_mode = pc_is_isa32 (get_frame_pc (frame));
1374
1375   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
1376                                    get_frame_base (frame),
1377                                    get_frame_base (frame)))
1378     generic_pop_dummy_frame ();
1379   else
1380     {
1381       fp = get_frame_base (frame);
1382       DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
1383
1384       /* Copy regs from where they were saved in the frame */
1385       for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
1386         if (deprecated_get_frame_saved_regs (frame)[regnum])
1387           {
1388             int size;
1389             if (tdep->sh_abi == SH_ABI_32
1390                 && (regnum == DEPRECATED_FP_REGNUM
1391                     || regnum ==  PR_REGNUM))
1392               size = 4;
1393             else
1394               size = register_size (current_gdbarch,
1395                                     translate_insn_rn (regnum, media_mode));
1396             write_register (regnum,
1397                             read_memory_integer (deprecated_get_frame_saved_regs (frame)[regnum],
1398                                                  size));
1399           }
1400
1401       write_register (PC_REGNUM, get_frame_extra_info (frame)->return_pc);
1402       write_register (SP_REGNUM, fp + 8);
1403     }
1404   flush_cached_frames ();
1405 }
1406
1407 static CORE_ADDR
1408 sh_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
1409 {
1410   return sp & ~3;
1411 }
1412
1413 /* Function: push_arguments
1414    Setup the function arguments for calling a function in the inferior.
1415
1416    On the Renesas SH architecture, there are four registers (R4 to R7)
1417    which are dedicated for passing function arguments.  Up to the first
1418    four arguments (depending on size) may go into these registers.
1419    The rest go on the stack.
1420
1421    Arguments that are smaller than 4 bytes will still take up a whole
1422    register or a whole 32-bit word on the stack, and will be
1423    right-justified in the register or the stack word.  This includes
1424    chars, shorts, and small aggregate types.
1425
1426    Arguments that are larger than 4 bytes may be split between two or
1427    more registers.  If there are not enough registers free, an argument
1428    may be passed partly in a register (or registers), and partly on the
1429    stack.  This includes doubles, long longs, and larger aggregates.
1430    As far as I know, there is no upper limit to the size of aggregates
1431    that will be passed in this way; in other words, the convention of
1432    passing a pointer to a large aggregate instead of a copy is not used.
1433
1434    An exceptional case exists for struct arguments (and possibly other
1435    aggregates such as arrays) if the size is larger than 4 bytes but
1436    not a multiple of 4 bytes.  In this case the argument is never split
1437    between the registers and the stack, but instead is copied in its
1438    entirety onto the stack, AND also copied into as many registers as
1439    there is room for.  In other words, space in registers permitting,
1440    two copies of the same argument are passed in.  As far as I can tell,
1441    only the one on the stack is used, although that may be a function
1442    of the level of compiler optimization.  I suspect this is a compiler
1443    bug.  Arguments of these odd sizes are left-justified within the
1444    word (as opposed to arguments smaller than 4 bytes, which are
1445    right-justified).
1446
1447    If the function is to return an aggregate type such as a struct, it
1448    is either returned in the normal return value register R0 (if its
1449    size is no greater than one byte), or else the caller must allocate
1450    space into which the callee will copy the return value (if the size
1451    is greater than one byte).  In this case, a pointer to the return
1452    value location is passed into the callee in register R2, which does
1453    not displace any of the other arguments passed in via registers R4
1454    to R7.   */
1455
1456 /* R2-R9 for integer types and integer equivalent (char, pointers) and
1457    non-scalar (struct, union) elements (even if the elements are
1458    floats).
1459    FR0-FR11 for single precision floating point (float)
1460    DR0-DR10 for double precision floating point (double)
1461
1462    If a float is argument number 3 (for instance) and arguments number
1463    1,2, and 4 are integer, the mapping will be:
1464    arg1 -->R2, arg2 --> R3, arg3 -->FR0, arg4 --> R5. I.e. R4 is not used.
1465
1466    If a float is argument number 10 (for instance) and arguments number
1467    1 through 10 are integer, the mapping will be:
1468    arg1->R2, arg2->R3, arg3->R4, arg4->R5, arg5->R6, arg6->R7, arg7->R8,
1469    arg8->R9, arg9->(0,SP)stack(8-byte aligned), arg10->FR0, arg11->stack(16,SP).
1470    I.e. there is hole in the stack.
1471
1472    Different rules apply for variable arguments functions, and for functions
1473    for which the prototype is not known.  */
1474
1475 static CORE_ADDR
1476 sh64_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
1477                      int struct_return, CORE_ADDR struct_addr)
1478 {
1479   int stack_offset, stack_alloc;
1480   int int_argreg;
1481   int float_argreg;
1482   int double_argreg;
1483   int float_arg_index = 0;
1484   int double_arg_index = 0;
1485   int argnum;
1486   struct type *type;
1487   CORE_ADDR regval;
1488   char *val;
1489   char valbuf[8];
1490   char valbuf_tmp[8];
1491   int len;
1492   int argreg_size;
1493   int fp_args[12];
1494
1495   memset (fp_args, 0, sizeof (fp_args));
1496
1497   /* first force sp to a 8-byte alignment */
1498   sp = sp & ~7;
1499
1500   /* The "struct return pointer" pseudo-argument has its own dedicated
1501      register */
1502
1503   if (struct_return)
1504     write_register (STRUCT_RETURN_REGNUM, struct_addr);
1505
1506   /* Now make sure there's space on the stack */
1507   for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
1508     stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 7) & ~7);
1509   sp -= stack_alloc;            /* make room on stack for args */
1510
1511   /* Now load as many as possible of the first arguments into
1512      registers, and push the rest onto the stack.  There are 64 bytes
1513      in eight registers available.  Loop thru args from first to last.  */
1514
1515   int_argreg = ARG0_REGNUM;
1516   float_argreg = FP0_REGNUM;
1517   double_argreg = DR0_REGNUM;
1518
1519   for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
1520     {
1521       type = VALUE_TYPE (args[argnum]);
1522       len = TYPE_LENGTH (type);
1523       memset (valbuf, 0, sizeof (valbuf));
1524
1525       if (TYPE_CODE (type) != TYPE_CODE_FLT)
1526         {
1527           argreg_size = register_size (current_gdbarch, int_argreg);
1528
1529           if (len < argreg_size)
1530             {
1531               /* value gets right-justified in the register or stack word */
1532               if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
1533                 memcpy (valbuf + argreg_size - len,
1534                         (char *) VALUE_CONTENTS (args[argnum]), len);
1535               else
1536                 memcpy (valbuf, (char *) VALUE_CONTENTS (args[argnum]), len);
1537
1538               val = valbuf;
1539             }
1540           else
1541             val = (char *) VALUE_CONTENTS (args[argnum]);
1542
1543           while (len > 0)
1544             {
1545               if (int_argreg > ARGLAST_REGNUM)
1546                 {
1547                   /* must go on the stack */
1548                   write_memory (sp + stack_offset, val, argreg_size);
1549                   stack_offset += 8;/*argreg_size;*/
1550                 }
1551               /* NOTE WELL!!!!!  This is not an "else if" clause!!!
1552                  That's because some *&^%$ things get passed on the stack
1553                  AND in the registers!   */
1554               if (int_argreg <= ARGLAST_REGNUM)
1555                 {
1556                   /* there's room in a register */
1557                   regval = extract_unsigned_integer (val, argreg_size);
1558                   write_register (int_argreg, regval);
1559                 }
1560               /* Store the value 8 bytes at a time.  This means that
1561                  things larger than 8 bytes may go partly in registers
1562                  and partly on the stack. FIXME: argreg is incremented
1563                  before we use its size.  */
1564               len -= argreg_size;
1565               val += argreg_size;
1566               int_argreg++;
1567             }
1568         }
1569       else
1570         {
1571           val = (char *) VALUE_CONTENTS (args[argnum]);
1572           if (len == 4)
1573             {
1574               /* Where is it going to be stored? */
1575               while (fp_args[float_arg_index])
1576                 float_arg_index ++;
1577
1578               /* Now float_argreg points to the register where it
1579                  should be stored.  Are we still within the allowed
1580                  register set? */
1581               if (float_arg_index <= FLOAT_ARGLAST_REGNUM)
1582                 {
1583                   /* Goes in FR0...FR11 */
1584                   deprecated_write_register_gen (FP0_REGNUM + float_arg_index,
1585                                                  val);
1586                   fp_args[float_arg_index] = 1;
1587                   /* Skip the corresponding general argument register.  */
1588                   int_argreg ++;
1589                 }
1590               else
1591                 ;
1592                 /* Store it as the integers, 8 bytes at the time, if
1593                    necessary spilling on the stack.  */
1594
1595             }
1596             else if (len == 8)
1597               {
1598                 /* Where is it going to be stored? */
1599                 while (fp_args[double_arg_index])
1600                   double_arg_index += 2;
1601                 /* Now double_argreg points to the register
1602                    where it should be stored.
1603                    Are we still within the allowed register set? */
1604                 if (double_arg_index < FLOAT_ARGLAST_REGNUM)
1605                   {
1606                     /* Goes in DR0...DR10 */
1607                     /* The numbering of the DRi registers is consecutive,
1608                        i.e. includes odd numbers.  */
1609                     int double_register_offset = double_arg_index / 2;
1610                     int regnum = DR0_REGNUM +
1611                                  double_register_offset;
1612 #if 0
1613                     if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
1614                       {
1615                         memset (valbuf_tmp, 0, sizeof (valbuf_tmp));
1616                         DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum,
1617                                                                 type, val,
1618                                                                 valbuf_tmp);
1619                         val = valbuf_tmp;
1620                       }
1621 #endif
1622                     /* Note: must use write_register_gen here instead
1623                        of regcache_raw_write, because
1624                        regcache_raw_write works only for real
1625                        registers, not pseudo.  write_register_gen will
1626                        call the gdbarch function to do register
1627                        writes, and that will properly know how to deal
1628                        with pseudoregs.  */
1629                     deprecated_write_register_gen (regnum, val);
1630                     fp_args[double_arg_index] = 1;
1631                     fp_args[double_arg_index + 1] = 1;
1632                     /* Skip the corresponding general argument register.  */
1633                     int_argreg ++;
1634                   }
1635                 else
1636                   ;
1637                   /* Store it as the integers, 8 bytes at the time, if
1638                      necessary spilling on the stack.  */
1639               }
1640         }
1641     }
1642   return sp;
1643 }
1644
1645 /* Function: push_return_address (pc)
1646    Set up the return address for the inferior function call.
1647    Needed for targets where we don't actually execute a JSR/BSR instruction */
1648
1649 static CORE_ADDR
1650 sh64_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
1651 {
1652   write_register (PR_REGNUM, entry_point_address ());
1653   return sp;
1654 }
1655
1656 /* Find a function's return value in the appropriate registers (in
1657    regbuf), and copy it into valbuf.  Extract from an array REGBUF
1658    containing the (raw) register state a function return value of type
1659    TYPE, and copy that, in virtual format, into VALBUF.  */
1660 static void
1661 sh64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
1662 {
1663   int offset;
1664   int return_register;
1665   int len = TYPE_LENGTH (type);
1666
1667   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1668     {
1669       if (len == 4)
1670         {
1671           /* Return value stored in FP0_REGNUM */
1672           return_register = FP0_REGNUM;
1673           offset = DEPRECATED_REGISTER_BYTE (return_register);
1674           memcpy (valbuf, (char *) regbuf + offset, len);
1675         }
1676       else if (len == 8)
1677         {
1678           /* return value stored in DR0_REGNUM */
1679           DOUBLEST val;
1680
1681           return_register = DR0_REGNUM;
1682           offset = DEPRECATED_REGISTER_BYTE (return_register);
1683
1684           if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
1685             floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
1686                                      (char *) regbuf + offset, &val);
1687           else
1688             floatformat_to_doublest (&floatformat_ieee_double_big,
1689                                      (char *) regbuf + offset, &val);
1690           store_typed_floating (valbuf, type, val);
1691         }
1692     }
1693   else
1694     {
1695       if (len <= 8)
1696         {
1697           /* Result is in register 2. If smaller than 8 bytes, it is padded
1698              at the most significant end.  */
1699           return_register = DEFAULT_RETURN_REGNUM;
1700           if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
1701             offset = DEPRECATED_REGISTER_BYTE (return_register) +
1702               register_size (current_gdbarch, return_register) - len;
1703           else
1704             offset = DEPRECATED_REGISTER_BYTE (return_register);
1705           memcpy (valbuf, (char *) regbuf + offset, len);
1706         }
1707       else
1708         error ("bad size for return value");
1709     }
1710 }
1711
1712 /* Write into appropriate registers a function return value
1713    of type TYPE, given in virtual format.
1714    If the architecture is sh4 or sh3e, store a function's return value
1715    in the R0 general register or in the FP0 floating point register,
1716    depending on the type of the return value. In all the other cases
1717    the result is stored in r0, left-justified.  */
1718
1719 static void
1720 sh64_store_return_value (struct type *type, char *valbuf)
1721 {
1722   char buf[64]; /* more than enough...  */
1723   int len = TYPE_LENGTH (type);
1724
1725   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1726     {
1727       if (len == 4)
1728         {
1729           /* Return value stored in FP0_REGNUM */
1730           deprecated_write_register_gen (FP0_REGNUM, valbuf);
1731         }
1732       if (len == 8)
1733         {
1734           /* return value stored in DR0_REGNUM */
1735           /* FIXME: Implement */
1736         }
1737     }
1738   else
1739     {
1740       int return_register = DEFAULT_RETURN_REGNUM;
1741       int offset = 0;
1742
1743       if (len <= register_size (current_gdbarch, return_register))
1744         {
1745           /* Pad with zeros.  */
1746           memset (buf, 0, register_size (current_gdbarch, return_register));
1747           if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
1748             offset = 0; /*register_size (current_gdbarch,
1749                           return_register) - len;*/
1750           else
1751             offset = register_size (current_gdbarch, return_register) - len;
1752
1753           memcpy (buf + offset, valbuf, len);
1754           deprecated_write_register_gen (return_register, buf);
1755         }
1756       else
1757         deprecated_write_register_gen (return_register, valbuf);
1758     }
1759 }
1760
1761 static void
1762 sh64_show_media_regs (void)
1763 {
1764   int i;
1765
1766   printf_filtered ("PC=%s SR=%016llx \n",
1767                    paddr (read_register (PC_REGNUM)),
1768                    (long long) read_register (SR_REGNUM));
1769
1770   printf_filtered ("SSR=%016llx SPC=%016llx \n",
1771                    (long long) read_register (SSR_REGNUM),
1772                    (long long) read_register (SPC_REGNUM));
1773   printf_filtered ("FPSCR=%016lx\n ",
1774                    (long) read_register (FPSCR_REGNUM));
1775
1776   for (i = 0; i < 64; i = i + 4)
1777     printf_filtered ("\nR%d-R%d  %016llx %016llx %016llx %016llx\n",
1778                      i, i + 3,
1779                      (long long) read_register (i + 0),
1780                      (long long) read_register (i + 1),
1781                      (long long) read_register (i + 2),
1782                      (long long) read_register (i + 3));
1783
1784   printf_filtered ("\n");
1785
1786   for (i = 0; i < 64; i = i + 8)
1787     printf_filtered ("FR%d-FR%d  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1788                      i, i + 7,
1789                      (long) read_register (FP0_REGNUM + i + 0),
1790                      (long) read_register (FP0_REGNUM + i + 1),
1791                      (long) read_register (FP0_REGNUM + i + 2),
1792                      (long) read_register (FP0_REGNUM + i + 3),
1793                      (long) read_register (FP0_REGNUM + i + 4),
1794                      (long) read_register (FP0_REGNUM + i + 5),
1795                      (long) read_register (FP0_REGNUM + i + 6),
1796                      (long) read_register (FP0_REGNUM + i + 7));
1797 }
1798
1799 static void
1800 sh64_show_compact_regs (void)
1801 {
1802   int i;
1803
1804   printf_filtered ("PC=%s \n",
1805                    paddr (read_register (PC_C_REGNUM)));
1806
1807   printf_filtered ("GBR=%08lx MACH=%08lx MACL=%08lx PR=%08lx T=%08lx\n",
1808                    (long) read_register (GBR_C_REGNUM),
1809                    (long) read_register (MACH_C_REGNUM),
1810                    (long) read_register (MACL_C_REGNUM),
1811                    (long) read_register (PR_C_REGNUM),
1812                    (long) read_register (T_C_REGNUM));
1813   printf_filtered ("FPSCR=%08lx FPUL=%08lx\n",
1814                    (long) read_register (FPSCR_C_REGNUM),
1815                    (long) read_register (FPUL_C_REGNUM));
1816
1817   for (i = 0; i < 16; i = i + 4)
1818     printf_filtered ("\nR%d-R%d  %08lx %08lx %08lx %08lx\n",
1819                      i, i + 3,
1820                      (long) read_register (i + 0),
1821                      (long) read_register (i + 1),
1822                      (long) read_register (i + 2),
1823                      (long) read_register (i + 3));
1824
1825   printf_filtered ("\n");
1826
1827   for (i = 0; i < 16; i = i + 8)
1828     printf_filtered ("FR%d-FR%d  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1829                      i, i + 7,
1830                      (long) read_register (FP0_REGNUM + i + 0),
1831                      (long) read_register (FP0_REGNUM + i + 1),
1832                      (long) read_register (FP0_REGNUM + i + 2),
1833                      (long) read_register (FP0_REGNUM + i + 3),
1834                      (long) read_register (FP0_REGNUM + i + 4),
1835                      (long) read_register (FP0_REGNUM + i + 5),
1836                      (long) read_register (FP0_REGNUM + i + 6),
1837                      (long) read_register (FP0_REGNUM + i + 7));
1838 }
1839
1840 /* FIXME!!! This only shows the registers for shmedia, excluding the
1841    pseudo registers.  */
1842 void
1843 sh64_show_regs (void)
1844 {
1845   if (deprecated_selected_frame
1846       && pc_is_isa32 (get_frame_pc (deprecated_selected_frame)))
1847     sh64_show_media_regs ();
1848   else
1849     sh64_show_compact_regs ();
1850 }
1851
1852 /* *INDENT-OFF* */
1853 /*
1854     SH MEDIA MODE (ISA 32)
1855     general registers (64-bit) 0-63
1856 0    r0,   r1,   r2,   r3,   r4,   r5,   r6,   r7,
1857 64   r8,   r9,   r10,  r11,  r12,  r13,  r14,  r15,
1858 128  r16,  r17,  r18,  r19,  r20,  r21,  r22,  r23,
1859 192  r24,  r25,  r26,  r27,  r28,  r29,  r30,  r31,
1860 256  r32,  r33,  r34,  r35,  r36,  r37,  r38,  r39,
1861 320  r40,  r41,  r42,  r43,  r44,  r45,  r46,  r47,
1862 384  r48,  r49,  r50,  r51,  r52,  r53,  r54,  r55,
1863 448  r56,  r57,  r58,  r59,  r60,  r61,  r62,  r63,
1864
1865     pc (64-bit) 64
1866 512  pc,
1867
1868     status reg., saved status reg., saved pc reg. (64-bit) 65-67
1869 520  sr,  ssr,  spc,
1870
1871     target registers (64-bit) 68-75
1872 544  tr0,  tr1,  tr2,  tr3,  tr4,  tr5,  tr6,  tr7,
1873
1874     floating point state control register (32-bit) 76
1875 608  fpscr,
1876
1877     single precision floating point registers (32-bit) 77-140
1878 612  fr0,  fr1,  fr2,  fr3,  fr4,  fr5,  fr6,  fr7,
1879 644  fr8,  fr9,  fr10, fr11, fr12, fr13, fr14, fr15,
1880 676  fr16, fr17, fr18, fr19, fr20, fr21, fr22, fr23,
1881 708  fr24, fr25, fr26, fr27, fr28, fr29, fr30, fr31,
1882 740  fr32, fr33, fr34, fr35, fr36, fr37, fr38, fr39,
1883 772  fr40, fr41, fr42, fr43, fr44, fr45, fr46, fr47,
1884 804  fr48, fr49, fr50, fr51, fr52, fr53, fr54, fr55,
1885 836  fr56, fr57, fr58, fr59, fr60, fr61, fr62, fr63,
1886
1887 TOTAL SPACE FOR REGISTERS: 868 bytes
1888
1889 From here on they are all pseudo registers: no memory allocated.
1890 REGISTER_BYTE returns the register byte for the base register.
1891
1892     double precision registers (pseudo) 141-172
1893      dr0,  dr2,  dr4,  dr6,  dr8,  dr10, dr12, dr14,
1894      dr16, dr18, dr20, dr22, dr24, dr26, dr28, dr30,
1895      dr32, dr34, dr36, dr38, dr40, dr42, dr44, dr46,
1896      dr48, dr50, dr52, dr54, dr56, dr58, dr60, dr62,
1897
1898     floating point pairs (pseudo) 173-204
1899      fp0,  fp2,  fp4,  fp6,  fp8,  fp10, fp12, fp14,
1900      fp16, fp18, fp20, fp22, fp24, fp26, fp28, fp30,
1901      fp32, fp34, fp36, fp38, fp40, fp42, fp44, fp46,
1902      fp48, fp50, fp52, fp54, fp56, fp58, fp60, fp62,
1903
1904     floating point vectors (4 floating point regs) (pseudo) 205-220
1905      fv0,  fv4,  fv8,  fv12, fv16, fv20, fv24, fv28,
1906      fv32, fv36, fv40, fv44, fv48, fv52, fv56, fv60,
1907
1908     SH COMPACT MODE (ISA 16) (all pseudo) 221-272
1909      r0_c, r1_c, r2_c,  r3_c,  r4_c,  r5_c,  r6_c,  r7_c,
1910      r8_c, r9_c, r10_c, r11_c, r12_c, r13_c, r14_c, r15_c,
1911      pc_c,
1912      gbr_c, mach_c, macl_c, pr_c, t_c,
1913      fpscr_c, fpul_c,
1914      fr0_c, fr1_c, fr2_c,  fr3_c,  fr4_c,  fr5_c,  fr6_c,  fr7_c,
1915      fr8_c, fr9_c, fr10_c, fr11_c, fr12_c, fr13_c, fr14_c, fr15_c
1916      dr0_c, dr2_c, dr4_c,  dr6_c,  dr8_c,  dr10_c, dr12_c, dr14_c
1917      fv0_c, fv4_c, fv8_c,  fv12_c
1918 */
1919 /* *INDENT-ON* */
1920 static int
1921 sh64_register_byte (int reg_nr)
1922 {
1923   int base_regnum = -1;
1924
1925   /* If it is a pseudo register, get the number of the first floating
1926      point register that is part of it.  */
1927   if (reg_nr >= DR0_REGNUM
1928       && reg_nr <= DR_LAST_REGNUM)
1929     base_regnum = dr_reg_base_num (reg_nr);
1930
1931   else if (reg_nr >= FPP0_REGNUM
1932             && reg_nr <= FPP_LAST_REGNUM)
1933     base_regnum = fpp_reg_base_num (reg_nr);
1934
1935   else if (reg_nr >= FV0_REGNUM
1936             && reg_nr <= FV_LAST_REGNUM)
1937     base_regnum = fv_reg_base_num (reg_nr);
1938
1939   /* sh compact pseudo register. FPSCR is a pathological case, need to
1940      treat it as special.  */
1941   else if ((reg_nr >= R0_C_REGNUM
1942             && reg_nr <= FV_LAST_C_REGNUM)
1943            && reg_nr != FPSCR_C_REGNUM)
1944     base_regnum = sh64_compact_reg_base_num (reg_nr);
1945
1946   /* Now return the offset in bytes within the register cache.  */
1947   /* sh media pseudo register, i.e. any of DR, FFP, FV registers.  */
1948   if (reg_nr >= DR0_REGNUM
1949       && reg_nr <= FV_LAST_REGNUM)
1950     return (base_regnum - FP0_REGNUM + 1) * 4
1951       + (TR7_REGNUM + 1) * 8;
1952
1953   /* sh compact pseudo register: general register */
1954   if ((reg_nr >= R0_C_REGNUM
1955        && reg_nr <= R_LAST_C_REGNUM))
1956     return (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
1957             ? base_regnum * 8 + 4
1958             : base_regnum * 8);
1959
1960   /* sh compact pseudo register: */
1961   if (reg_nr == PC_C_REGNUM
1962        || reg_nr == GBR_C_REGNUM
1963        || reg_nr == MACL_C_REGNUM
1964        || reg_nr == PR_C_REGNUM)
1965     return (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
1966             ? base_regnum * 8 + 4
1967             : base_regnum * 8);
1968
1969   if (reg_nr == MACH_C_REGNUM)
1970     return base_regnum * 8;
1971
1972   if (reg_nr == T_C_REGNUM)
1973     return base_regnum * 8; /* FIXME??? how do we get bit 0? Do we have to? */
1974
1975   /* sh compact pseudo register: floating point register */
1976   else if (reg_nr >= FP0_C_REGNUM
1977            && reg_nr <= FV_LAST_C_REGNUM)
1978     return (base_regnum  - FP0_REGNUM) * 4
1979       + (TR7_REGNUM + 1) * 8 + 4;
1980
1981   else if (reg_nr == FPSCR_C_REGNUM)
1982     /* This is complicated, for now return the beginning of the
1983        architectural FPSCR register.  */
1984     return (TR7_REGNUM + 1) * 8;
1985
1986   else if (reg_nr == FPUL_C_REGNUM)
1987     return ((base_regnum - FP0_REGNUM) * 4 +
1988             (TR7_REGNUM + 1) * 8 + 4);
1989
1990   /* It is not a pseudo register.  */
1991   /* It is a 64 bit register.  */
1992   else if (reg_nr <= TR7_REGNUM)
1993     return reg_nr * 8;
1994
1995   /* It is a 32 bit register.  */
1996   else if (reg_nr == FPSCR_REGNUM)
1997     return (FPSCR_REGNUM * 8);
1998
1999   /* It is floating point 32-bit register */
2000   else
2001     return ((TR7_REGNUM + 1) * 8
2002       + (reg_nr - FP0_REGNUM + 1) * 4);
2003 }
2004
2005 static struct type *
2006 sh64_build_float_register_type (int high)
2007 {
2008   struct type *temp;
2009
2010   temp = create_range_type (NULL, builtin_type_int, 0, high);
2011   return create_array_type (NULL, builtin_type_float, temp);
2012 }
2013
2014 /* Return the GDB type object for the "standard" data type
2015    of data in register REG_NR.  */
2016 static struct type *
2017 sh64_register_type (struct gdbarch *gdbarch, int reg_nr)
2018 {
2019   if ((reg_nr >= FP0_REGNUM
2020        && reg_nr <= FP_LAST_REGNUM)
2021       || (reg_nr >= FP0_C_REGNUM
2022           && reg_nr <= FP_LAST_C_REGNUM))
2023     return builtin_type_float;
2024   else if ((reg_nr >= DR0_REGNUM
2025             && reg_nr <= DR_LAST_REGNUM)
2026            || (reg_nr >= DR0_C_REGNUM
2027                && reg_nr <= DR_LAST_C_REGNUM))
2028     return builtin_type_double;
2029   else if  (reg_nr >= FPP0_REGNUM
2030             && reg_nr <= FPP_LAST_REGNUM)
2031     return sh64_build_float_register_type (1);
2032   else if ((reg_nr >= FV0_REGNUM
2033             && reg_nr <= FV_LAST_REGNUM)
2034            ||(reg_nr >= FV0_C_REGNUM
2035               && reg_nr <= FV_LAST_C_REGNUM))
2036     return sh64_build_float_register_type (3);
2037   else if (reg_nr == FPSCR_REGNUM)
2038     return builtin_type_int;
2039   else if (reg_nr >= R0_C_REGNUM
2040            && reg_nr < FP0_C_REGNUM)
2041     return builtin_type_int;
2042   else
2043     return builtin_type_long_long;
2044 }
2045
2046 static void
2047 sh64_register_convert_to_virtual (int regnum, struct type *type,
2048                                      char *from, char *to)
2049 {
2050   if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
2051     {
2052       /* It is a no-op.  */
2053       memcpy (to, from, register_size (current_gdbarch, regnum));
2054       return;
2055     }
2056
2057   if ((regnum >= DR0_REGNUM
2058        && regnum <= DR_LAST_REGNUM)
2059       || (regnum >= DR0_C_REGNUM
2060           && regnum <= DR_LAST_C_REGNUM))
2061     {
2062       DOUBLEST val;
2063       floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
2064                                from, &val);
2065       store_typed_floating (to, type, val);
2066     }
2067   else
2068     error ("sh64_register_convert_to_virtual called with non DR register number");
2069 }
2070
2071 static void
2072 sh64_register_convert_to_raw (struct type *type, int regnum,
2073                                  const void *from, void *to)
2074 {
2075   if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
2076     {
2077       /* It is a no-op.  */
2078       memcpy (to, from, register_size (current_gdbarch, regnum));
2079       return;
2080     }
2081
2082   if ((regnum >= DR0_REGNUM
2083        && regnum <= DR_LAST_REGNUM)
2084       || (regnum >= DR0_C_REGNUM
2085           && regnum <= DR_LAST_C_REGNUM))
2086     {
2087       DOUBLEST val = deprecated_extract_floating (from, TYPE_LENGTH(type));
2088       floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword,
2089                                  &val, to);
2090     }
2091   else
2092     error ("sh64_register_convert_to_raw called with non DR register number");
2093 }
2094
2095 static void
2096 sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2097                            int reg_nr, void *buffer)
2098 {
2099   int base_regnum;
2100   int portion;
2101   int offset = 0;
2102   char temp_buffer[MAX_REGISTER_SIZE];
2103
2104   if (reg_nr >= DR0_REGNUM
2105       && reg_nr <= DR_LAST_REGNUM)
2106     {
2107       base_regnum = dr_reg_base_num (reg_nr);
2108
2109       /* Build the value in the provided buffer.  */
2110       /* DR regs are double precision registers obtained by
2111          concatenating 2 single precision floating point registers.  */
2112       for (portion = 0; portion < 2; portion++)
2113         regcache_raw_read (regcache, base_regnum + portion,
2114                            (temp_buffer
2115                             + register_size (gdbarch, base_regnum) * portion));
2116
2117       /* We must pay attention to the endianness.  */
2118       sh64_register_convert_to_virtual (reg_nr,
2119                                         gdbarch_register_type (gdbarch,
2120                                                                reg_nr),
2121                                         temp_buffer, buffer);
2122
2123     }
2124
2125   else if (reg_nr >= FPP0_REGNUM
2126            && reg_nr <= FPP_LAST_REGNUM)
2127     {
2128       base_regnum = fpp_reg_base_num (reg_nr);
2129
2130       /* Build the value in the provided buffer.  */
2131       /* FPP regs are pairs of single precision registers obtained by
2132          concatenating 2 single precision floating point registers.  */
2133       for (portion = 0; portion < 2; portion++)
2134         regcache_raw_read (regcache, base_regnum + portion,
2135                            ((char *) buffer
2136                             + register_size (gdbarch, base_regnum) * portion));
2137     }
2138
2139   else if (reg_nr >= FV0_REGNUM
2140            && reg_nr <= FV_LAST_REGNUM)
2141     {
2142       base_regnum = fv_reg_base_num (reg_nr);
2143
2144       /* Build the value in the provided buffer.  */
2145       /* FV regs are vectors of single precision registers obtained by
2146          concatenating 4 single precision floating point registers.  */
2147       for (portion = 0; portion < 4; portion++)
2148         regcache_raw_read (regcache, base_regnum + portion,
2149                            ((char *) buffer
2150                             + register_size (gdbarch, base_regnum) * portion));
2151     }
2152
2153   /* sh compact pseudo registers. 1-to-1 with a shmedia register */
2154   else if (reg_nr >= R0_C_REGNUM
2155            && reg_nr <= T_C_REGNUM)
2156     {
2157       base_regnum = sh64_compact_reg_base_num (reg_nr);
2158
2159       /* Build the value in the provided buffer.  */
2160       regcache_raw_read (regcache, base_regnum, temp_buffer);
2161       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2162         offset = 4;
2163       memcpy (buffer, temp_buffer + offset, 4); /* get LOWER 32 bits only????*/
2164     }
2165
2166   else if (reg_nr >= FP0_C_REGNUM
2167            && reg_nr <= FP_LAST_C_REGNUM)
2168     {
2169       base_regnum = sh64_compact_reg_base_num (reg_nr);
2170
2171       /* Build the value in the provided buffer.  */
2172       /* Floating point registers map 1-1 to the media fp regs,
2173          they have the same size and endianness.  */
2174       regcache_raw_read (regcache, base_regnum, buffer);
2175     }
2176
2177   else if (reg_nr >= DR0_C_REGNUM
2178            && reg_nr <= DR_LAST_C_REGNUM)
2179     {
2180       base_regnum = sh64_compact_reg_base_num (reg_nr);
2181
2182       /* DR_C regs are double precision registers obtained by
2183          concatenating 2 single precision floating point registers.  */
2184       for (portion = 0; portion < 2; portion++)
2185         regcache_raw_read (regcache, base_regnum + portion,
2186                            (temp_buffer
2187                             + register_size (gdbarch, base_regnum) * portion));
2188
2189       /* We must pay attention to the endianness.  */
2190       sh64_register_convert_to_virtual (reg_nr,
2191                                         gdbarch_register_type (gdbarch,
2192                                                                reg_nr),
2193                                         temp_buffer, buffer);
2194     }
2195
2196   else if (reg_nr >= FV0_C_REGNUM
2197            && reg_nr <= FV_LAST_C_REGNUM)
2198     {
2199       base_regnum = sh64_compact_reg_base_num (reg_nr);
2200
2201       /* Build the value in the provided buffer.  */
2202       /* FV_C regs are vectors of single precision registers obtained by
2203          concatenating 4 single precision floating point registers.  */
2204       for (portion = 0; portion < 4; portion++)
2205         regcache_raw_read (regcache, base_regnum + portion,
2206                            ((char *) buffer
2207                             + register_size (gdbarch, base_regnum) * portion));
2208     }
2209
2210   else if (reg_nr == FPSCR_C_REGNUM)
2211     {
2212       int fpscr_base_regnum;
2213       int sr_base_regnum;
2214       unsigned int fpscr_value;
2215       unsigned int sr_value;
2216       unsigned int fpscr_c_value;
2217       unsigned int fpscr_c_part1_value;
2218       unsigned int fpscr_c_part2_value;
2219
2220       fpscr_base_regnum = FPSCR_REGNUM;
2221       sr_base_regnum = SR_REGNUM;
2222
2223       /* Build the value in the provided buffer.  */
2224       /* FPSCR_C is a very weird register that contains sparse bits
2225          from the FPSCR and the SR architectural registers.
2226          Specifically: */
2227       /* *INDENT-OFF* */
2228       /*
2229          FPSRC_C bit
2230             0         Bit 0 of FPSCR
2231             1         reserved
2232             2-17      Bit 2-18 of FPSCR
2233             18-20     Bits 12,13,14 of SR
2234             21-31     reserved
2235        */
2236       /* *INDENT-ON* */
2237       /* Get FPSCR into a local buffer */
2238       regcache_raw_read (regcache, fpscr_base_regnum, temp_buffer);
2239       /* Get value as an int.  */
2240       fpscr_value = extract_unsigned_integer (temp_buffer, 4);
2241       /* Get SR into a local buffer */
2242       regcache_raw_read (regcache, sr_base_regnum, temp_buffer);
2243       /* Get value as an int.  */
2244       sr_value = extract_unsigned_integer (temp_buffer, 4);
2245       /* Build the new value.  */
2246       fpscr_c_part1_value = fpscr_value & 0x3fffd;
2247       fpscr_c_part2_value = (sr_value & 0x7000) << 6;
2248       fpscr_c_value = fpscr_c_part1_value | fpscr_c_part2_value;
2249       /* Store that in out buffer!!! */
2250       store_unsigned_integer (buffer, 4, fpscr_c_value);
2251       /* FIXME There is surely an endianness gotcha here.  */
2252     }
2253
2254   else if (reg_nr == FPUL_C_REGNUM)
2255     {
2256       base_regnum = sh64_compact_reg_base_num (reg_nr);
2257
2258       /* FPUL_C register is floating point register 32,
2259          same size, same endianness.  */
2260       regcache_raw_read (regcache, base_regnum, buffer);
2261     }
2262 }
2263
2264 static void
2265 sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
2266                             int reg_nr, const void *buffer)
2267 {
2268   int base_regnum, portion;
2269   int offset;
2270   char temp_buffer[MAX_REGISTER_SIZE];
2271
2272   if (reg_nr >= DR0_REGNUM
2273       && reg_nr <= DR_LAST_REGNUM)
2274     {
2275       base_regnum = dr_reg_base_num (reg_nr);
2276       /* We must pay attention to the endianness.  */
2277       sh64_register_convert_to_raw (gdbarch_register_type (gdbarch, reg_nr),
2278                                     reg_nr,
2279                                     buffer, temp_buffer);
2280
2281       /* Write the real regs for which this one is an alias.  */
2282       for (portion = 0; portion < 2; portion++)
2283         regcache_raw_write (regcache, base_regnum + portion,
2284                             (temp_buffer
2285                              + register_size (gdbarch,
2286                                               base_regnum) * portion));
2287     }
2288
2289   else if (reg_nr >= FPP0_REGNUM
2290            && reg_nr <= FPP_LAST_REGNUM)
2291     {
2292       base_regnum = fpp_reg_base_num (reg_nr);
2293
2294       /* Write the real regs for which this one is an alias.  */
2295       for (portion = 0; portion < 2; portion++)
2296         regcache_raw_write (regcache, base_regnum + portion,
2297                             ((char *) buffer
2298                              + register_size (gdbarch,
2299                                               base_regnum) * portion));
2300     }
2301
2302   else if (reg_nr >= FV0_REGNUM
2303            && reg_nr <= FV_LAST_REGNUM)
2304     {
2305       base_regnum = fv_reg_base_num (reg_nr);
2306
2307       /* Write the real regs for which this one is an alias.  */
2308       for (portion = 0; portion < 4; portion++)
2309         regcache_raw_write (regcache, base_regnum + portion,
2310                             ((char *) buffer
2311                              + register_size (gdbarch,
2312                                               base_regnum) * portion));
2313     }
2314
2315   /* sh compact general pseudo registers. 1-to-1 with a shmedia
2316      register but only 4 bytes of it.  */
2317   else if (reg_nr >= R0_C_REGNUM
2318            && reg_nr <= T_C_REGNUM)
2319     {
2320       base_regnum = sh64_compact_reg_base_num (reg_nr);
2321       /* reg_nr is 32 bit here, and base_regnum is 64 bits.  */
2322       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
2323         offset = 4;
2324       else
2325         offset = 0;
2326       /* Let's read the value of the base register into a temporary
2327          buffer, so that overwriting the last four bytes with the new
2328          value of the pseudo will leave the upper 4 bytes unchanged.  */
2329       regcache_raw_read (regcache, base_regnum, temp_buffer);
2330       /* Write as an 8 byte quantity */
2331       memcpy (temp_buffer + offset, buffer, 4);
2332       regcache_raw_write (regcache, base_regnum, temp_buffer);
2333     }
2334
2335   /* sh floating point compact pseudo registers. 1-to-1 with a shmedia
2336      registers. Both are 4 bytes.  */
2337   else if (reg_nr >= FP0_C_REGNUM
2338                && reg_nr <= FP_LAST_C_REGNUM)
2339     {
2340       base_regnum = sh64_compact_reg_base_num (reg_nr);
2341       regcache_raw_write (regcache, base_regnum, buffer);
2342     }
2343
2344   else if (reg_nr >= DR0_C_REGNUM
2345            && reg_nr <= DR_LAST_C_REGNUM)
2346     {
2347       base_regnum = sh64_compact_reg_base_num (reg_nr);
2348       for (portion = 0; portion < 2; portion++)
2349         {
2350           /* We must pay attention to the endianness.  */
2351           sh64_register_convert_to_raw (gdbarch_register_type (gdbarch,
2352                                                                reg_nr),
2353                                         reg_nr,
2354                                         buffer, temp_buffer);
2355
2356           regcache_raw_write (regcache, base_regnum + portion,
2357                               (temp_buffer
2358                                + register_size (gdbarch,
2359                                                 base_regnum) * portion));
2360         }
2361     }
2362
2363   else if (reg_nr >= FV0_C_REGNUM
2364            && reg_nr <= FV_LAST_C_REGNUM)
2365     {
2366       base_regnum = sh64_compact_reg_base_num (reg_nr);
2367
2368       for (portion = 0; portion < 4; portion++)
2369         {
2370           regcache_raw_write (regcache, base_regnum + portion,
2371                               ((char *) buffer
2372                                + register_size (gdbarch,
2373                                                 base_regnum) * portion));
2374         }
2375     }
2376
2377   else if (reg_nr == FPSCR_C_REGNUM)
2378     {
2379       int fpscr_base_regnum;
2380       int sr_base_regnum;
2381       unsigned int fpscr_value;
2382       unsigned int sr_value;
2383       unsigned int old_fpscr_value;
2384       unsigned int old_sr_value;
2385       unsigned int fpscr_c_value;
2386       unsigned int fpscr_mask;
2387       unsigned int sr_mask;
2388
2389       fpscr_base_regnum = FPSCR_REGNUM;
2390       sr_base_regnum = SR_REGNUM;
2391
2392       /* FPSCR_C is a very weird register that contains sparse bits
2393          from the FPSCR and the SR architectural registers.
2394          Specifically: */
2395       /* *INDENT-OFF* */
2396       /*
2397          FPSRC_C bit
2398             0         Bit 0 of FPSCR
2399             1         reserved
2400             2-17      Bit 2-18 of FPSCR
2401             18-20     Bits 12,13,14 of SR
2402             21-31     reserved
2403        */
2404       /* *INDENT-ON* */
2405       /* Get value as an int.  */
2406       fpscr_c_value = extract_unsigned_integer (buffer, 4);
2407
2408       /* Build the new values.  */
2409       fpscr_mask = 0x0003fffd;
2410       sr_mask = 0x001c0000;
2411
2412       fpscr_value = fpscr_c_value & fpscr_mask;
2413       sr_value = (fpscr_value & sr_mask) >> 6;
2414
2415       regcache_raw_read (regcache, fpscr_base_regnum, temp_buffer);
2416       old_fpscr_value = extract_unsigned_integer (temp_buffer, 4);
2417       old_fpscr_value &= 0xfffc0002;
2418       fpscr_value |= old_fpscr_value;
2419       store_unsigned_integer (temp_buffer, 4, fpscr_value);
2420       regcache_raw_write (regcache, fpscr_base_regnum, temp_buffer);
2421
2422       regcache_raw_read (regcache, sr_base_regnum, temp_buffer);
2423       old_sr_value = extract_unsigned_integer (temp_buffer, 4);
2424       old_sr_value &= 0xffff8fff;
2425       sr_value |= old_sr_value;
2426       store_unsigned_integer (temp_buffer, 4, sr_value);
2427       regcache_raw_write (regcache, sr_base_regnum, temp_buffer);
2428     }
2429
2430   else if (reg_nr == FPUL_C_REGNUM)
2431     {
2432       base_regnum = sh64_compact_reg_base_num (reg_nr);
2433       regcache_raw_write (regcache, base_regnum, buffer);
2434     }
2435 }
2436
2437 /* Floating point vector of 4 float registers.  */
2438 static void
2439 do_fv_register_info (struct gdbarch *gdbarch, struct ui_file *file,
2440                      int fv_regnum)
2441 {
2442   int first_fp_reg_num = fv_reg_base_num (fv_regnum);
2443   fprintf_filtered (file, "fv%d\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n",
2444                      fv_regnum - FV0_REGNUM,
2445                      (int) read_register (first_fp_reg_num),
2446                      (int) read_register (first_fp_reg_num + 1),
2447                      (int) read_register (first_fp_reg_num + 2),
2448                      (int) read_register (first_fp_reg_num + 3));
2449 }
2450
2451 /* Floating point vector of 4 float registers, compact mode.  */
2452 static void
2453 do_fv_c_register_info (int fv_regnum)
2454 {
2455   int first_fp_reg_num = sh64_compact_reg_base_num (fv_regnum);
2456   printf_filtered ("fv%d_c\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n",
2457                      fv_regnum - FV0_C_REGNUM,
2458                      (int) read_register (first_fp_reg_num),
2459                      (int) read_register (first_fp_reg_num + 1),
2460                      (int) read_register (first_fp_reg_num + 2),
2461                      (int) read_register (first_fp_reg_num + 3));
2462 }
2463
2464 /* Pairs of single regs. The DR are instead double precision
2465    registers.  */
2466 static void
2467 do_fpp_register_info (int fpp_regnum)
2468 {
2469   int first_fp_reg_num = fpp_reg_base_num (fpp_regnum);
2470
2471   printf_filtered ("fpp%d\t0x%08x\t0x%08x\n",
2472                     fpp_regnum - FPP0_REGNUM,
2473                     (int) read_register (first_fp_reg_num),
2474                     (int) read_register (first_fp_reg_num + 1));
2475 }
2476
2477 /* Double precision registers.  */
2478 static void
2479 do_dr_register_info (struct gdbarch *gdbarch, struct ui_file *file,
2480                      int dr_regnum)
2481 {
2482   int first_fp_reg_num = dr_reg_base_num (dr_regnum);
2483
2484   fprintf_filtered (file, "dr%d\t0x%08x%08x\n",
2485                     dr_regnum - DR0_REGNUM,
2486                     (int) read_register (first_fp_reg_num),
2487                     (int) read_register (first_fp_reg_num + 1));
2488 }
2489
2490 /* Double precision registers, compact mode.  */
2491 static void
2492 do_dr_c_register_info (int dr_regnum)
2493 {
2494  int first_fp_reg_num = sh64_compact_reg_base_num (dr_regnum);
2495
2496  printf_filtered ("dr%d_c\t0x%08x%08x\n",
2497                   dr_regnum - DR0_C_REGNUM,
2498                   (int) read_register (first_fp_reg_num),
2499                   (int) read_register (first_fp_reg_num +1));
2500 }
2501
2502 /* General register in compact mode.  */
2503 static void
2504 do_r_c_register_info (int r_c_regnum)
2505 {
2506   int regnum =  sh64_compact_reg_base_num (r_c_regnum);
2507
2508   printf_filtered ("r%d_c\t0x%08x\n",
2509                     r_c_regnum - R0_C_REGNUM,
2510                    /*FIXME!!!*/  (int) read_register (regnum));
2511 }
2512
2513 /* FIXME:!! THIS SHOULD TAKE CARE OF GETTING THE RIGHT PORTION OF THE
2514    shmedia REGISTERS.  */
2515 /* Control registers, compact mode.  */
2516 static void
2517 do_cr_c_register_info (int cr_c_regnum)
2518 {
2519   switch (cr_c_regnum)
2520     {
2521     case 237: printf_filtered ("pc_c\t0x%08x\n", (int) read_register (cr_c_regnum));
2522       break;
2523     case 238: printf_filtered ("gbr_c\t0x%08x\n", (int) read_register (cr_c_regnum));
2524       break;
2525     case 239: printf_filtered ("mach_c\t0x%08x\n", (int) read_register (cr_c_regnum));
2526       break;
2527     case 240: printf_filtered ("macl_c\t0x%08x\n", (int) read_register (cr_c_regnum));
2528       break;
2529     case 241: printf_filtered ("pr_c\t0x%08x\n", (int) read_register (cr_c_regnum));
2530       break;
2531     case 242: printf_filtered ("t_c\t0x%08x\n", (int) read_register (cr_c_regnum));
2532       break;
2533     case 243: printf_filtered ("fpscr_c\t0x%08x\n", (int) read_register (cr_c_regnum));
2534       break;
2535     case 244: printf_filtered ("fpul_c\t0x%08x\n", (int)read_register (cr_c_regnum));
2536       break;
2537     }
2538 }
2539
2540 static void
2541 sh_do_fp_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
2542 {                               /* do values for FP (float) regs */
2543   char *raw_buffer;
2544   double flt;   /* double extracted from raw hex data */
2545   int inv;
2546   int j;
2547
2548   /* Allocate space for the float.  */
2549   raw_buffer = (char *) alloca (register_size (gdbarch, FP0_REGNUM));
2550
2551   /* Get the data in raw format.  */
2552   if (!frame_register_read (get_selected_frame (), regnum, raw_buffer))
2553     error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
2554
2555   /* Get the register as a number */
2556   flt = unpack_double (builtin_type_float, raw_buffer, &inv);
2557
2558   /* Print the name and some spaces.  */
2559   fputs_filtered (REGISTER_NAME (regnum), file);
2560   print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
2561
2562   /* Print the value.  */
2563   if (inv)
2564     fprintf_filtered (file, "<invalid float>");
2565   else
2566     fprintf_filtered (file, "%-10.9g", flt);
2567
2568   /* Print the fp register as hex.  */
2569   fprintf_filtered (file, "\t(raw 0x");
2570   for (j = 0; j < register_size (gdbarch, regnum); j++)
2571     {
2572       int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j
2573         : register_size (gdbarch, regnum) - 1 - j;
2574       fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
2575     }
2576   fprintf_filtered (file, ")");
2577   fprintf_filtered (file, "\n");
2578 }
2579
2580 static void
2581 sh64_do_pseudo_register (int regnum)
2582 {
2583   /* All the sh64-compact mode registers are pseudo registers.  */
2584
2585   if (regnum < NUM_REGS
2586       || regnum >= NUM_REGS + NUM_PSEUDO_REGS_SH_MEDIA + NUM_PSEUDO_REGS_SH_COMPACT)
2587     internal_error (__FILE__, __LINE__,
2588                     "Invalid pseudo register number %d\n", regnum);
2589
2590   else if ((regnum >= DR0_REGNUM
2591             && regnum <= DR_LAST_REGNUM))
2592     do_dr_register_info (current_gdbarch, gdb_stdout, regnum);
2593
2594   else if ((regnum >= DR0_C_REGNUM
2595             && regnum <= DR_LAST_C_REGNUM))
2596     do_dr_c_register_info (regnum);
2597
2598   else if ((regnum >= FV0_REGNUM
2599             && regnum <= FV_LAST_REGNUM))
2600     do_fv_register_info (current_gdbarch, gdb_stdout, regnum);
2601
2602   else if ((regnum >= FV0_C_REGNUM
2603             && regnum <= FV_LAST_C_REGNUM))
2604     do_fv_c_register_info (regnum);
2605
2606   else if (regnum >= FPP0_REGNUM
2607            && regnum <= FPP_LAST_REGNUM)
2608     do_fpp_register_info (regnum);
2609
2610   else if (regnum >= R0_C_REGNUM
2611            && regnum <= R_LAST_C_REGNUM)
2612     /* FIXME, this function will not print the right format.  */
2613     do_r_c_register_info (regnum);
2614   else if (regnum >= FP0_C_REGNUM
2615            && regnum <= FP_LAST_C_REGNUM)
2616     /* This should work also for pseudoregs.  */
2617     sh_do_fp_register (current_gdbarch, gdb_stdout, regnum);
2618   else if (regnum >= PC_C_REGNUM
2619            && regnum <= FPUL_C_REGNUM)
2620     do_cr_c_register_info (regnum);
2621 }
2622
2623 static void
2624 sh_do_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
2625 {
2626   char raw_buffer[MAX_REGISTER_SIZE];
2627
2628   fputs_filtered (REGISTER_NAME (regnum), file);
2629   print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
2630
2631   /* Get the data in raw format.  */
2632   if (!frame_register_read (get_selected_frame (), regnum, raw_buffer))
2633     fprintf_filtered (file, "*value not available*\n");
2634
2635   val_print (gdbarch_register_type (gdbarch, regnum), raw_buffer, 0, 0,
2636              file, 'x', 1, 0, Val_pretty_default);
2637   fprintf_filtered (file, "\t");
2638   val_print (gdbarch_register_type (gdbarch, regnum), raw_buffer, 0, 0,
2639              file, 0, 1, 0, Val_pretty_default);
2640   fprintf_filtered (file, "\n");
2641 }
2642
2643 static void
2644 sh_print_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
2645 {
2646   if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
2647     internal_error (__FILE__, __LINE__,
2648                     "Invalid register number %d\n", regnum);
2649
2650   else if (regnum >= 0 && regnum < NUM_REGS)
2651     {
2652       if (TYPE_CODE (gdbarch_register_type (gdbarch, regnum)) == TYPE_CODE_FLT)
2653         sh_do_fp_register (gdbarch, file, regnum);      /* FP regs */
2654       else
2655         sh_do_register (gdbarch, file, regnum); /* All other regs */
2656     }
2657
2658   else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
2659     sh64_do_pseudo_register (regnum);
2660 }
2661
2662 static void
2663 sh_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
2664                          struct frame_info *frame, int regnum, int fpregs)
2665 {
2666   if (regnum != -1)             /* do one specified register */
2667     {
2668       if (*(REGISTER_NAME (regnum)) == '\0')
2669         error ("Not a valid register for the current processor type");
2670
2671       sh_print_register (gdbarch, file, regnum);
2672     }
2673   else
2674     /* do all (or most) registers */
2675     {
2676       regnum = 0;
2677       while (regnum < NUM_REGS)
2678         {
2679           /* If the register name is empty, it is undefined for this
2680              processor, so don't display anything.  */
2681           if (REGISTER_NAME (regnum) == NULL
2682               || *(REGISTER_NAME (regnum)) == '\0')
2683             {
2684               regnum++;
2685               continue;
2686             }
2687
2688           if (TYPE_CODE (gdbarch_register_type (gdbarch, regnum)) == TYPE_CODE_FLT)
2689             {
2690               if (fpregs)
2691                 {
2692                   /* true for "INFO ALL-REGISTERS" command */
2693                   sh_do_fp_register (gdbarch, file, regnum);    /* FP regs */
2694                   regnum ++;
2695                 }
2696               else
2697                 regnum += FP_LAST_REGNUM - FP0_REGNUM;  /* skip FP regs */
2698             }
2699           else
2700             {
2701               sh_do_register (gdbarch, file, regnum);   /* All other regs */
2702               regnum++;
2703             }
2704         }
2705
2706       if (fpregs)
2707         while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
2708           {
2709             sh64_do_pseudo_register (regnum);
2710             regnum++;
2711           }
2712     }
2713 }
2714
2715 static void
2716 sh_compact_do_registers_info (int regnum, int fpregs)
2717 {
2718   if (regnum != -1)             /* do one specified register */
2719     {
2720       if (*(REGISTER_NAME (regnum)) == '\0')
2721         error ("Not a valid register for the current processor type");
2722
2723       if (regnum >= 0 && regnum < R0_C_REGNUM)
2724         error ("Not a valid register for the current processor mode.");
2725
2726       sh_print_register (current_gdbarch, gdb_stdout, regnum);
2727     }
2728   else
2729     /* do all compact registers */
2730     {
2731       regnum = R0_C_REGNUM;
2732       while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
2733         {
2734           sh64_do_pseudo_register (regnum);
2735           regnum++;
2736         }
2737     }
2738 }
2739
2740 static void
2741 sh64_do_registers_info (int regnum, int fpregs)
2742 {
2743   if (pc_is_isa32 (get_frame_pc (deprecated_selected_frame)))
2744    sh_print_registers_info (current_gdbarch, gdb_stdout,
2745                             deprecated_selected_frame, regnum, fpregs);
2746   else
2747    sh_compact_do_registers_info (regnum, fpregs);
2748 }
2749
2750 #ifdef SVR4_SHARED_LIBS
2751
2752 /* Fetch (and possibly build) an appropriate link_map_offsets structure
2753    for native i386 linux targets using the struct offsets defined in
2754    link.h (but without actual reference to that file).
2755
2756    This makes it possible to access i386-linux shared libraries from
2757    a gdb that was not built on an i386-linux host (for cross debugging).
2758    */
2759
2760 struct link_map_offsets *
2761 sh_linux_svr4_fetch_link_map_offsets (void)
2762 {
2763   static struct link_map_offsets lmo;
2764   static struct link_map_offsets *lmp = 0;
2765
2766   if (lmp == 0)
2767     {
2768       lmp = &lmo;
2769
2770       lmo.r_debug_size = 8;     /* 20 not actual size but all we need */
2771
2772       lmo.r_map_offset = 4;
2773       lmo.r_map_size   = 4;
2774
2775       lmo.link_map_size = 20;   /* 552 not actual size but all we need */
2776
2777       lmo.l_addr_offset = 0;
2778       lmo.l_addr_size   = 4;
2779
2780       lmo.l_name_offset = 4;
2781       lmo.l_name_size   = 4;
2782
2783       lmo.l_next_offset = 12;
2784       lmo.l_next_size   = 4;
2785
2786       lmo.l_prev_offset = 16;
2787       lmo.l_prev_size   = 4;
2788     }
2789
2790     return lmp;
2791 }
2792 #endif /* SVR4_SHARED_LIBS */
2793
2794 gdbarch_init_ftype sh64_gdbarch_init;
2795
2796 struct gdbarch *
2797 sh64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2798 {
2799   static LONGEST sh64_call_dummy_words[] = {0};
2800   struct gdbarch *gdbarch;
2801   struct gdbarch_tdep *tdep;
2802
2803   /* If there is already a candidate, use it.  */
2804   arches = gdbarch_list_lookup_by_info (arches, &info);
2805   if (arches != NULL)
2806     return arches->gdbarch;
2807
2808   /* None found, create a new architecture from the information
2809      provided.  */
2810   tdep = XMALLOC (struct gdbarch_tdep);
2811   gdbarch = gdbarch_alloc (&info, tdep);
2812
2813   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
2814      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
2815   set_gdbarch_deprecated_init_frame_pc (gdbarch, deprecated_init_frame_pc_default);
2816
2817   /* Determine the ABI */
2818   if (info.abfd && bfd_get_arch_size (info.abfd) == 64)
2819     {
2820       /* If the ABI is the 64-bit one, it can only be sh-media.  */
2821       tdep->sh_abi = SH_ABI_64;
2822       set_gdbarch_ptr_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2823       set_gdbarch_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2824     }
2825   else
2826     {
2827       /* If the ABI is the 32-bit one it could be either media or
2828          compact.  */
2829       tdep->sh_abi = SH_ABI_32;
2830       set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2831       set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2832     }
2833
2834   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
2835   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2836   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2837   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2838   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2839   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2840
2841   set_gdbarch_sp_regnum (gdbarch, 15);
2842   set_gdbarch_deprecated_fp_regnum (gdbarch, 14);
2843
2844   set_gdbarch_print_insn (gdbarch, gdb_print_insn_sh);
2845   set_gdbarch_register_sim_regno (gdbarch, legacy_register_sim_regno);
2846
2847   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
2848
2849   set_gdbarch_skip_prologue (gdbarch, sh_skip_prologue);
2850   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2851   set_gdbarch_decr_pc_after_break (gdbarch, 0);
2852
2853   set_gdbarch_frame_args_skip (gdbarch, 0);
2854   set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue);
2855   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
2856
2857   set_gdbarch_deprecated_frame_saved_pc (gdbarch, sh_frame_saved_pc);
2858   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, sh_saved_pc_after_call);
2859   set_gdbarch_frame_align (gdbarch, sh_frame_align);
2860
2861   set_gdbarch_num_pseudo_regs (gdbarch, NUM_PSEUDO_REGS_SH_MEDIA + NUM_PSEUDO_REGS_SH_COMPACT);
2862   set_gdbarch_fp0_regnum (gdbarch, SIM_SH64_FR0_REGNUM);
2863   set_gdbarch_pc_regnum (gdbarch, 64);
2864
2865   /* The number of real registers is the same whether we are in
2866      ISA16(compact) or ISA32(media).  */
2867   set_gdbarch_num_regs (gdbarch, SIM_SH64_NR_REGS);
2868   set_gdbarch_deprecated_register_bytes (gdbarch,
2869                                          ((SIM_SH64_NR_FP_REGS + 1) * 4)
2870                                          + (SIM_SH64_NR_REGS - SIM_SH64_NR_FP_REGS -1) * 8);
2871
2872   set_gdbarch_register_name (gdbarch, sh64_register_name);
2873   set_gdbarch_register_type (gdbarch, sh64_register_type);
2874   set_gdbarch_deprecated_store_return_value (gdbarch, sh64_store_return_value);
2875   set_gdbarch_deprecated_register_byte (gdbarch, sh64_register_byte);
2876   set_gdbarch_pseudo_register_read (gdbarch, sh64_pseudo_register_read);
2877   set_gdbarch_pseudo_register_write (gdbarch, sh64_pseudo_register_write);
2878
2879   set_gdbarch_deprecated_do_registers_info (gdbarch, sh64_do_registers_info);
2880   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, sh64_nofp_frame_init_saved_regs);
2881   set_gdbarch_breakpoint_from_pc (gdbarch, sh64_breakpoint_from_pc);
2882   set_gdbarch_deprecated_call_dummy_words (gdbarch, sh64_call_dummy_words);
2883   set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (sh64_call_dummy_words));
2884
2885   set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sh64_init_extra_frame_info);
2886   set_gdbarch_deprecated_frame_chain (gdbarch, sh64_frame_chain);
2887   set_gdbarch_deprecated_get_saved_register (gdbarch, sh64_get_saved_register);
2888   set_gdbarch_deprecated_extract_return_value (gdbarch, sh64_extract_return_value);
2889   set_gdbarch_deprecated_push_arguments (gdbarch, sh64_push_arguments);
2890   set_gdbarch_deprecated_push_return_address (gdbarch, sh64_push_return_address);
2891   set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
2892   set_gdbarch_deprecated_store_struct_return (gdbarch, sh64_store_struct_return);
2893   set_gdbarch_deprecated_extract_struct_value_address (gdbarch, sh64_extract_struct_value_address);
2894   set_gdbarch_use_struct_convention (gdbarch, sh64_use_struct_convention);
2895   set_gdbarch_deprecated_pop_frame (gdbarch, sh64_pop_frame);
2896   set_gdbarch_elf_make_msymbol_special (gdbarch,
2897                                         sh64_elf_make_msymbol_special);
2898
2899   /* Hook in ABI-specific overrides, if they have been registered.  */
2900   gdbarch_init_osabi (info, gdbarch);
2901
2902   return gdbarch;
2903 }