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