]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gdb/sh-tdep.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* sh-tdep.c (sh_linux_svr4_fetch_link_map_offsets): Remove function.
[thirdparty/binutils-gdb.git] / gdb / sh-tdep.c
1 /* Target-dependent code for Renesas Super-H, for GDB.
2
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 /*
24 Contributed by Steve Chamberlain
25 sac@cygnus.com
26 */
27
28 #include "defs.h"
29 #include "frame.h"
30 #include "frame-base.h"
31 #include "frame-unwind.h"
32 #include "dwarf2-frame.h"
33 #include "symtab.h"
34 #include "gdbtypes.h"
35 #include "gdbcmd.h"
36 #include "gdbcore.h"
37 #include "value.h"
38 #include "dis-asm.h"
39 #include "inferior.h"
40 #include "gdb_string.h"
41 #include "gdb_assert.h"
42 #include "arch-utils.h"
43 #include "floatformat.h"
44 #include "regcache.h"
45 #include "doublest.h"
46 #include "osabi.h"
47
48 #include "sh-tdep.h"
49
50 #include "elf-bfd.h"
51 #include "solib-svr4.h"
52
53 /* sh flags */
54 #include "elf/sh.h"
55 /* registers numbers shared with the simulator */
56 #include "gdb/sim-sh.h"
57
58 static void (*sh_show_regs) (void);
59
60 #define SH_NUM_REGS 67
61
62 struct sh_frame_cache
63 {
64 /* Base address. */
65 CORE_ADDR base;
66 LONGEST sp_offset;
67 CORE_ADDR pc;
68
69 /* Flag showing that a frame has been created in the prologue code. */
70 int uses_fp;
71
72 /* Saved registers. */
73 CORE_ADDR saved_regs[SH_NUM_REGS];
74 CORE_ADDR saved_sp;
75 };
76
77 static const char *
78 sh_sh_register_name (int reg_nr)
79 {
80 static char *register_names[] = {
81 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
82 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
83 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
84 "", "",
85 "", "", "", "", "", "", "", "",
86 "", "", "", "", "", "", "", "",
87 "", "",
88 "", "", "", "", "", "", "", "",
89 "", "", "", "", "", "", "", "",
90 "", "", "", "", "", "", "", "",
91 };
92 if (reg_nr < 0)
93 return NULL;
94 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
95 return NULL;
96 return register_names[reg_nr];
97 }
98
99 static const char *
100 sh_sh3_register_name (int reg_nr)
101 {
102 static char *register_names[] = {
103 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
104 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
105 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
106 "", "",
107 "", "", "", "", "", "", "", "",
108 "", "", "", "", "", "", "", "",
109 "ssr", "spc",
110 "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
111 "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1"
112 "", "", "", "", "", "", "", "",
113 };
114 if (reg_nr < 0)
115 return NULL;
116 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
117 return NULL;
118 return register_names[reg_nr];
119 }
120
121 static const char *
122 sh_sh3e_register_name (int reg_nr)
123 {
124 static char *register_names[] = {
125 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
126 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
127 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
128 "fpul", "fpscr",
129 "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
130 "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
131 "ssr", "spc",
132 "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
133 "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
134 "", "", "", "", "", "", "", "",
135 };
136 if (reg_nr < 0)
137 return NULL;
138 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
139 return NULL;
140 return register_names[reg_nr];
141 }
142
143 static const char *
144 sh_sh2e_register_name (int reg_nr)
145 {
146 static char *register_names[] = {
147 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
148 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
149 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
150 "fpul", "fpscr",
151 "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
152 "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
153 "", "",
154 "", "", "", "", "", "", "", "",
155 "", "", "", "", "", "", "", "",
156 "", "", "", "", "", "", "", "",
157 };
158 if (reg_nr < 0)
159 return NULL;
160 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
161 return NULL;
162 return register_names[reg_nr];
163 }
164
165 static const char *
166 sh_sh2a_register_name (int reg_nr)
167 {
168 static char *register_names[] = {
169 /* general registers 0-15 */
170 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
171 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
172 /* 16 - 22 */
173 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
174 /* 23, 24 */
175 "fpul", "fpscr",
176 /* floating point registers 25 - 40 */
177 "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
178 "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
179 /* 41, 42 */
180 "", "",
181 /* 43 - 62. Banked registers. The bank number used is determined by
182 the bank register (63). */
183 "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b",
184 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b",
185 "machb", "ivnb", "prb", "gbrb", "maclb",
186 /* 63: register bank number, not a real register but used to
187 communicate the register bank currently get/set. This register
188 is hidden to the user, who manipulates it using the pseudo
189 register called "bank" (67). See below. */
190 "",
191 /* 64 - 66 */
192 "ibcr", "ibnr", "tbr",
193 /* 67: register bank number, the user visible pseudo register. */
194 "bank",
195 /* double precision (pseudo) 68 - 75 */
196 "dr0", "dr2", "dr4", "dr6", "dr8", "dr10", "dr12", "dr14",
197 };
198 if (reg_nr < 0)
199 return NULL;
200 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
201 return NULL;
202 return register_names[reg_nr];
203 }
204
205 static const char *
206 sh_sh2a_nofpu_register_name (int reg_nr)
207 {
208 static char *register_names[] = {
209 /* general registers 0-15 */
210 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
211 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
212 /* 16 - 22 */
213 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
214 /* 23, 24 */
215 "", "",
216 /* floating point registers 25 - 40 */
217 "", "", "", "", "", "", "", "",
218 "", "", "", "", "", "", "", "",
219 /* 41, 42 */
220 "", "",
221 /* 43 - 62. Banked registers. The bank number used is determined by
222 the bank register (63). */
223 "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b",
224 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b",
225 "machb", "ivnb", "prb", "gbrb", "maclb",
226 /* 63: register bank number, not a real register but used to
227 communicate the register bank currently get/set. This register
228 is hidden to the user, who manipulates it using the pseudo
229 register called "bank" (67). See below. */
230 "",
231 /* 64 - 66 */
232 "ibcr", "ibnr", "tbr",
233 /* 67: register bank number, the user visible pseudo register. */
234 "bank",
235 /* double precision (pseudo) 68 - 75 */
236 "", "", "", "", "", "", "", "",
237 };
238 if (reg_nr < 0)
239 return NULL;
240 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
241 return NULL;
242 return register_names[reg_nr];
243 }
244
245 static const char *
246 sh_sh_dsp_register_name (int reg_nr)
247 {
248 static char *register_names[] = {
249 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
250 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
251 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
252 "", "dsr",
253 "a0g", "a0", "a1g", "a1", "m0", "m1", "x0", "x1",
254 "y0", "y1", "", "", "", "", "", "mod",
255 "", "",
256 "rs", "re", "", "", "", "", "", "",
257 "", "", "", "", "", "", "", "",
258 "", "", "", "", "", "", "", "",
259 };
260 if (reg_nr < 0)
261 return NULL;
262 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
263 return NULL;
264 return register_names[reg_nr];
265 }
266
267 static const char *
268 sh_sh3_dsp_register_name (int reg_nr)
269 {
270 static char *register_names[] = {
271 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
272 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
273 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
274 "", "dsr",
275 "a0g", "a0", "a1g", "a1", "m0", "m1", "x0", "x1",
276 "y0", "y1", "", "", "", "", "", "mod",
277 "ssr", "spc",
278 "rs", "re", "", "", "", "", "", "",
279 "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b",
280 "", "", "", "", "", "", "", "",
281 "", "", "", "", "", "", "", "",
282 };
283 if (reg_nr < 0)
284 return NULL;
285 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
286 return NULL;
287 return register_names[reg_nr];
288 }
289
290 static const char *
291 sh_sh4_register_name (int reg_nr)
292 {
293 static char *register_names[] = {
294 /* general registers 0-15 */
295 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
296 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
297 /* 16 - 22 */
298 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
299 /* 23, 24 */
300 "fpul", "fpscr",
301 /* floating point registers 25 - 40 */
302 "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
303 "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
304 /* 41, 42 */
305 "ssr", "spc",
306 /* bank 0 43 - 50 */
307 "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
308 /* bank 1 51 - 58 */
309 "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
310 "", "", "", "", "", "", "", "",
311 /* pseudo bank register. */
312 "",
313 /* double precision (pseudo) 59 - 66 */
314 "dr0", "dr2", "dr4", "dr6", "dr8", "dr10", "dr12", "dr14",
315 /* vectors (pseudo) 67 - 70 */
316 "fv0", "fv4", "fv8", "fv12",
317 /* FIXME: missing XF 71 - 86 */
318 /* FIXME: missing XD 87 - 94 */
319 };
320 if (reg_nr < 0)
321 return NULL;
322 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
323 return NULL;
324 return register_names[reg_nr];
325 }
326
327 static const char *
328 sh_sh4_nofpu_register_name (int reg_nr)
329 {
330 static char *register_names[] = {
331 /* general registers 0-15 */
332 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
333 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
334 /* 16 - 22 */
335 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
336 /* 23, 24 */
337 "", "",
338 /* floating point registers 25 - 40 -- not for nofpu target */
339 "", "", "", "", "", "", "", "",
340 "", "", "", "", "", "", "", "",
341 /* 41, 42 */
342 "ssr", "spc",
343 /* bank 0 43 - 50 */
344 "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
345 /* bank 1 51 - 58 */
346 "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
347 "", "", "", "", "", "", "", "",
348 /* pseudo bank register. */
349 "",
350 /* double precision (pseudo) 59 - 66 -- not for nofpu target */
351 "", "", "", "", "", "", "", "",
352 /* vectors (pseudo) 67 - 70 -- not for nofpu target */
353 "", "", "", "",
354 };
355 if (reg_nr < 0)
356 return NULL;
357 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
358 return NULL;
359 return register_names[reg_nr];
360 }
361
362 static const char *
363 sh_sh4al_dsp_register_name (int reg_nr)
364 {
365 static char *register_names[] = {
366 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
367 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
368 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
369 "", "dsr",
370 "a0g", "a0", "a1g", "a1", "m0", "m1", "x0", "x1",
371 "y0", "y1", "", "", "", "", "", "mod",
372 "ssr", "spc",
373 "rs", "re", "", "", "", "", "", "",
374 "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b",
375 "", "", "", "", "", "", "", "",
376 "", "", "", "", "", "", "", "",
377 };
378 if (reg_nr < 0)
379 return NULL;
380 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
381 return NULL;
382 return register_names[reg_nr];
383 }
384
385 static const unsigned char *
386 sh_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
387 {
388 /* 0xc3c3 is trapa #c3, and it works in big and little endian modes */
389 static unsigned char breakpoint[] = { 0xc3, 0xc3 };
390
391 *lenptr = sizeof (breakpoint);
392 return breakpoint;
393 }
394
395 /* Prologue looks like
396 mov.l r14,@-r15
397 sts.l pr,@-r15
398 mov.l <regs>,@-r15
399 sub <room_for_loca_vars>,r15
400 mov r15,r14
401
402 Actually it can be more complicated than this but that's it, basically.
403 */
404
405 #define GET_SOURCE_REG(x) (((x) >> 4) & 0xf)
406 #define GET_TARGET_REG(x) (((x) >> 8) & 0xf)
407
408 /* JSR @Rm 0100mmmm00001011 */
409 #define IS_JSR(x) (((x) & 0xf0ff) == 0x400b)
410
411 /* STS.L PR,@-r15 0100111100100010
412 r15-4-->r15, PR-->(r15) */
413 #define IS_STS(x) ((x) == 0x4f22)
414
415 /* STS.L MACL,@-r15 0100111100010010
416 r15-4-->r15, MACL-->(r15) */
417 #define IS_MACL_STS(x) ((x) == 0x4f12)
418
419 /* MOV.L Rm,@-r15 00101111mmmm0110
420 r15-4-->r15, Rm-->(R15) */
421 #define IS_PUSH(x) (((x) & 0xff0f) == 0x2f06)
422
423 /* MOV r15,r14 0110111011110011
424 r15-->r14 */
425 #define IS_MOV_SP_FP(x) ((x) == 0x6ef3)
426
427 /* ADD #imm,r15 01111111iiiiiiii
428 r15+imm-->r15 */
429 #define IS_ADD_IMM_SP(x) (((x) & 0xff00) == 0x7f00)
430
431 #define IS_MOV_R3(x) (((x) & 0xff00) == 0x1a00)
432 #define IS_SHLL_R3(x) ((x) == 0x4300)
433
434 /* ADD r3,r15 0011111100111100
435 r15+r3-->r15 */
436 #define IS_ADD_R3SP(x) ((x) == 0x3f3c)
437
438 /* FMOV.S FRm,@-Rn Rn-4-->Rn, FRm-->(Rn) 1111nnnnmmmm1011
439 FMOV DRm,@-Rn Rn-8-->Rn, DRm-->(Rn) 1111nnnnmmm01011
440 FMOV XDm,@-Rn Rn-8-->Rn, XDm-->(Rn) 1111nnnnmmm11011 */
441 /* CV, 2003-08-28: Only suitable with Rn == SP, therefore name changed to
442 make this entirely clear. */
443 /* #define IS_FMOV(x) (((x) & 0xf00f) == 0xf00b) */
444 #define IS_FPUSH(x) (((x) & 0xff0f) == 0xff0b)
445
446 /* MOV Rm,Rn Rm-->Rn 0110nnnnmmmm0011 4 <= m <= 7 */
447 #define IS_MOV_ARG_TO_REG(x) \
448 (((x) & 0xf00f) == 0x6003 && \
449 ((x) & 0x00f0) >= 0x0040 && \
450 ((x) & 0x00f0) <= 0x0070)
451 /* MOV.L Rm,@Rn 0010nnnnmmmm0010 n = 14, 4 <= m <= 7 */
452 #define IS_MOV_ARG_TO_IND_R14(x) \
453 (((x) & 0xff0f) == 0x2e02 && \
454 ((x) & 0x00f0) >= 0x0040 && \
455 ((x) & 0x00f0) <= 0x0070)
456 /* MOV.L Rm,@(disp*4,Rn) 00011110mmmmdddd n = 14, 4 <= m <= 7 */
457 #define IS_MOV_ARG_TO_IND_R14_WITH_DISP(x) \
458 (((x) & 0xff00) == 0x1e00 && \
459 ((x) & 0x00f0) >= 0x0040 && \
460 ((x) & 0x00f0) <= 0x0070)
461
462 /* MOV.W @(disp*2,PC),Rn 1001nnnndddddddd */
463 #define IS_MOVW_PCREL_TO_REG(x) (((x) & 0xf000) == 0x9000)
464 /* MOV.L @(disp*4,PC),Rn 1101nnnndddddddd */
465 #define IS_MOVL_PCREL_TO_REG(x) (((x) & 0xf000) == 0xd000)
466 /* MOVI20 #imm20,Rn 0000nnnniiii0000 */
467 #define IS_MOVI20(x) (((x) & 0xf00f) == 0x0000)
468 /* SUB Rn,R15 00111111nnnn1000 */
469 #define IS_SUB_REG_FROM_SP(x) (((x) & 0xff0f) == 0x3f08)
470
471 #define FPSCR_SZ (1 << 20)
472
473 /* The following instructions are used for epilogue testing. */
474 #define IS_RESTORE_FP(x) ((x) == 0x6ef6)
475 #define IS_RTS(x) ((x) == 0x000b)
476 #define IS_LDS(x) ((x) == 0x4f26)
477 #define IS_MACL_LDS(x) ((x) == 0x4f16)
478 #define IS_MOV_FP_SP(x) ((x) == 0x6fe3)
479 #define IS_ADD_REG_TO_FP(x) (((x) & 0xff0f) == 0x3e0c)
480 #define IS_ADD_IMM_FP(x) (((x) & 0xff00) == 0x7e00)
481
482 /* Disassemble an instruction. */
483 static int
484 gdb_print_insn_sh (bfd_vma memaddr, disassemble_info * info)
485 {
486 info->endian = TARGET_BYTE_ORDER;
487 return print_insn_sh (memaddr, info);
488 }
489
490 static CORE_ADDR
491 sh_analyze_prologue (CORE_ADDR pc, CORE_ADDR current_pc,
492 struct sh_frame_cache *cache)
493 {
494 ULONGEST inst;
495 CORE_ADDR opc;
496 int offset;
497 int sav_offset = 0;
498 int r3_val = 0;
499 int reg, sav_reg = -1;
500
501 if (pc >= current_pc)
502 return current_pc;
503
504 cache->uses_fp = 0;
505 for (opc = pc + (2 * 28); pc < opc; pc += 2)
506 {
507 inst = read_memory_unsigned_integer (pc, 2);
508 /* See where the registers will be saved to */
509 if (IS_PUSH (inst))
510 {
511 cache->saved_regs[GET_SOURCE_REG (inst)] = cache->sp_offset;
512 cache->sp_offset += 4;
513 }
514 else if (IS_STS (inst))
515 {
516 cache->saved_regs[PR_REGNUM] = cache->sp_offset;
517 cache->sp_offset += 4;
518 }
519 else if (IS_MACL_STS (inst))
520 {
521 cache->saved_regs[MACL_REGNUM] = cache->sp_offset;
522 cache->sp_offset += 4;
523 }
524 else if (IS_MOV_R3 (inst))
525 {
526 r3_val = ((inst & 0xff) ^ 0x80) - 0x80;
527 }
528 else if (IS_SHLL_R3 (inst))
529 {
530 r3_val <<= 1;
531 }
532 else if (IS_ADD_R3SP (inst))
533 {
534 cache->sp_offset += -r3_val;
535 }
536 else if (IS_ADD_IMM_SP (inst))
537 {
538 offset = ((inst & 0xff) ^ 0x80) - 0x80;
539 cache->sp_offset -= offset;
540 }
541 else if (IS_MOVW_PCREL_TO_REG (inst))
542 {
543 if (sav_reg < 0)
544 {
545 reg = GET_TARGET_REG (inst);
546 if (reg < 14)
547 {
548 sav_reg = reg;
549 offset = (inst & 0xff) << 1;
550 sav_offset =
551 read_memory_integer ((pc + 4) + offset, 2);
552 }
553 }
554 }
555 else if (IS_MOVL_PCREL_TO_REG (inst))
556 {
557 if (sav_reg < 0)
558 {
559 reg = GET_TARGET_REG (inst);
560 if (reg < 14)
561 {
562 sav_reg = reg;
563 offset = (inst & 0xff) << 2;
564 sav_offset =
565 read_memory_integer (((pc & 0xfffffffc) + 4) + offset, 4);
566 }
567 }
568 }
569 else if (IS_MOVI20 (inst))
570 {
571 if (sav_reg < 0)
572 {
573 reg = GET_TARGET_REG (inst);
574 if (reg < 14)
575 {
576 sav_reg = reg;
577 sav_offset = GET_SOURCE_REG (inst) << 16;
578 /* MOVI20 is a 32 bit instruction! */
579 pc += 2;
580 sav_offset |= read_memory_unsigned_integer (pc, 2);
581 /* Now sav_offset contains an unsigned 20 bit value.
582 It must still get sign extended. */
583 if (sav_offset & 0x00080000)
584 sav_offset |= 0xfff00000;
585 }
586 }
587 }
588 else if (IS_SUB_REG_FROM_SP (inst))
589 {
590 reg = GET_SOURCE_REG (inst);
591 if (sav_reg > 0 && reg == sav_reg)
592 {
593 sav_reg = -1;
594 }
595 cache->sp_offset += sav_offset;
596 }
597 else if (IS_FPUSH (inst))
598 {
599 if (read_register (FPSCR_REGNUM) & FPSCR_SZ)
600 {
601 cache->sp_offset += 8;
602 }
603 else
604 {
605 cache->sp_offset += 4;
606 }
607 }
608 else if (IS_MOV_SP_FP (inst))
609 {
610 cache->uses_fp = 1;
611 /* At this point, only allow argument register moves to other
612 registers or argument register moves to @(X,fp) which are
613 moving the register arguments onto the stack area allocated
614 by a former add somenumber to SP call. Don't allow moving
615 to an fp indirect address above fp + cache->sp_offset. */
616 pc += 2;
617 for (opc = pc + 12; pc < opc; pc += 2)
618 {
619 inst = read_memory_integer (pc, 2);
620 if (IS_MOV_ARG_TO_IND_R14 (inst))
621 {
622 reg = GET_SOURCE_REG (inst);
623 if (cache->sp_offset > 0)
624 cache->saved_regs[reg] = cache->sp_offset;
625 }
626 else if (IS_MOV_ARG_TO_IND_R14_WITH_DISP (inst))
627 {
628 reg = GET_SOURCE_REG (inst);
629 offset = (inst & 0xf) * 4;
630 if (cache->sp_offset > offset)
631 cache->saved_regs[reg] = cache->sp_offset - offset;
632 }
633 else if (IS_MOV_ARG_TO_REG (inst))
634 continue;
635 else
636 break;
637 }
638 break;
639 }
640 else if (IS_JSR (inst))
641 {
642 /* We have found a jsr that has been scheduled into the prologue.
643 If we continue the scan and return a pc someplace after this,
644 then setting a breakpoint on this function will cause it to
645 appear to be called after the function it is calling via the
646 jsr, which will be very confusing. Most likely the next
647 instruction is going to be IS_MOV_SP_FP in the delay slot. If
648 so, note that before returning the current pc. */
649 inst = read_memory_integer (pc + 2, 2);
650 if (IS_MOV_SP_FP (inst))
651 cache->uses_fp = 1;
652 break;
653 }
654 #if 0 /* This used to just stop when it found an instruction that
655 was not considered part of the prologue. Now, we just
656 keep going looking for likely instructions. */
657 else
658 break;
659 #endif
660 }
661
662 return pc;
663 }
664
665 /* Skip any prologue before the guts of a function */
666
667 /* Skip the prologue using the debug information. If this fails we'll
668 fall back on the 'guess' method below. */
669 static CORE_ADDR
670 after_prologue (CORE_ADDR pc)
671 {
672 struct symtab_and_line sal;
673 CORE_ADDR func_addr, func_end;
674
675 /* If we can not find the symbol in the partial symbol table, then
676 there is no hope we can determine the function's start address
677 with this code. */
678 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
679 return 0;
680
681 /* Get the line associated with FUNC_ADDR. */
682 sal = find_pc_line (func_addr, 0);
683
684 /* There are only two cases to consider. First, the end of the source line
685 is within the function bounds. In that case we return the end of the
686 source line. Second is the end of the source line extends beyond the
687 bounds of the current function. We need to use the slow code to
688 examine instructions in that case. */
689 if (sal.end < func_end)
690 return sal.end;
691 else
692 return 0;
693 }
694
695 static CORE_ADDR
696 sh_skip_prologue (CORE_ADDR start_pc)
697 {
698 CORE_ADDR pc;
699 struct sh_frame_cache cache;
700
701 /* See if we can determine the end of the prologue via the symbol table.
702 If so, then return either PC, or the PC after the prologue, whichever
703 is greater. */
704 pc = after_prologue (start_pc);
705
706 /* If after_prologue returned a useful address, then use it. Else
707 fall back on the instruction skipping code. */
708 if (pc)
709 return max (pc, start_pc);
710
711 cache.sp_offset = -4;
712 pc = sh_analyze_prologue (start_pc, (CORE_ADDR) -1, &cache);
713 if (!cache.uses_fp)
714 return start_pc;
715
716 return pc;
717 }
718
719 /* The ABI says:
720
721 Aggregate types not bigger than 8 bytes that have the same size and
722 alignment as one of the integer scalar types are returned in the
723 same registers as the integer type they match.
724
725 For example, a 2-byte aligned structure with size 2 bytes has the
726 same size and alignment as a short int, and will be returned in R0.
727 A 4-byte aligned structure with size 8 bytes has the same size and
728 alignment as a long long int, and will be returned in R0 and R1.
729
730 When an aggregate type is returned in R0 and R1, R0 contains the
731 first four bytes of the aggregate, and R1 contains the
732 remainder. If the size of the aggregate type is not a multiple of 4
733 bytes, the aggregate is tail-padded up to a multiple of 4
734 bytes. The value of the padding is undefined. For little-endian
735 targets the padding will appear at the most significant end of the
736 last element, for big-endian targets the padding appears at the
737 least significant end of the last element.
738
739 All other aggregate types are returned by address. The caller
740 function passes the address of an area large enough to hold the
741 aggregate value in R2. The called function stores the result in
742 this location.
743
744 To reiterate, structs smaller than 8 bytes could also be returned
745 in memory, if they don't pass the "same size and alignment as an
746 integer type" rule.
747
748 For example, in
749
750 struct s { char c[3]; } wibble;
751 struct s foo(void) { return wibble; }
752
753 the return value from foo() will be in memory, not
754 in R0, because there is no 3-byte integer type.
755
756 Similarly, in
757
758 struct s { char c[2]; } wibble;
759 struct s foo(void) { return wibble; }
760
761 because a struct containing two chars has alignment 1, that matches
762 type char, but size 2, that matches type short. There's no integer
763 type that has alignment 1 and size 2, so the struct is returned in
764 memory.
765
766 */
767
768 static int
769 sh_use_struct_convention (int gcc_p, struct type *type)
770 {
771 int len = TYPE_LENGTH (type);
772 int nelem = TYPE_NFIELDS (type);
773
774 /* Non-power of 2 length types and types bigger than 8 bytes (which don't
775 fit in two registers anyway) use struct convention. */
776 if (len != 1 && len != 2 && len != 4 && len != 8)
777 return 1;
778
779 /* Scalar types and aggregate types with exactly one field are aligned
780 by definition. They are returned in registers. */
781 if (nelem <= 1)
782 return 0;
783
784 /* If the first field in the aggregate has the same length as the entire
785 aggregate type, the type is returned in registers. */
786 if (TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == len)
787 return 0;
788
789 /* If the size of the aggregate is 8 bytes and the first field is
790 of size 4 bytes its alignment is equal to long long's alignment,
791 so it's returned in registers. */
792 if (len == 8 && TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == 4)
793 return 0;
794
795 /* Otherwise use struct convention. */
796 return 1;
797 }
798
799 /* Extract from an array REGBUF containing the (raw) register state
800 the address in which a function should return its structure value,
801 as a CORE_ADDR (or an expression that can be used as one). */
802 static CORE_ADDR
803 sh_extract_struct_value_address (struct regcache *regcache)
804 {
805 ULONGEST addr;
806
807 regcache_cooked_read_unsigned (regcache, STRUCT_RETURN_REGNUM, &addr);
808 return addr;
809 }
810
811 static CORE_ADDR
812 sh_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
813 {
814 return sp & ~3;
815 }
816
817 /* Function: push_dummy_call (formerly push_arguments)
818 Setup the function arguments for calling a function in the inferior.
819
820 On the Renesas SH architecture, there are four registers (R4 to R7)
821 which are dedicated for passing function arguments. Up to the first
822 four arguments (depending on size) may go into these registers.
823 The rest go on the stack.
824
825 MVS: Except on SH variants that have floating point registers.
826 In that case, float and double arguments are passed in the same
827 manner, but using FP registers instead of GP registers.
828
829 Arguments that are smaller than 4 bytes will still take up a whole
830 register or a whole 32-bit word on the stack, and will be
831 right-justified in the register or the stack word. This includes
832 chars, shorts, and small aggregate types.
833
834 Arguments that are larger than 4 bytes may be split between two or
835 more registers. If there are not enough registers free, an argument
836 may be passed partly in a register (or registers), and partly on the
837 stack. This includes doubles, long longs, and larger aggregates.
838 As far as I know, there is no upper limit to the size of aggregates
839 that will be passed in this way; in other words, the convention of
840 passing a pointer to a large aggregate instead of a copy is not used.
841
842 MVS: The above appears to be true for the SH variants that do not
843 have an FPU, however those that have an FPU appear to copy the
844 aggregate argument onto the stack (and not place it in registers)
845 if it is larger than 16 bytes (four GP registers).
846
847 An exceptional case exists for struct arguments (and possibly other
848 aggregates such as arrays) if the size is larger than 4 bytes but
849 not a multiple of 4 bytes. In this case the argument is never split
850 between the registers and the stack, but instead is copied in its
851 entirety onto the stack, AND also copied into as many registers as
852 there is room for. In other words, space in registers permitting,
853 two copies of the same argument are passed in. As far as I can tell,
854 only the one on the stack is used, although that may be a function
855 of the level of compiler optimization. I suspect this is a compiler
856 bug. Arguments of these odd sizes are left-justified within the
857 word (as opposed to arguments smaller than 4 bytes, which are
858 right-justified).
859
860 If the function is to return an aggregate type such as a struct, it
861 is either returned in the normal return value register R0 (if its
862 size is no greater than one byte), or else the caller must allocate
863 space into which the callee will copy the return value (if the size
864 is greater than one byte). In this case, a pointer to the return
865 value location is passed into the callee in register R2, which does
866 not displace any of the other arguments passed in via registers R4
867 to R7. */
868
869 /* Helper function to justify value in register according to endianess. */
870 static char *
871 sh_justify_value_in_reg (struct value *val, int len)
872 {
873 static char valbuf[4];
874
875 memset (valbuf, 0, sizeof (valbuf));
876 if (len < 4)
877 {
878 /* value gets right-justified in the register or stack word */
879 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
880 memcpy (valbuf + (4 - len), (char *) value_contents (val), len);
881 else
882 memcpy (valbuf, (char *) value_contents (val), len);
883 return valbuf;
884 }
885 return (char *) value_contents (val);
886 }
887
888 /* Helper function to eval number of bytes to allocate on stack. */
889 static CORE_ADDR
890 sh_stack_allocsize (int nargs, struct value **args)
891 {
892 int stack_alloc = 0;
893 while (nargs-- > 0)
894 stack_alloc += ((TYPE_LENGTH (value_type (args[nargs])) + 3) & ~3);
895 return stack_alloc;
896 }
897
898 /* Helper functions for getting the float arguments right. Registers usage
899 depends on the ABI and the endianess. The comments should enlighten how
900 it's intended to work. */
901
902 /* This array stores which of the float arg registers are already in use. */
903 static int flt_argreg_array[FLOAT_ARGLAST_REGNUM - FLOAT_ARG0_REGNUM + 1];
904
905 /* This function just resets the above array to "no reg used so far". */
906 static void
907 sh_init_flt_argreg (void)
908 {
909 memset (flt_argreg_array, 0, sizeof flt_argreg_array);
910 }
911
912 /* This function returns the next register to use for float arg passing.
913 It returns either a valid value between FLOAT_ARG0_REGNUM and
914 FLOAT_ARGLAST_REGNUM if a register is available, otherwise it returns
915 FLOAT_ARGLAST_REGNUM + 1 to indicate that no register is available.
916
917 Note that register number 0 in flt_argreg_array corresponds with the
918 real float register fr4. In contrast to FLOAT_ARG0_REGNUM (value is
919 29) the parity of the register number is preserved, which is important
920 for the double register passing test (see the "argreg & 1" test below). */
921 static int
922 sh_next_flt_argreg (int len)
923 {
924 int argreg;
925
926 /* First search for the next free register. */
927 for (argreg = 0; argreg <= FLOAT_ARGLAST_REGNUM - FLOAT_ARG0_REGNUM;
928 ++argreg)
929 if (!flt_argreg_array[argreg])
930 break;
931
932 /* No register left? */
933 if (argreg > FLOAT_ARGLAST_REGNUM - FLOAT_ARG0_REGNUM)
934 return FLOAT_ARGLAST_REGNUM + 1;
935
936 if (len == 8)
937 {
938 /* Doubles are always starting in a even register number. */
939 if (argreg & 1)
940 {
941 flt_argreg_array[argreg] = 1;
942
943 ++argreg;
944
945 /* No register left? */
946 if (argreg > FLOAT_ARGLAST_REGNUM - FLOAT_ARG0_REGNUM)
947 return FLOAT_ARGLAST_REGNUM + 1;
948 }
949 /* Also mark the next register as used. */
950 flt_argreg_array[argreg + 1] = 1;
951 }
952 else if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
953 {
954 /* In little endian, gcc passes floats like this: f5, f4, f7, f6, ... */
955 if (!flt_argreg_array[argreg + 1])
956 ++argreg;
957 }
958 flt_argreg_array[argreg] = 1;
959 return FLOAT_ARG0_REGNUM + argreg;
960 }
961
962 /* Helper function which figures out, if a type is treated like a float type.
963
964 The FPU ABIs have a special way how to treat types as float types.
965 Structures with exactly one member, which is of type float or double, are
966 treated exactly as the base types float or double:
967
968 struct sf {
969 float f;
970 };
971
972 struct sd {
973 double d;
974 };
975
976 are handled the same way as just
977
978 float f;
979
980 double d;
981
982 As a result, arguments of these struct types are pushed into floating point
983 registers exactly as floats or doubles, using the same decision algorithm.
984
985 The same is valid if these types are used as function return types. The
986 above structs are returned in fr0 resp. fr0,fr1 instead of in r0, r0,r1
987 or even using struct convention as it is for other structs. */
988
989 static int
990 sh_treat_as_flt_p (struct type *type)
991 {
992 int len = TYPE_LENGTH (type);
993
994 /* Ordinary float types are obviously treated as float. */
995 if (TYPE_CODE (type) == TYPE_CODE_FLT)
996 return 1;
997 /* Otherwise non-struct types are not treated as float. */
998 if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
999 return 0;
1000 /* Otherwise structs with more than one memeber are not treated as float. */
1001 if (TYPE_NFIELDS (type) != 1)
1002 return 0;
1003 /* Otherwise if the type of that member is float, the whole type is
1004 treated as float. */
1005 if (TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_FLT)
1006 return 1;
1007 /* Otherwise it's not treated as float. */
1008 return 0;
1009 }
1010
1011 static CORE_ADDR
1012 sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
1013 struct value *function,
1014 struct regcache *regcache,
1015 CORE_ADDR bp_addr, int nargs,
1016 struct value **args,
1017 CORE_ADDR sp, int struct_return,
1018 CORE_ADDR struct_addr)
1019 {
1020 int stack_offset = 0;
1021 int argreg = ARG0_REGNUM;
1022 int flt_argreg = 0;
1023 int argnum;
1024 struct type *type;
1025 CORE_ADDR regval;
1026 char *val;
1027 int len, reg_size = 0;
1028 int pass_on_stack = 0;
1029 int treat_as_flt;
1030
1031 /* first force sp to a 4-byte alignment */
1032 sp = sh_frame_align (gdbarch, sp);
1033
1034 if (struct_return)
1035 regcache_cooked_write_unsigned (regcache,
1036 STRUCT_RETURN_REGNUM, struct_addr);
1037
1038 /* make room on stack for args */
1039 sp -= sh_stack_allocsize (nargs, args);
1040
1041 /* Initialize float argument mechanism. */
1042 sh_init_flt_argreg ();
1043
1044 /* Now load as many as possible of the first arguments into
1045 registers, and push the rest onto the stack. There are 16 bytes
1046 in four registers available. Loop thru args from first to last. */
1047 for (argnum = 0; argnum < nargs; argnum++)
1048 {
1049 type = value_type (args[argnum]);
1050 len = TYPE_LENGTH (type);
1051 val = sh_justify_value_in_reg (args[argnum], len);
1052
1053 /* Some decisions have to be made how various types are handled.
1054 This also differs in different ABIs. */
1055 pass_on_stack = 0;
1056
1057 /* Find out the next register to use for a floating point value. */
1058 treat_as_flt = sh_treat_as_flt_p (type);
1059 if (treat_as_flt)
1060 flt_argreg = sh_next_flt_argreg (len);
1061 /* In contrast to non-FPU CPUs, arguments are never split between
1062 registers and stack. If an argument doesn't fit in the remaining
1063 registers it's always pushed entirely on the stack. */
1064 else if (len > ((ARGLAST_REGNUM - argreg + 1) * 4))
1065 pass_on_stack = 1;
1066
1067 while (len > 0)
1068 {
1069 if ((treat_as_flt && flt_argreg > FLOAT_ARGLAST_REGNUM)
1070 || (!treat_as_flt && (argreg > ARGLAST_REGNUM
1071 || pass_on_stack)))
1072 {
1073 /* The data goes entirely on the stack, 4-byte aligned. */
1074 reg_size = (len + 3) & ~3;
1075 write_memory (sp + stack_offset, val, reg_size);
1076 stack_offset += reg_size;
1077 }
1078 else if (treat_as_flt && flt_argreg <= FLOAT_ARGLAST_REGNUM)
1079 {
1080 /* Argument goes in a float argument register. */
1081 reg_size = register_size (gdbarch, flt_argreg);
1082 regval = extract_unsigned_integer (val, reg_size);
1083 /* In little endian mode, float types taking two registers
1084 (doubles on sh4, long doubles on sh2e, sh3e and sh4) must
1085 be stored swapped in the argument registers. The below
1086 code first writes the first 32 bits in the next but one
1087 register, increments the val and len values accordingly
1088 and then proceeds as normal by writing the second 32 bits
1089 into the next register. */
1090 if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE
1091 && TYPE_LENGTH (type) == 2 * reg_size)
1092 {
1093 regcache_cooked_write_unsigned (regcache, flt_argreg + 1,
1094 regval);
1095 val += reg_size;
1096 len -= reg_size;
1097 regval = extract_unsigned_integer (val, reg_size);
1098 }
1099 regcache_cooked_write_unsigned (regcache, flt_argreg++, regval);
1100 }
1101 else if (!treat_as_flt && argreg <= ARGLAST_REGNUM)
1102 {
1103 /* there's room in a register */
1104 reg_size = register_size (gdbarch, argreg);
1105 regval = extract_unsigned_integer (val, reg_size);
1106 regcache_cooked_write_unsigned (regcache, argreg++, regval);
1107 }
1108 /* Store the value one register at a time or in one step on stack. */
1109 len -= reg_size;
1110 val += reg_size;
1111 }
1112 }
1113
1114 /* Store return address. */
1115 regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
1116
1117 /* Update stack pointer. */
1118 regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp);
1119
1120 return sp;
1121 }
1122
1123 static CORE_ADDR
1124 sh_push_dummy_call_nofpu (struct gdbarch *gdbarch,
1125 struct value *function,
1126 struct regcache *regcache,
1127 CORE_ADDR bp_addr,
1128 int nargs, struct value **args,
1129 CORE_ADDR sp, int struct_return,
1130 CORE_ADDR struct_addr)
1131 {
1132 int stack_offset = 0;
1133 int argreg = ARG0_REGNUM;
1134 int argnum;
1135 struct type *type;
1136 CORE_ADDR regval;
1137 char *val;
1138 int len, reg_size;
1139
1140 /* first force sp to a 4-byte alignment */
1141 sp = sh_frame_align (gdbarch, sp);
1142
1143 if (struct_return)
1144 regcache_cooked_write_unsigned (regcache,
1145 STRUCT_RETURN_REGNUM, struct_addr);
1146
1147 /* make room on stack for args */
1148 sp -= sh_stack_allocsize (nargs, args);
1149
1150 /* Now load as many as possible of the first arguments into
1151 registers, and push the rest onto the stack. There are 16 bytes
1152 in four registers available. Loop thru args from first to last. */
1153 for (argnum = 0; argnum < nargs; argnum++)
1154 {
1155 type = value_type (args[argnum]);
1156 len = TYPE_LENGTH (type);
1157 val = sh_justify_value_in_reg (args[argnum], len);
1158
1159 while (len > 0)
1160 {
1161 if (argreg > ARGLAST_REGNUM)
1162 {
1163 /* The remainder of the data goes entirely on the stack,
1164 4-byte aligned. */
1165 reg_size = (len + 3) & ~3;
1166 write_memory (sp + stack_offset, val, reg_size);
1167 stack_offset += reg_size;
1168 }
1169 else if (argreg <= ARGLAST_REGNUM)
1170 {
1171 /* there's room in a register */
1172 reg_size = register_size (gdbarch, argreg);
1173 regval = extract_unsigned_integer (val, reg_size);
1174 regcache_cooked_write_unsigned (regcache, argreg++, regval);
1175 }
1176 /* Store the value reg_size bytes at a time. This means that things
1177 larger than reg_size bytes may go partly in registers and partly
1178 on the stack. */
1179 len -= reg_size;
1180 val += reg_size;
1181 }
1182 }
1183
1184 /* Store return address. */
1185 regcache_cooked_write_unsigned (regcache, PR_REGNUM, bp_addr);
1186
1187 /* Update stack pointer. */
1188 regcache_cooked_write_unsigned (regcache, SP_REGNUM, sp);
1189
1190 return sp;
1191 }
1192
1193 /* Find a function's return value in the appropriate registers (in
1194 regbuf), and copy it into valbuf. Extract from an array REGBUF
1195 containing the (raw) register state a function return value of type
1196 TYPE, and copy that, in virtual format, into VALBUF. */
1197 static void
1198 sh_extract_return_value_nofpu (struct type *type, struct regcache *regcache,
1199 void *valbuf)
1200 {
1201 int len = TYPE_LENGTH (type);
1202 int return_register = R0_REGNUM;
1203 int offset;
1204
1205 if (len <= 4)
1206 {
1207 ULONGEST c;
1208
1209 regcache_cooked_read_unsigned (regcache, R0_REGNUM, &c);
1210 store_unsigned_integer (valbuf, len, c);
1211 }
1212 else if (len == 8)
1213 {
1214 int i, regnum = R0_REGNUM;
1215 for (i = 0; i < len; i += 4)
1216 regcache_raw_read (regcache, regnum++, (char *) valbuf + i);
1217 }
1218 else
1219 error (_("bad size for return value"));
1220 }
1221
1222 static void
1223 sh_extract_return_value_fpu (struct type *type, struct regcache *regcache,
1224 void *valbuf)
1225 {
1226 if (sh_treat_as_flt_p (type))
1227 {
1228 int len = TYPE_LENGTH (type);
1229 int i, regnum = FP0_REGNUM;
1230 for (i = 0; i < len; i += 4)
1231 if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
1232 regcache_raw_read (regcache, regnum++, (char *) valbuf + len - 4 - i);
1233 else
1234 regcache_raw_read (regcache, regnum++, (char *) valbuf + i);
1235 }
1236 else
1237 sh_extract_return_value_nofpu (type, regcache, valbuf);
1238 }
1239
1240 /* Write into appropriate registers a function return value
1241 of type TYPE, given in virtual format.
1242 If the architecture is sh4 or sh3e, store a function's return value
1243 in the R0 general register or in the FP0 floating point register,
1244 depending on the type of the return value. In all the other cases
1245 the result is stored in r0, left-justified. */
1246 static void
1247 sh_store_return_value_nofpu (struct type *type, struct regcache *regcache,
1248 const void *valbuf)
1249 {
1250 ULONGEST val;
1251 int len = TYPE_LENGTH (type);
1252
1253 if (len <= 4)
1254 {
1255 val = extract_unsigned_integer (valbuf, len);
1256 regcache_cooked_write_unsigned (regcache, R0_REGNUM, val);
1257 }
1258 else
1259 {
1260 int i, regnum = R0_REGNUM;
1261 for (i = 0; i < len; i += 4)
1262 regcache_raw_write (regcache, regnum++, (char *) valbuf + i);
1263 }
1264 }
1265
1266 static void
1267 sh_store_return_value_fpu (struct type *type, struct regcache *regcache,
1268 const void *valbuf)
1269 {
1270 if (sh_treat_as_flt_p (type))
1271 {
1272 int len = TYPE_LENGTH (type);
1273 int i, regnum = FP0_REGNUM;
1274 for (i = 0; i < len; i += 4)
1275 if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
1276 regcache_raw_write (regcache, regnum++,
1277 (char *) valbuf + len - 4 - i);
1278 else
1279 regcache_raw_write (regcache, regnum++, (char *) valbuf + i);
1280 }
1281 else
1282 sh_store_return_value_nofpu (type, regcache, valbuf);
1283 }
1284
1285 static enum return_value_convention
1286 sh_return_value_nofpu (struct gdbarch *gdbarch, struct type *type,
1287 struct regcache *regcache,
1288 void *readbuf, const void *writebuf)
1289 {
1290 if (sh_use_struct_convention (0, type))
1291 return RETURN_VALUE_STRUCT_CONVENTION;
1292 if (writebuf)
1293 sh_store_return_value_nofpu (type, regcache, writebuf);
1294 else if (readbuf)
1295 sh_extract_return_value_nofpu (type, regcache, readbuf);
1296 return RETURN_VALUE_REGISTER_CONVENTION;
1297 }
1298
1299 static enum return_value_convention
1300 sh_return_value_fpu (struct gdbarch *gdbarch, struct type *type,
1301 struct regcache *regcache,
1302 void *readbuf, const void *writebuf)
1303 {
1304 if (sh_use_struct_convention (0, type))
1305 return RETURN_VALUE_STRUCT_CONVENTION;
1306 if (writebuf)
1307 sh_store_return_value_fpu (type, regcache, writebuf);
1308 else if (readbuf)
1309 sh_extract_return_value_fpu (type, regcache, readbuf);
1310 return RETURN_VALUE_REGISTER_CONVENTION;
1311 }
1312
1313 /* Print the registers in a form similar to the E7000 */
1314
1315 static void
1316 sh_generic_show_regs (void)
1317 {
1318 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1319 paddr (read_register (PC_REGNUM)),
1320 (long) read_register (SR_REGNUM),
1321 (long) read_register (PR_REGNUM),
1322 (long) read_register (MACH_REGNUM),
1323 (long) read_register (MACL_REGNUM));
1324
1325 printf_filtered ("GBR=%08lx VBR=%08lx",
1326 (long) read_register (GBR_REGNUM),
1327 (long) read_register (VBR_REGNUM));
1328
1329 printf_filtered
1330 ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1331 (long) read_register (0), (long) read_register (1),
1332 (long) read_register (2), (long) read_register (3),
1333 (long) read_register (4), (long) read_register (5),
1334 (long) read_register (6), (long) read_register (7));
1335 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1336 (long) read_register (8), (long) read_register (9),
1337 (long) read_register (10), (long) read_register (11),
1338 (long) read_register (12), (long) read_register (13),
1339 (long) read_register (14), (long) read_register (15));
1340 }
1341
1342 static void
1343 sh3_show_regs (void)
1344 {
1345 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1346 paddr (read_register (PC_REGNUM)),
1347 (long) read_register (SR_REGNUM),
1348 (long) read_register (PR_REGNUM),
1349 (long) read_register (MACH_REGNUM),
1350 (long) read_register (MACL_REGNUM));
1351
1352 printf_filtered ("GBR=%08lx VBR=%08lx",
1353 (long) read_register (GBR_REGNUM),
1354 (long) read_register (VBR_REGNUM));
1355 printf_filtered (" SSR=%08lx SPC=%08lx",
1356 (long) read_register (SSR_REGNUM),
1357 (long) read_register (SPC_REGNUM));
1358
1359 printf_filtered
1360 ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1361 (long) read_register (0), (long) read_register (1),
1362 (long) read_register (2), (long) read_register (3),
1363 (long) read_register (4), (long) read_register (5),
1364 (long) read_register (6), (long) read_register (7));
1365 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1366 (long) read_register (8), (long) read_register (9),
1367 (long) read_register (10), (long) read_register (11),
1368 (long) read_register (12), (long) read_register (13),
1369 (long) read_register (14), (long) read_register (15));
1370 }
1371
1372
1373 static void
1374 sh2e_show_regs (void)
1375 {
1376 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1377 paddr (read_register (PC_REGNUM)),
1378 (long) read_register (SR_REGNUM),
1379 (long) read_register (PR_REGNUM),
1380 (long) read_register (MACH_REGNUM),
1381 (long) read_register (MACL_REGNUM));
1382
1383 printf_filtered ("GBR=%08lx VBR=%08lx",
1384 (long) read_register (GBR_REGNUM),
1385 (long) read_register (VBR_REGNUM));
1386 printf_filtered (" FPUL=%08lx FPSCR=%08lx",
1387 (long) read_register (FPUL_REGNUM),
1388 (long) read_register (FPSCR_REGNUM));
1389
1390 printf_filtered
1391 ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1392 (long) read_register (0), (long) read_register (1),
1393 (long) read_register (2), (long) read_register (3),
1394 (long) read_register (4), (long) read_register (5),
1395 (long) read_register (6), (long) read_register (7));
1396 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1397 (long) read_register (8), (long) read_register (9),
1398 (long) read_register (10), (long) read_register (11),
1399 (long) read_register (12), (long) read_register (13),
1400 (long) read_register (14), (long) read_register (15));
1401
1402 printf_filtered (("FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"), (long) read_register (FP0_REGNUM + 0), (long) read_register (FP0_REGNUM + 1), (long) read_register (FP0_REGNUM + 2), (long) read_register (FP0_REGNUM + 3), (long) read_register (FP0_REGNUM + 4), (long) read_register (FP0_REGNUM + 5), (long) read_register (FP0_REGNUM + 6), (long) read_register (FP0_REGNUM + 7));
1403 printf_filtered (("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"), (long) read_register (FP0_REGNUM + 8), (long) read_register (FP0_REGNUM + 9), (long) read_register (FP0_REGNUM + 10), (long) read_register (FP0_REGNUM + 11), (long) read_register (FP0_REGNUM + 12), (long) read_register (FP0_REGNUM + 13), (long) read_register (FP0_REGNUM + 14), (long) read_register (FP0_REGNUM + 15));
1404 }
1405
1406 static void
1407 sh2a_show_regs (void)
1408 {
1409 int pr = read_register (FPSCR_REGNUM) & 0x80000;
1410 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1411 paddr (read_register (PC_REGNUM)),
1412 (long) read_register (SR_REGNUM),
1413 (long) read_register (PR_REGNUM),
1414 (long) read_register (MACH_REGNUM),
1415 (long) read_register (MACL_REGNUM));
1416
1417 printf_filtered ("GBR=%08lx VBR=%08lx TBR=%08lx",
1418 (long) read_register (GBR_REGNUM),
1419 (long) read_register (VBR_REGNUM),
1420 (long) read_register (TBR_REGNUM));
1421 printf_filtered (" FPUL=%08lx FPSCR=%08lx\n",
1422 (long) read_register (FPUL_REGNUM),
1423 (long) read_register (FPSCR_REGNUM));
1424
1425 printf_filtered ("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1426 (long) read_register (0), (long) read_register (1),
1427 (long) read_register (2), (long) read_register (3),
1428 (long) read_register (4), (long) read_register (5),
1429 (long) read_register (6), (long) read_register (7));
1430 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1431 (long) read_register (8), (long) read_register (9),
1432 (long) read_register (10), (long) read_register (11),
1433 (long) read_register (12), (long) read_register (13),
1434 (long) read_register (14), (long) read_register (15));
1435
1436 printf_filtered ((pr
1437 ? "DR0-DR6 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
1438 :
1439 "FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1440 (long) read_register (FP0_REGNUM + 0),
1441 (long) read_register (FP0_REGNUM + 1),
1442 (long) read_register (FP0_REGNUM + 2),
1443 (long) read_register (FP0_REGNUM + 3),
1444 (long) read_register (FP0_REGNUM + 4),
1445 (long) read_register (FP0_REGNUM + 5),
1446 (long) read_register (FP0_REGNUM + 6),
1447 (long) read_register (FP0_REGNUM + 7));
1448 printf_filtered ((pr ?
1449 "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n" :
1450 "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1451 (long) read_register (FP0_REGNUM + 8),
1452 (long) read_register (FP0_REGNUM + 9),
1453 (long) read_register (FP0_REGNUM + 10),
1454 (long) read_register (FP0_REGNUM + 11),
1455 (long) read_register (FP0_REGNUM + 12),
1456 (long) read_register (FP0_REGNUM + 13),
1457 (long) read_register (FP0_REGNUM + 14),
1458 (long) read_register (FP0_REGNUM + 15));
1459 printf_filtered ("BANK=%-3d\n", (int) read_register (BANK_REGNUM));
1460 printf_filtered ("R0b - R7b %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1461 (long) read_register (R0_BANK0_REGNUM + 0),
1462 (long) read_register (R0_BANK0_REGNUM + 1),
1463 (long) read_register (R0_BANK0_REGNUM + 2),
1464 (long) read_register (R0_BANK0_REGNUM + 3),
1465 (long) read_register (R0_BANK0_REGNUM + 4),
1466 (long) read_register (R0_BANK0_REGNUM + 5),
1467 (long) read_register (R0_BANK0_REGNUM + 6),
1468 (long) read_register (R0_BANK0_REGNUM + 7));
1469 printf_filtered ("R8b - R14b %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1470 (long) read_register (R0_BANK0_REGNUM + 8),
1471 (long) read_register (R0_BANK0_REGNUM + 9),
1472 (long) read_register (R0_BANK0_REGNUM + 10),
1473 (long) read_register (R0_BANK0_REGNUM + 11),
1474 (long) read_register (R0_BANK0_REGNUM + 12),
1475 (long) read_register (R0_BANK0_REGNUM + 13),
1476 (long) read_register (R0_BANK0_REGNUM + 14));
1477 printf_filtered ("MACHb=%08lx IVNb=%08lx PRb=%08lx GBRb=%08lx MACLb=%08lx\n",
1478 (long) read_register (R0_BANK0_REGNUM + 15),
1479 (long) read_register (R0_BANK0_REGNUM + 16),
1480 (long) read_register (R0_BANK0_REGNUM + 17),
1481 (long) read_register (R0_BANK0_REGNUM + 18),
1482 (long) read_register (R0_BANK0_REGNUM + 19));
1483 }
1484
1485 static void
1486 sh2a_nofpu_show_regs (void)
1487 {
1488 int pr = read_register (FPSCR_REGNUM) & 0x80000;
1489 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1490 paddr (read_register (PC_REGNUM)),
1491 (long) read_register (SR_REGNUM),
1492 (long) read_register (PR_REGNUM),
1493 (long) read_register (MACH_REGNUM),
1494 (long) read_register (MACL_REGNUM));
1495
1496 printf_filtered ("GBR=%08lx VBR=%08lx TBR=%08lx",
1497 (long) read_register (GBR_REGNUM),
1498 (long) read_register (VBR_REGNUM),
1499 (long) read_register (TBR_REGNUM));
1500 printf_filtered (" FPUL=%08lx FPSCR=%08lx\n",
1501 (long) read_register (FPUL_REGNUM),
1502 (long) read_register (FPSCR_REGNUM));
1503
1504 printf_filtered ("R0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1505 (long) read_register (0), (long) read_register (1),
1506 (long) read_register (2), (long) read_register (3),
1507 (long) read_register (4), (long) read_register (5),
1508 (long) read_register (6), (long) read_register (7));
1509 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1510 (long) read_register (8), (long) read_register (9),
1511 (long) read_register (10), (long) read_register (11),
1512 (long) read_register (12), (long) read_register (13),
1513 (long) read_register (14), (long) read_register (15));
1514
1515 printf_filtered ("BANK=%-3d\n", (int) read_register (BANK_REGNUM));
1516 printf_filtered ("R0b - R7b %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1517 (long) read_register (R0_BANK0_REGNUM + 0),
1518 (long) read_register (R0_BANK0_REGNUM + 1),
1519 (long) read_register (R0_BANK0_REGNUM + 2),
1520 (long) read_register (R0_BANK0_REGNUM + 3),
1521 (long) read_register (R0_BANK0_REGNUM + 4),
1522 (long) read_register (R0_BANK0_REGNUM + 5),
1523 (long) read_register (R0_BANK0_REGNUM + 6),
1524 (long) read_register (R0_BANK0_REGNUM + 7));
1525 printf_filtered ("R8b - R14b %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1526 (long) read_register (R0_BANK0_REGNUM + 8),
1527 (long) read_register (R0_BANK0_REGNUM + 9),
1528 (long) read_register (R0_BANK0_REGNUM + 10),
1529 (long) read_register (R0_BANK0_REGNUM + 11),
1530 (long) read_register (R0_BANK0_REGNUM + 12),
1531 (long) read_register (R0_BANK0_REGNUM + 13),
1532 (long) read_register (R0_BANK0_REGNUM + 14));
1533 printf_filtered ("MACHb=%08lx IVNb=%08lx PRb=%08lx GBRb=%08lx MACLb=%08lx\n",
1534 (long) read_register (R0_BANK0_REGNUM + 15),
1535 (long) read_register (R0_BANK0_REGNUM + 16),
1536 (long) read_register (R0_BANK0_REGNUM + 17),
1537 (long) read_register (R0_BANK0_REGNUM + 18),
1538 (long) read_register (R0_BANK0_REGNUM + 19));
1539 }
1540
1541 static void
1542 sh3e_show_regs (void)
1543 {
1544 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1545 paddr (read_register (PC_REGNUM)),
1546 (long) read_register (SR_REGNUM),
1547 (long) read_register (PR_REGNUM),
1548 (long) read_register (MACH_REGNUM),
1549 (long) read_register (MACL_REGNUM));
1550
1551 printf_filtered ("GBR=%08lx VBR=%08lx",
1552 (long) read_register (GBR_REGNUM),
1553 (long) read_register (VBR_REGNUM));
1554 printf_filtered (" SSR=%08lx SPC=%08lx",
1555 (long) read_register (SSR_REGNUM),
1556 (long) read_register (SPC_REGNUM));
1557 printf_filtered (" FPUL=%08lx FPSCR=%08lx",
1558 (long) read_register (FPUL_REGNUM),
1559 (long) read_register (FPSCR_REGNUM));
1560
1561 printf_filtered
1562 ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1563 (long) read_register (0), (long) read_register (1),
1564 (long) read_register (2), (long) read_register (3),
1565 (long) read_register (4), (long) read_register (5),
1566 (long) read_register (6), (long) read_register (7));
1567 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1568 (long) read_register (8), (long) read_register (9),
1569 (long) read_register (10), (long) read_register (11),
1570 (long) read_register (12), (long) read_register (13),
1571 (long) read_register (14), (long) read_register (15));
1572
1573 printf_filtered (("FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"), (long) read_register (FP0_REGNUM + 0), (long) read_register (FP0_REGNUM + 1), (long) read_register (FP0_REGNUM + 2), (long) read_register (FP0_REGNUM + 3), (long) read_register (FP0_REGNUM + 4), (long) read_register (FP0_REGNUM + 5), (long) read_register (FP0_REGNUM + 6), (long) read_register (FP0_REGNUM + 7));
1574 printf_filtered (("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"), (long) read_register (FP0_REGNUM + 8), (long) read_register (FP0_REGNUM + 9), (long) read_register (FP0_REGNUM + 10), (long) read_register (FP0_REGNUM + 11), (long) read_register (FP0_REGNUM + 12), (long) read_register (FP0_REGNUM + 13), (long) read_register (FP0_REGNUM + 14), (long) read_register (FP0_REGNUM + 15));
1575 }
1576
1577 static void
1578 sh3_dsp_show_regs (void)
1579 {
1580 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1581 paddr (read_register (PC_REGNUM)),
1582 (long) read_register (SR_REGNUM),
1583 (long) read_register (PR_REGNUM),
1584 (long) read_register (MACH_REGNUM),
1585 (long) read_register (MACL_REGNUM));
1586
1587 printf_filtered ("GBR=%08lx VBR=%08lx",
1588 (long) read_register (GBR_REGNUM),
1589 (long) read_register (VBR_REGNUM));
1590
1591 printf_filtered (" SSR=%08lx SPC=%08lx",
1592 (long) read_register (SSR_REGNUM),
1593 (long) read_register (SPC_REGNUM));
1594
1595 printf_filtered (" DSR=%08lx", (long) read_register (DSR_REGNUM));
1596
1597 printf_filtered
1598 ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1599 (long) read_register (0), (long) read_register (1),
1600 (long) read_register (2), (long) read_register (3),
1601 (long) read_register (4), (long) read_register (5),
1602 (long) read_register (6), (long) read_register (7));
1603 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1604 (long) read_register (8), (long) read_register (9),
1605 (long) read_register (10), (long) read_register (11),
1606 (long) read_register (12), (long) read_register (13),
1607 (long) read_register (14), (long) read_register (15));
1608
1609 printf_filtered
1610 ("A0G=%02lx A0=%08lx M0=%08lx X0=%08lx Y0=%08lx RS=%08lx MOD=%08lx\n",
1611 (long) read_register (A0G_REGNUM) & 0xff,
1612 (long) read_register (A0_REGNUM), (long) read_register (M0_REGNUM),
1613 (long) read_register (X0_REGNUM), (long) read_register (Y0_REGNUM),
1614 (long) read_register (RS_REGNUM), (long) read_register (MOD_REGNUM));
1615 printf_filtered ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
1616 (long) read_register (A1G_REGNUM) & 0xff,
1617 (long) read_register (A1_REGNUM),
1618 (long) read_register (M1_REGNUM),
1619 (long) read_register (X1_REGNUM),
1620 (long) read_register (Y1_REGNUM),
1621 (long) read_register (RE_REGNUM));
1622 }
1623
1624 static void
1625 sh4_show_regs (void)
1626 {
1627 int pr = read_register (FPSCR_REGNUM) & 0x80000;
1628 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1629 paddr (read_register (PC_REGNUM)),
1630 (long) read_register (SR_REGNUM),
1631 (long) read_register (PR_REGNUM),
1632 (long) read_register (MACH_REGNUM),
1633 (long) read_register (MACL_REGNUM));
1634
1635 printf_filtered ("GBR=%08lx VBR=%08lx",
1636 (long) read_register (GBR_REGNUM),
1637 (long) read_register (VBR_REGNUM));
1638 printf_filtered (" SSR=%08lx SPC=%08lx",
1639 (long) read_register (SSR_REGNUM),
1640 (long) read_register (SPC_REGNUM));
1641 printf_filtered (" FPUL=%08lx FPSCR=%08lx",
1642 (long) read_register (FPUL_REGNUM),
1643 (long) read_register (FPSCR_REGNUM));
1644
1645 printf_filtered
1646 ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1647 (long) read_register (0), (long) read_register (1),
1648 (long) read_register (2), (long) read_register (3),
1649 (long) read_register (4), (long) read_register (5),
1650 (long) read_register (6), (long) read_register (7));
1651 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1652 (long) read_register (8), (long) read_register (9),
1653 (long) read_register (10), (long) read_register (11),
1654 (long) read_register (12), (long) read_register (13),
1655 (long) read_register (14), (long) read_register (15));
1656
1657 printf_filtered ((pr
1658 ? "DR0-DR6 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
1659 :
1660 "FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1661 (long) read_register (FP0_REGNUM + 0),
1662 (long) read_register (FP0_REGNUM + 1),
1663 (long) read_register (FP0_REGNUM + 2),
1664 (long) read_register (FP0_REGNUM + 3),
1665 (long) read_register (FP0_REGNUM + 4),
1666 (long) read_register (FP0_REGNUM + 5),
1667 (long) read_register (FP0_REGNUM + 6),
1668 (long) read_register (FP0_REGNUM + 7));
1669 printf_filtered ((pr ?
1670 "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n" :
1671 "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1672 (long) read_register (FP0_REGNUM + 8),
1673 (long) read_register (FP0_REGNUM + 9),
1674 (long) read_register (FP0_REGNUM + 10),
1675 (long) read_register (FP0_REGNUM + 11),
1676 (long) read_register (FP0_REGNUM + 12),
1677 (long) read_register (FP0_REGNUM + 13),
1678 (long) read_register (FP0_REGNUM + 14),
1679 (long) read_register (FP0_REGNUM + 15));
1680 }
1681
1682 static void
1683 sh4_nofpu_show_regs (void)
1684 {
1685 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1686 paddr (read_register (PC_REGNUM)),
1687 (long) read_register (SR_REGNUM),
1688 (long) read_register (PR_REGNUM),
1689 (long) read_register (MACH_REGNUM),
1690 (long) read_register (MACL_REGNUM));
1691
1692 printf_filtered ("GBR=%08lx VBR=%08lx",
1693 (long) read_register (GBR_REGNUM),
1694 (long) read_register (VBR_REGNUM));
1695 printf_filtered (" SSR=%08lx SPC=%08lx",
1696 (long) read_register (SSR_REGNUM),
1697 (long) read_register (SPC_REGNUM));
1698
1699 printf_filtered
1700 ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1701 (long) read_register (0), (long) read_register (1),
1702 (long) read_register (2), (long) read_register (3),
1703 (long) read_register (4), (long) read_register (5),
1704 (long) read_register (6), (long) read_register (7));
1705 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1706 (long) read_register (8), (long) read_register (9),
1707 (long) read_register (10), (long) read_register (11),
1708 (long) read_register (12), (long) read_register (13),
1709 (long) read_register (14), (long) read_register (15));
1710 }
1711
1712 static void
1713 sh_dsp_show_regs (void)
1714 {
1715 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1716 paddr (read_register (PC_REGNUM)),
1717 (long) read_register (SR_REGNUM),
1718 (long) read_register (PR_REGNUM),
1719 (long) read_register (MACH_REGNUM),
1720 (long) read_register (MACL_REGNUM));
1721
1722 printf_filtered ("GBR=%08lx VBR=%08lx",
1723 (long) read_register (GBR_REGNUM),
1724 (long) read_register (VBR_REGNUM));
1725
1726 printf_filtered (" DSR=%08lx", (long) read_register (DSR_REGNUM));
1727
1728 printf_filtered
1729 ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1730 (long) read_register (0), (long) read_register (1),
1731 (long) read_register (2), (long) read_register (3),
1732 (long) read_register (4), (long) read_register (5),
1733 (long) read_register (6), (long) read_register (7));
1734 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1735 (long) read_register (8), (long) read_register (9),
1736 (long) read_register (10), (long) read_register (11),
1737 (long) read_register (12), (long) read_register (13),
1738 (long) read_register (14), (long) read_register (15));
1739
1740 printf_filtered
1741 ("A0G=%02lx A0=%08lx M0=%08lx X0=%08lx Y0=%08lx RS=%08lx MOD=%08lx\n",
1742 (long) read_register (A0G_REGNUM) & 0xff,
1743 (long) read_register (A0_REGNUM), (long) read_register (M0_REGNUM),
1744 (long) read_register (X0_REGNUM), (long) read_register (Y0_REGNUM),
1745 (long) read_register (RS_REGNUM), (long) read_register (MOD_REGNUM));
1746 printf_filtered ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
1747 (long) read_register (A1G_REGNUM) & 0xff,
1748 (long) read_register (A1_REGNUM),
1749 (long) read_register (M1_REGNUM),
1750 (long) read_register (X1_REGNUM),
1751 (long) read_register (Y1_REGNUM),
1752 (long) read_register (RE_REGNUM));
1753 }
1754
1755 static void
1756 sh_show_regs_command (char *args, int from_tty)
1757 {
1758 if (sh_show_regs)
1759 (*sh_show_regs) ();
1760 }
1761
1762 static struct type *
1763 sh_sh2a_register_type (struct gdbarch *gdbarch, int reg_nr)
1764 {
1765 if ((reg_nr >= FP0_REGNUM
1766 && (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM))
1767 return builtin_type_float;
1768 else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
1769 return builtin_type_double;
1770 else
1771 return builtin_type_int;
1772 }
1773
1774 /* Return the GDB type object for the "standard" data type
1775 of data in register N. */
1776 static struct type *
1777 sh_sh3e_register_type (struct gdbarch *gdbarch, int reg_nr)
1778 {
1779 if ((reg_nr >= FP0_REGNUM
1780 && (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM))
1781 return builtin_type_float;
1782 else
1783 return builtin_type_int;
1784 }
1785
1786 static struct type *
1787 sh_sh4_build_float_register_type (int high)
1788 {
1789 struct type *temp;
1790
1791 temp = create_range_type (NULL, builtin_type_int, 0, high);
1792 return create_array_type (NULL, builtin_type_float, temp);
1793 }
1794
1795 static struct type *
1796 sh_sh4_register_type (struct gdbarch *gdbarch, int reg_nr)
1797 {
1798 if ((reg_nr >= FP0_REGNUM
1799 && (reg_nr <= FP_LAST_REGNUM)) || (reg_nr == FPUL_REGNUM))
1800 return builtin_type_float;
1801 else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
1802 return builtin_type_double;
1803 else if (reg_nr >= FV0_REGNUM && reg_nr <= FV_LAST_REGNUM)
1804 return sh_sh4_build_float_register_type (3);
1805 else
1806 return builtin_type_int;
1807 }
1808
1809 static struct type *
1810 sh_default_register_type (struct gdbarch *gdbarch, int reg_nr)
1811 {
1812 return builtin_type_int;
1813 }
1814
1815 /* On the sh4, the DRi pseudo registers are problematic if the target
1816 is little endian. When the user writes one of those registers, for
1817 instance with 'ser var $dr0=1', we want the double to be stored
1818 like this:
1819 fr0 = 0x00 0x00 0x00 0x00 0x00 0xf0 0x3f
1820 fr1 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
1821
1822 This corresponds to little endian byte order & big endian word
1823 order. However if we let gdb write the register w/o conversion, it
1824 will write fr0 and fr1 this way:
1825 fr0 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
1826 fr1 = 0x00 0x00 0x00 0x00 0x00 0xf0 0x3f
1827 because it will consider fr0 and fr1 as a single LE stretch of memory.
1828
1829 To achieve what we want we must force gdb to store things in
1830 floatformat_ieee_double_littlebyte_bigword (which is defined in
1831 include/floatformat.h and libiberty/floatformat.c.
1832
1833 In case the target is big endian, there is no problem, the
1834 raw bytes will look like:
1835 fr0 = 0x3f 0xf0 0x00 0x00 0x00 0x00 0x00
1836 fr1 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
1837
1838 The other pseudo registers (the FVs) also don't pose a problem
1839 because they are stored as 4 individual FP elements. */
1840
1841 static void
1842 sh_register_convert_to_virtual (int regnum, struct type *type,
1843 char *from, char *to)
1844 {
1845 if (regnum >= DR0_REGNUM && regnum <= DR_LAST_REGNUM)
1846 {
1847 DOUBLEST val;
1848 floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
1849 from, &val);
1850 store_typed_floating (to, type, val);
1851 }
1852 else
1853 error
1854 ("sh_register_convert_to_virtual called with non DR register number");
1855 }
1856
1857 static void
1858 sh_register_convert_to_raw (struct type *type, int regnum,
1859 const void *from, void *to)
1860 {
1861 if (regnum >= DR0_REGNUM && regnum <= DR_LAST_REGNUM)
1862 {
1863 DOUBLEST val = extract_typed_floating (from, type);
1864 floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword,
1865 &val, to);
1866 }
1867 else
1868 error (_("sh_register_convert_to_raw called with non DR register number"));
1869 }
1870
1871 /* For vectors of 4 floating point registers. */
1872 static int
1873 fv_reg_base_num (int fv_regnum)
1874 {
1875 int fp_regnum;
1876
1877 fp_regnum = FP0_REGNUM + (fv_regnum - FV0_REGNUM) * 4;
1878 return fp_regnum;
1879 }
1880
1881 /* For double precision floating point registers, i.e 2 fp regs.*/
1882 static int
1883 dr_reg_base_num (int dr_regnum)
1884 {
1885 int fp_regnum;
1886
1887 fp_regnum = FP0_REGNUM + (dr_regnum - DR0_REGNUM) * 2;
1888 return fp_regnum;
1889 }
1890
1891 static void
1892 sh_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
1893 int reg_nr, void *buffer)
1894 {
1895 int base_regnum, portion;
1896 char temp_buffer[MAX_REGISTER_SIZE];
1897
1898 if (reg_nr == PSEUDO_BANK_REGNUM)
1899 regcache_raw_read (regcache, BANK_REGNUM, buffer);
1900 else
1901 if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
1902 {
1903 base_regnum = dr_reg_base_num (reg_nr);
1904
1905 /* Build the value in the provided buffer. */
1906 /* Read the real regs for which this one is an alias. */
1907 for (portion = 0; portion < 2; portion++)
1908 regcache_raw_read (regcache, base_regnum + portion,
1909 (temp_buffer
1910 + register_size (gdbarch,
1911 base_regnum) * portion));
1912 /* We must pay attention to the endiannes. */
1913 sh_register_convert_to_virtual (reg_nr,
1914 gdbarch_register_type (gdbarch, reg_nr),
1915 temp_buffer, buffer);
1916 }
1917 else if (reg_nr >= FV0_REGNUM && reg_nr <= FV_LAST_REGNUM)
1918 {
1919 base_regnum = fv_reg_base_num (reg_nr);
1920
1921 /* Read the real regs for which this one is an alias. */
1922 for (portion = 0; portion < 4; portion++)
1923 regcache_raw_read (regcache, base_regnum + portion,
1924 ((char *) buffer
1925 + register_size (gdbarch,
1926 base_regnum) * portion));
1927 }
1928 }
1929
1930 static void
1931 sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
1932 int reg_nr, const void *buffer)
1933 {
1934 int base_regnum, portion;
1935 char temp_buffer[MAX_REGISTER_SIZE];
1936
1937 if (reg_nr == PSEUDO_BANK_REGNUM)
1938 {
1939 /* When the bank register is written to, the whole register bank
1940 is switched and all values in the bank registers must be read
1941 from the target/sim again. We're just invalidating the regcache
1942 so that a re-read happens next time it's necessary. */
1943 int bregnum;
1944
1945 regcache_raw_write (regcache, BANK_REGNUM, buffer);
1946 for (bregnum = R0_BANK0_REGNUM; bregnum < MACLB_REGNUM; ++bregnum)
1947 set_register_cached (bregnum, 0);
1948 }
1949 else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
1950 {
1951 base_regnum = dr_reg_base_num (reg_nr);
1952
1953 /* We must pay attention to the endiannes. */
1954 sh_register_convert_to_raw (gdbarch_register_type (gdbarch, reg_nr),
1955 reg_nr, buffer, temp_buffer);
1956
1957 /* Write the real regs for which this one is an alias. */
1958 for (portion = 0; portion < 2; portion++)
1959 regcache_raw_write (regcache, base_regnum + portion,
1960 (temp_buffer
1961 + register_size (gdbarch,
1962 base_regnum) * portion));
1963 }
1964 else if (reg_nr >= FV0_REGNUM && reg_nr <= FV_LAST_REGNUM)
1965 {
1966 base_regnum = fv_reg_base_num (reg_nr);
1967
1968 /* Write the real regs for which this one is an alias. */
1969 for (portion = 0; portion < 4; portion++)
1970 regcache_raw_write (regcache, base_regnum + portion,
1971 ((char *) buffer
1972 + register_size (gdbarch,
1973 base_regnum) * portion));
1974 }
1975 }
1976
1977 /* Floating point vector of 4 float registers. */
1978 static void
1979 do_fv_register_info (struct gdbarch *gdbarch, struct ui_file *file,
1980 int fv_regnum)
1981 {
1982 int first_fp_reg_num = fv_reg_base_num (fv_regnum);
1983 fprintf_filtered (file, "fv%d\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n",
1984 fv_regnum - FV0_REGNUM,
1985 (int) read_register (first_fp_reg_num),
1986 (int) read_register (first_fp_reg_num + 1),
1987 (int) read_register (first_fp_reg_num + 2),
1988 (int) read_register (first_fp_reg_num + 3));
1989 }
1990
1991 /* Double precision registers. */
1992 static void
1993 do_dr_register_info (struct gdbarch *gdbarch, struct ui_file *file,
1994 int dr_regnum)
1995 {
1996 int first_fp_reg_num = dr_reg_base_num (dr_regnum);
1997
1998 fprintf_filtered (file, "dr%d\t0x%08x%08x\n",
1999 dr_regnum - DR0_REGNUM,
2000 (int) read_register (first_fp_reg_num),
2001 (int) read_register (first_fp_reg_num + 1));
2002 }
2003 static void
2004 do_bank_register_info (struct gdbarch *gdbarch, struct ui_file *file)
2005 {
2006 fprintf_filtered (file, "bank %d\n",
2007 (int) read_register (BANK_REGNUM));
2008 }
2009
2010 static void
2011 sh_print_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
2012 int regnum)
2013 {
2014 if (regnum < NUM_REGS || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
2015 internal_error (__FILE__, __LINE__,
2016 _("Invalid pseudo register number %d\n"), regnum);
2017 else if (regnum == PSEUDO_BANK_REGNUM)
2018 do_bank_register_info (gdbarch, file);
2019 else if (regnum >= DR0_REGNUM && regnum <= DR_LAST_REGNUM)
2020 do_dr_register_info (gdbarch, file, regnum);
2021 else if (regnum >= FV0_REGNUM && regnum <= FV_LAST_REGNUM)
2022 do_fv_register_info (gdbarch, file, regnum);
2023 }
2024
2025 static void
2026 sh_do_fp_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
2027 { /* do values for FP (float) regs */
2028 char *raw_buffer;
2029 double flt; /* double extracted from raw hex data */
2030 int inv;
2031 int j;
2032
2033 /* Allocate space for the float. */
2034 raw_buffer = (char *) alloca (register_size (gdbarch, FP0_REGNUM));
2035
2036 /* Get the data in raw format. */
2037 if (!frame_register_read (get_selected_frame (NULL), regnum, raw_buffer))
2038 error (_("can't read register %d (%s)"), regnum, REGISTER_NAME (regnum));
2039
2040 /* Get the register as a number */
2041 flt = unpack_double (builtin_type_float, raw_buffer, &inv);
2042
2043 /* Print the name and some spaces. */
2044 fputs_filtered (REGISTER_NAME (regnum), file);
2045 print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
2046
2047 /* Print the value. */
2048 if (inv)
2049 fprintf_filtered (file, "<invalid float>");
2050 else
2051 fprintf_filtered (file, "%-10.9g", flt);
2052
2053 /* Print the fp register as hex. */
2054 fprintf_filtered (file, "\t(raw 0x");
2055 for (j = 0; j < register_size (gdbarch, regnum); j++)
2056 {
2057 int idx = (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
2058 ? j
2059 : register_size (gdbarch, regnum) - 1 - j);
2060 fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
2061 }
2062 fprintf_filtered (file, ")");
2063 fprintf_filtered (file, "\n");
2064 }
2065
2066 static void
2067 sh_do_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
2068 {
2069 char raw_buffer[MAX_REGISTER_SIZE];
2070
2071 fputs_filtered (REGISTER_NAME (regnum), file);
2072 print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), file);
2073
2074 /* Get the data in raw format. */
2075 if (!frame_register_read (get_selected_frame (NULL), regnum, raw_buffer))
2076 fprintf_filtered (file, "*value not available*\n");
2077
2078 val_print (gdbarch_register_type (gdbarch, regnum), raw_buffer, 0, 0,
2079 file, 'x', 1, 0, Val_pretty_default);
2080 fprintf_filtered (file, "\t");
2081 val_print (gdbarch_register_type (gdbarch, regnum), raw_buffer, 0, 0,
2082 file, 0, 1, 0, Val_pretty_default);
2083 fprintf_filtered (file, "\n");
2084 }
2085
2086 static void
2087 sh_print_register (struct gdbarch *gdbarch, struct ui_file *file, int regnum)
2088 {
2089 if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
2090 internal_error (__FILE__, __LINE__,
2091 _("Invalid register number %d\n"), regnum);
2092
2093 else if (regnum >= 0 && regnum < NUM_REGS)
2094 {
2095 if (TYPE_CODE (gdbarch_register_type (gdbarch, regnum)) ==
2096 TYPE_CODE_FLT)
2097 sh_do_fp_register (gdbarch, file, regnum); /* FP regs */
2098 else
2099 sh_do_register (gdbarch, file, regnum); /* All other regs */
2100 }
2101
2102 else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
2103 {
2104 sh_print_pseudo_register (gdbarch, file, regnum);
2105 }
2106 }
2107
2108 static void
2109 sh_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
2110 struct frame_info *frame, int regnum, int fpregs)
2111 {
2112 if (regnum != -1) /* do one specified register */
2113 {
2114 if (*(REGISTER_NAME (regnum)) == '\0')
2115 error (_("Not a valid register for the current processor type"));
2116
2117 sh_print_register (gdbarch, file, regnum);
2118 }
2119 else
2120 /* do all (or most) registers */
2121 {
2122 for (regnum = 0; regnum < NUM_REGS; ++regnum)
2123 {
2124 /* If the register name is empty, it is undefined for this
2125 processor, so don't display anything. */
2126 if (REGISTER_NAME (regnum) == NULL
2127 || *(REGISTER_NAME (regnum)) == '\0')
2128 continue;
2129
2130 if (TYPE_CODE (gdbarch_register_type (gdbarch, regnum)) ==
2131 TYPE_CODE_FLT)
2132 {
2133 /* true for "INFO ALL-REGISTERS" command */
2134 if (fpregs)
2135 sh_do_fp_register (gdbarch, file, regnum); /* FP regs */
2136 }
2137 else
2138 sh_do_register (gdbarch, file, regnum); /* All other regs */
2139 }
2140
2141 if (regnum == PSEUDO_BANK_REGNUM
2142 && REGISTER_NAME (regnum)
2143 && *REGISTER_NAME (regnum))
2144 sh_print_pseudo_register (gdbarch, file, regnum++);
2145
2146 if (fpregs)
2147 while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
2148 {
2149 sh_print_pseudo_register (gdbarch, file, regnum);
2150 regnum++;
2151 }
2152 }
2153 }
2154
2155 static int
2156 sh_dsp_register_sim_regno (int nr)
2157 {
2158 if (legacy_register_sim_regno (nr) < 0)
2159 return legacy_register_sim_regno (nr);
2160 if (nr >= DSR_REGNUM && nr <= Y1_REGNUM)
2161 return nr - DSR_REGNUM + SIM_SH_DSR_REGNUM;
2162 if (nr == MOD_REGNUM)
2163 return SIM_SH_MOD_REGNUM;
2164 if (nr == RS_REGNUM)
2165 return SIM_SH_RS_REGNUM;
2166 if (nr == RE_REGNUM)
2167 return SIM_SH_RE_REGNUM;
2168 if (nr >= DSP_R0_BANK_REGNUM && nr <= DSP_R7_BANK_REGNUM)
2169 return nr - DSP_R0_BANK_REGNUM + SIM_SH_R0_BANK_REGNUM;
2170 return nr;
2171 }
2172
2173 static int
2174 sh_sh2a_register_sim_regno (int nr)
2175 {
2176 switch (nr)
2177 {
2178 case TBR_REGNUM:
2179 return SIM_SH_TBR_REGNUM;
2180 case IBNR_REGNUM:
2181 return SIM_SH_IBNR_REGNUM;
2182 case IBCR_REGNUM:
2183 return SIM_SH_IBCR_REGNUM;
2184 case BANK_REGNUM:
2185 return SIM_SH_BANK_REGNUM;
2186 case MACLB_REGNUM:
2187 return SIM_SH_BANK_MACL_REGNUM;
2188 case GBRB_REGNUM:
2189 return SIM_SH_BANK_GBR_REGNUM;
2190 case PRB_REGNUM:
2191 return SIM_SH_BANK_PR_REGNUM;
2192 case IVNB_REGNUM:
2193 return SIM_SH_BANK_IVN_REGNUM;
2194 case MACHB_REGNUM:
2195 return SIM_SH_BANK_MACH_REGNUM;
2196 default:
2197 break;
2198 }
2199 return legacy_register_sim_regno (nr);
2200 }
2201
2202 static struct sh_frame_cache *
2203 sh_alloc_frame_cache (void)
2204 {
2205 struct sh_frame_cache *cache;
2206 int i;
2207
2208 cache = FRAME_OBSTACK_ZALLOC (struct sh_frame_cache);
2209
2210 /* Base address. */
2211 cache->base = 0;
2212 cache->saved_sp = 0;
2213 cache->sp_offset = 0;
2214 cache->pc = 0;
2215
2216 /* Frameless until proven otherwise. */
2217 cache->uses_fp = 0;
2218
2219 /* Saved registers. We initialize these to -1 since zero is a valid
2220 offset (that's where fp is supposed to be stored). */
2221 for (i = 0; i < SH_NUM_REGS; i++)
2222 {
2223 cache->saved_regs[i] = -1;
2224 }
2225
2226 return cache;
2227 }
2228
2229 static struct sh_frame_cache *
2230 sh_frame_cache (struct frame_info *next_frame, void **this_cache)
2231 {
2232 struct sh_frame_cache *cache;
2233 CORE_ADDR current_pc;
2234 int i;
2235
2236 if (*this_cache)
2237 return *this_cache;
2238
2239 cache = sh_alloc_frame_cache ();
2240 *this_cache = cache;
2241
2242 /* In principle, for normal frames, fp holds the frame pointer,
2243 which holds the base address for the current stack frame.
2244 However, for functions that don't need it, the frame pointer is
2245 optional. For these "frameless" functions the frame pointer is
2246 actually the frame pointer of the calling frame. */
2247 cache->base = frame_unwind_register_unsigned (next_frame, FP_REGNUM);
2248 if (cache->base == 0)
2249 return cache;
2250
2251 cache->pc = frame_func_unwind (next_frame);
2252 current_pc = frame_pc_unwind (next_frame);
2253 if (cache->pc != 0)
2254 sh_analyze_prologue (cache->pc, current_pc, cache);
2255
2256 if (!cache->uses_fp)
2257 {
2258 /* We didn't find a valid frame, which means that CACHE->base
2259 currently holds the frame pointer for our calling frame. If
2260 we're at the start of a function, or somewhere half-way its
2261 prologue, the function's frame probably hasn't been fully
2262 setup yet. Try to reconstruct the base address for the stack
2263 frame by looking at the stack pointer. For truly "frameless"
2264 functions this might work too. */
2265 cache->base = frame_unwind_register_unsigned (next_frame, SP_REGNUM);
2266 }
2267
2268 /* Now that we have the base address for the stack frame we can
2269 calculate the value of sp in the calling frame. */
2270 cache->saved_sp = cache->base + cache->sp_offset;
2271
2272 /* Adjust all the saved registers such that they contain addresses
2273 instead of offsets. */
2274 for (i = 0; i < SH_NUM_REGS; i++)
2275 if (cache->saved_regs[i] != -1)
2276 cache->saved_regs[i] = cache->saved_sp - cache->saved_regs[i] - 4;
2277
2278 return cache;
2279 }
2280
2281 static void
2282 sh_frame_prev_register (struct frame_info *next_frame, void **this_cache,
2283 int regnum, int *optimizedp,
2284 enum lval_type *lvalp, CORE_ADDR *addrp,
2285 int *realnump, void *valuep)
2286 {
2287 struct sh_frame_cache *cache = sh_frame_cache (next_frame, this_cache);
2288
2289 gdb_assert (regnum >= 0);
2290
2291 if (regnum == SP_REGNUM && cache->saved_sp)
2292 {
2293 *optimizedp = 0;
2294 *lvalp = not_lval;
2295 *addrp = 0;
2296 *realnump = -1;
2297 if (valuep)
2298 {
2299 /* Store the value. */
2300 store_unsigned_integer (valuep, 4, cache->saved_sp);
2301 }
2302 return;
2303 }
2304
2305 /* The PC of the previous frame is stored in the PR register of
2306 the current frame. Frob regnum so that we pull the value from
2307 the correct place. */
2308 if (regnum == PC_REGNUM)
2309 regnum = PR_REGNUM;
2310
2311 if (regnum < SH_NUM_REGS && cache->saved_regs[regnum] != -1)
2312 {
2313 *optimizedp = 0;
2314 *lvalp = lval_memory;
2315 *addrp = cache->saved_regs[regnum];
2316 *realnump = -1;
2317 if (valuep)
2318 {
2319 /* Read the value in from memory. */
2320 read_memory (*addrp, valuep,
2321 register_size (current_gdbarch, regnum));
2322 }
2323 return;
2324 }
2325
2326 *optimizedp = 0;
2327 *lvalp = lval_register;
2328 *addrp = 0;
2329 *realnump = regnum;
2330 if (valuep)
2331 frame_unwind_register (next_frame, (*realnump), valuep);
2332 }
2333
2334 static void
2335 sh_frame_this_id (struct frame_info *next_frame, void **this_cache,
2336 struct frame_id *this_id)
2337 {
2338 struct sh_frame_cache *cache = sh_frame_cache (next_frame, this_cache);
2339
2340 /* This marks the outermost frame. */
2341 if (cache->base == 0)
2342 return;
2343
2344 *this_id = frame_id_build (cache->saved_sp, cache->pc);
2345 }
2346
2347 static const struct frame_unwind sh_frame_unwind = {
2348 NORMAL_FRAME,
2349 sh_frame_this_id,
2350 sh_frame_prev_register
2351 };
2352
2353 static const struct frame_unwind *
2354 sh_frame_sniffer (struct frame_info *next_frame)
2355 {
2356 return &sh_frame_unwind;
2357 }
2358
2359 static CORE_ADDR
2360 sh_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
2361 {
2362 return frame_unwind_register_unsigned (next_frame, SP_REGNUM);
2363 }
2364
2365 static CORE_ADDR
2366 sh_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2367 {
2368 return frame_unwind_register_unsigned (next_frame, PC_REGNUM);
2369 }
2370
2371 static struct frame_id
2372 sh_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
2373 {
2374 return frame_id_build (sh_unwind_sp (gdbarch, next_frame),
2375 frame_pc_unwind (next_frame));
2376 }
2377
2378 static CORE_ADDR
2379 sh_frame_base_address (struct frame_info *next_frame, void **this_cache)
2380 {
2381 struct sh_frame_cache *cache = sh_frame_cache (next_frame, this_cache);
2382
2383 return cache->base;
2384 }
2385
2386 static const struct frame_base sh_frame_base = {
2387 &sh_frame_unwind,
2388 sh_frame_base_address,
2389 sh_frame_base_address,
2390 sh_frame_base_address
2391 };
2392
2393 /* The epilogue is defined here as the area at the end of a function,
2394 either on the `ret' instruction itself or after an instruction which
2395 destroys the function's stack frame. */
2396 static int
2397 sh_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
2398 {
2399 CORE_ADDR func_addr = 0, func_end = 0;
2400
2401 if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
2402 {
2403 ULONGEST inst;
2404 /* The sh epilogue is max. 14 bytes long. Give another 14 bytes
2405 for a nop and some fixed data (e.g. big offsets) which are
2406 unfortunately also treated as part of the function (which
2407 means, they are below func_end. */
2408 CORE_ADDR addr = func_end - 28;
2409 if (addr < func_addr + 4)
2410 addr = func_addr + 4;
2411 if (pc < addr)
2412 return 0;
2413
2414 /* First search forward until hitting an rts. */
2415 while (addr < func_end
2416 && !IS_RTS (read_memory_unsigned_integer (addr, 2)))
2417 addr += 2;
2418 if (addr >= func_end)
2419 return 0;
2420
2421 /* At this point we should find a mov.l @r15+,r14 instruction,
2422 either before or after the rts. If not, then the function has
2423 probably no "normal" epilogue and we bail out here. */
2424 inst = read_memory_unsigned_integer (addr - 2, 2);
2425 if (IS_RESTORE_FP (read_memory_unsigned_integer (addr - 2, 2)))
2426 addr -= 2;
2427 else if (!IS_RESTORE_FP (read_memory_unsigned_integer (addr + 2, 2)))
2428 return 0;
2429
2430 inst = read_memory_unsigned_integer (addr - 2, 2);
2431
2432 /* Step over possible lds.l @r15+,macl. */
2433 if (IS_MACL_LDS (inst))
2434 {
2435 addr -= 2;
2436 inst = read_memory_unsigned_integer (addr - 2, 2);
2437 }
2438
2439 /* Step over possible lds.l @r15+,pr. */
2440 if (IS_LDS (inst))
2441 {
2442 addr -= 2;
2443 inst = read_memory_unsigned_integer (addr - 2, 2);
2444 }
2445
2446 /* Step over possible mov r14,r15. */
2447 if (IS_MOV_FP_SP (inst))
2448 {
2449 addr -= 2;
2450 inst = read_memory_unsigned_integer (addr - 2, 2);
2451 }
2452
2453 /* Now check for FP adjustments, using add #imm,r14 or add rX, r14
2454 instructions. */
2455 while (addr > func_addr + 4
2456 && (IS_ADD_REG_TO_FP (inst) || IS_ADD_IMM_FP (inst)))
2457 {
2458 addr -= 2;
2459 inst = read_memory_unsigned_integer (addr - 2, 2);
2460 }
2461
2462 /* On SH2a check if the previous instruction was perhaps a MOVI20.
2463 That's allowed for the epilogue. */
2464 if ((gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_sh2a
2465 || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_sh2a_nofpu)
2466 && addr > func_addr + 6
2467 && IS_MOVI20 (read_memory_unsigned_integer (addr - 4, 2)))
2468 addr -= 4;
2469
2470 if (pc >= addr)
2471 return 1;
2472 }
2473 return 0;
2474 }
2475 \f
2476
2477 static struct gdbarch *
2478 sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2479 {
2480 struct gdbarch *gdbarch;
2481
2482 sh_show_regs = sh_generic_show_regs;
2483 switch (info.bfd_arch_info->mach)
2484 {
2485 case bfd_mach_sh2e:
2486 sh_show_regs = sh2e_show_regs;
2487 break;
2488 case bfd_mach_sh2a:
2489 sh_show_regs = sh2a_show_regs;
2490 break;
2491 case bfd_mach_sh2a_nofpu:
2492 sh_show_regs = sh2a_nofpu_show_regs;
2493 break;
2494 case bfd_mach_sh_dsp:
2495 sh_show_regs = sh_dsp_show_regs;
2496 break;
2497
2498 case bfd_mach_sh3:
2499 sh_show_regs = sh3_show_regs;
2500 break;
2501
2502 case bfd_mach_sh3e:
2503 sh_show_regs = sh3e_show_regs;
2504 break;
2505
2506 case bfd_mach_sh3_dsp:
2507 case bfd_mach_sh4al_dsp:
2508 sh_show_regs = sh3_dsp_show_regs;
2509 break;
2510
2511 case bfd_mach_sh4:
2512 case bfd_mach_sh4a:
2513 sh_show_regs = sh4_show_regs;
2514 break;
2515
2516 case bfd_mach_sh4_nofpu:
2517 case bfd_mach_sh4a_nofpu:
2518 sh_show_regs = sh4_nofpu_show_regs;
2519 break;
2520
2521 case bfd_mach_sh5:
2522 sh_show_regs = sh64_show_regs;
2523 /* SH5 is handled entirely in sh64-tdep.c */
2524 return sh64_gdbarch_init (info, arches);
2525 }
2526
2527 /* If there is already a candidate, use it. */
2528 arches = gdbarch_list_lookup_by_info (arches, &info);
2529 if (arches != NULL)
2530 return arches->gdbarch;
2531
2532 /* None found, create a new architecture from the information
2533 provided. */
2534 gdbarch = gdbarch_alloc (&info, NULL);
2535
2536 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
2537 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2538 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2539 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2540 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2541 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2542 set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2543 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2544
2545 set_gdbarch_num_regs (gdbarch, SH_NUM_REGS);
2546 set_gdbarch_sp_regnum (gdbarch, 15);
2547 set_gdbarch_pc_regnum (gdbarch, 16);
2548 set_gdbarch_fp0_regnum (gdbarch, -1);
2549 set_gdbarch_num_pseudo_regs (gdbarch, 0);
2550
2551 set_gdbarch_register_type (gdbarch, sh_default_register_type);
2552
2553 set_gdbarch_print_registers_info (gdbarch, sh_print_registers_info);
2554
2555 set_gdbarch_breakpoint_from_pc (gdbarch, sh_breakpoint_from_pc);
2556
2557 set_gdbarch_print_insn (gdbarch, gdb_print_insn_sh);
2558 set_gdbarch_register_sim_regno (gdbarch, legacy_register_sim_regno);
2559
2560 set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
2561
2562 set_gdbarch_return_value (gdbarch, sh_return_value_nofpu);
2563 set_gdbarch_deprecated_extract_struct_value_address (gdbarch,
2564 sh_extract_struct_value_address);
2565
2566 set_gdbarch_skip_prologue (gdbarch, sh_skip_prologue);
2567 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2568
2569 set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call_nofpu);
2570
2571 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
2572
2573 set_gdbarch_frame_align (gdbarch, sh_frame_align);
2574 set_gdbarch_unwind_sp (gdbarch, sh_unwind_sp);
2575 set_gdbarch_unwind_pc (gdbarch, sh_unwind_pc);
2576 set_gdbarch_unwind_dummy_id (gdbarch, sh_unwind_dummy_id);
2577 frame_base_set_default (gdbarch, &sh_frame_base);
2578
2579 set_gdbarch_in_function_epilogue_p (gdbarch, sh_in_function_epilogue_p);
2580
2581 switch (info.bfd_arch_info->mach)
2582 {
2583 case bfd_mach_sh:
2584 set_gdbarch_register_name (gdbarch, sh_sh_register_name);
2585 break;
2586
2587 case bfd_mach_sh2:
2588 set_gdbarch_register_name (gdbarch, sh_sh_register_name);
2589 break;
2590
2591 case bfd_mach_sh2e:
2592 /* doubles on sh2e and sh3e are actually 4 byte. */
2593 set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2594
2595 set_gdbarch_register_name (gdbarch, sh_sh2e_register_name);
2596 set_gdbarch_register_type (gdbarch, sh_sh3e_register_type);
2597 set_gdbarch_fp0_regnum (gdbarch, 25);
2598 set_gdbarch_return_value (gdbarch, sh_return_value_fpu);
2599 set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call_fpu);
2600 break;
2601
2602 case bfd_mach_sh2a:
2603 set_gdbarch_register_name (gdbarch, sh_sh2a_register_name);
2604 set_gdbarch_register_type (gdbarch, sh_sh2a_register_type);
2605 set_gdbarch_register_sim_regno (gdbarch, sh_sh2a_register_sim_regno);
2606
2607 set_gdbarch_fp0_regnum (gdbarch, 25);
2608 set_gdbarch_num_pseudo_regs (gdbarch, 9);
2609 set_gdbarch_pseudo_register_read (gdbarch, sh_pseudo_register_read);
2610 set_gdbarch_pseudo_register_write (gdbarch, sh_pseudo_register_write);
2611 set_gdbarch_return_value (gdbarch, sh_return_value_fpu);
2612 set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call_fpu);
2613 break;
2614
2615 case bfd_mach_sh2a_nofpu:
2616 set_gdbarch_register_name (gdbarch, sh_sh2a_nofpu_register_name);
2617 set_gdbarch_register_sim_regno (gdbarch, sh_sh2a_register_sim_regno);
2618
2619 set_gdbarch_num_pseudo_regs (gdbarch, 1);
2620 set_gdbarch_pseudo_register_read (gdbarch, sh_pseudo_register_read);
2621 set_gdbarch_pseudo_register_write (gdbarch, sh_pseudo_register_write);
2622 break;
2623
2624 case bfd_mach_sh_dsp:
2625 set_gdbarch_register_name (gdbarch, sh_sh_dsp_register_name);
2626 set_gdbarch_register_sim_regno (gdbarch, sh_dsp_register_sim_regno);
2627 break;
2628
2629 case bfd_mach_sh3:
2630 set_gdbarch_register_name (gdbarch, sh_sh3_register_name);
2631 break;
2632
2633 case bfd_mach_sh3e:
2634 /* doubles on sh2e and sh3e are actually 4 byte. */
2635 set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2636
2637 set_gdbarch_register_name (gdbarch, sh_sh3e_register_name);
2638 set_gdbarch_register_type (gdbarch, sh_sh3e_register_type);
2639 set_gdbarch_fp0_regnum (gdbarch, 25);
2640 set_gdbarch_return_value (gdbarch, sh_return_value_fpu);
2641 set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call_fpu);
2642 break;
2643
2644 case bfd_mach_sh3_dsp:
2645 set_gdbarch_register_name (gdbarch, sh_sh3_dsp_register_name);
2646 set_gdbarch_register_sim_regno (gdbarch, sh_dsp_register_sim_regno);
2647 break;
2648
2649 case bfd_mach_sh4:
2650 case bfd_mach_sh4a:
2651 set_gdbarch_register_name (gdbarch, sh_sh4_register_name);
2652 set_gdbarch_register_type (gdbarch, sh_sh4_register_type);
2653 set_gdbarch_fp0_regnum (gdbarch, 25);
2654 set_gdbarch_num_pseudo_regs (gdbarch, 13);
2655 set_gdbarch_pseudo_register_read (gdbarch, sh_pseudo_register_read);
2656 set_gdbarch_pseudo_register_write (gdbarch, sh_pseudo_register_write);
2657 set_gdbarch_return_value (gdbarch, sh_return_value_fpu);
2658 set_gdbarch_push_dummy_call (gdbarch, sh_push_dummy_call_fpu);
2659 break;
2660
2661 case bfd_mach_sh4_nofpu:
2662 case bfd_mach_sh4a_nofpu:
2663 set_gdbarch_register_name (gdbarch, sh_sh4_nofpu_register_name);
2664 break;
2665
2666 case bfd_mach_sh4al_dsp:
2667 set_gdbarch_register_name (gdbarch, sh_sh4al_dsp_register_name);
2668 set_gdbarch_register_sim_regno (gdbarch, sh_dsp_register_sim_regno);
2669 break;
2670
2671 default:
2672 set_gdbarch_register_name (gdbarch, sh_sh_register_name);
2673 break;
2674 }
2675
2676 /* Hook in ABI-specific overrides, if they have been registered. */
2677 gdbarch_init_osabi (info, gdbarch);
2678
2679 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
2680 frame_unwind_append_sniffer (gdbarch, sh_frame_sniffer);
2681
2682 return gdbarch;
2683 }
2684
2685 extern initialize_file_ftype _initialize_sh_tdep; /* -Wmissing-prototypes */
2686
2687 void
2688 _initialize_sh_tdep (void)
2689 {
2690 struct cmd_list_element *c;
2691
2692 gdbarch_register (bfd_arch_sh, sh_gdbarch_init, NULL);
2693
2694 add_com ("regs", class_vars, sh_show_regs_command, _("Print all registers"));
2695 }
A mirror of the official binutils-gdb repository