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