GDB (xrefs)

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