gdb/sh64-tdep.c

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