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