?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* gas/cgen feature
[binutils-gdb.git] / gdb / sh-tdep.c
blob74783bf2a607c3dc5cb251323f7d386aae2c9a60
1 /* Target-dependent code for Hitachi Super-H, for GDB.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 2000 Free Software
3 Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 /*
23 Contributed by Steve Chamberlain
24 sac@cygnus.com
25 */
26
27 #include "defs.h"
28 #include "frame.h"
29 #include "obstack.h"
30 #include "symtab.h"
31 #include "symfile.h"
32 #include "gdbtypes.h"
33 #include "gdbcmd.h"
34 #include "gdbcore.h"
35 #include "value.h"
36 #include "dis-asm.h"
37 #include "inferior.h" /* for BEFORE_TEXT_END etc. */
38 #include "gdb_string.h"
39 #include "arch-utils.h"
40 #include "floatformat.h"
41
42 #include "solib-svr4.h"
43
44 #undef XMALLOC
45 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
46
47
48 /* Frame interpretation related functions. */
49 static gdbarch_breakpoint_from_pc_ftype sh_breakpoint_from_pc;
50 static gdbarch_frame_chain_ftype sh_frame_chain;
51 static gdbarch_frame_saved_pc_ftype sh_frame_saved_pc;
52 static gdbarch_skip_prologue_ftype sh_skip_prologue;
53
54 static gdbarch_frame_init_saved_regs_ftype sh_nofp_frame_init_saved_regs;
55 static gdbarch_frame_init_saved_regs_ftype sh_fp_frame_init_saved_regs;
56 static gdbarch_init_extra_frame_info_ftype sh_init_extra_frame_info;
57 static gdbarch_pop_frame_ftype sh_pop_frame;
58 static gdbarch_saved_pc_after_call_ftype sh_saved_pc_after_call;
59
60 /* Function call related functions. */
61 static gdbarch_extract_return_value_ftype sh_extract_return_value;
62 static gdbarch_extract_struct_value_address_ftype sh_extract_struct_value_address;
63 static gdbarch_use_struct_convention_ftype sh_use_struct_convention;
64 static gdbarch_store_struct_return_ftype sh_store_struct_return;
65 static gdbarch_push_arguments_ftype sh_push_arguments;
66 static gdbarch_push_return_address_ftype sh_push_return_address;
67 static gdbarch_coerce_float_to_double_ftype sh_coerce_float_to_double;
68 static gdbarch_store_return_value_ftype sh_default_store_return_value;
69 static gdbarch_store_return_value_ftype sh3e_sh4_store_return_value;
70
71 static gdbarch_register_name_ftype sh_generic_register_name;
72 static gdbarch_register_name_ftype sh_sh_register_name;
73 static gdbarch_register_name_ftype sh_sh3_register_name;
74 static gdbarch_register_name_ftype sh_sh3e_register_name;
75 static gdbarch_register_name_ftype sh_sh_dsp_register_name;
76 static gdbarch_register_name_ftype sh_sh3_dsp_register_name;
77
78 /* Registers display related functions */
79 static gdbarch_register_raw_size_ftype sh_default_register_raw_size;
80 static gdbarch_register_raw_size_ftype sh_sh4_register_raw_size;
81
82 static gdbarch_register_virtual_size_ftype sh_register_virtual_size;
83
84 static gdbarch_register_byte_ftype sh_default_register_byte;
85 static gdbarch_register_byte_ftype sh_sh4_register_byte;
86
87 static gdbarch_register_virtual_type_ftype sh_sh3e_register_virtual_type;
88 static gdbarch_register_virtual_type_ftype sh_sh4_register_virtual_type;
89 static gdbarch_register_virtual_type_ftype sh_default_register_virtual_type;
90
91 static void sh_generic_show_regs (void);
92 static void sh3_show_regs (void);
93 static void sh3e_show_regs (void);
94 static void sh3_dsp_show_regs (void);
95 static void sh_dsp_show_regs (void);
96 static void sh4_show_regs (void);
97 static void sh_show_regs_command (char *, int);
98
99 static struct type *sh_sh4_build_float_register_type (int high);
100
101 static gdbarch_fetch_pseudo_register_ftype sh_fetch_pseudo_register;
102 static gdbarch_store_pseudo_register_ftype sh_store_pseudo_register;
103 static int fv_reg_base_num (int);
104 static int dr_reg_base_num (int);
105 static gdbarch_do_registers_info_ftype sh_do_registers_info;
106 static void do_fv_register_info (int fv_regnum);
107 static void do_dr_register_info (int dr_regnum);
108 static void sh_do_pseudo_register (int regnum);
109 static void sh_do_fp_register (int regnum);
110 static void sh_do_register (int regnum);
111 static void sh_print_register (int regnum);
112
113 void (*sh_show_regs) (void);
114 int (*print_sh_insn) (bfd_vma, disassemble_info*);
115
116 /* Define other aspects of the stack frame.
117 we keep a copy of the worked out return pc lying around, since it
118 is a useful bit of info */
119
120 struct frame_extra_info
121 {
122 CORE_ADDR return_pc;
123 int leaf_function;
124 int f_offset;
125 };
126
127 #if 0
128 #ifdef _WIN32_WCE
129 char **sh_register_names = sh3_reg_names;
130 #else
131 char **sh_register_names = sh_generic_reg_names;
132 #endif
133 #endif
134
135 static char *
136 sh_generic_register_name (int reg_nr)
137 {
138 static char *register_names[] =
139 {
140 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
141 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
142 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
143 "fpul", "fpscr",
144 "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
145 "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
146 "ssr", "spc",
147 "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
148 "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
149 };
150 if (reg_nr < 0)
151 return NULL;
152 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
153 return NULL;
154 return register_names[reg_nr];
155 }
156
157 static char *
158 sh_sh_register_name (int reg_nr)
159 {
160 static char *register_names[] =
161 {
162 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
163 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
164 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
165 "", "",
166 "", "", "", "", "", "", "", "",
167 "", "", "", "", "", "", "", "",
168 "", "",
169 "", "", "", "", "", "", "", "",
170 "", "", "", "", "", "", "", "",
171 };
172 if (reg_nr < 0)
173 return NULL;
174 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
175 return NULL;
176 return register_names[reg_nr];
177 }
178
179 static char *
180 sh_sh3_register_name (int reg_nr)
181 {
182 static char *register_names[] =
183 {
184 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
185 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
186 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
187 "", "",
188 "", "", "", "", "", "", "", "",
189 "", "", "", "", "", "", "", "",
190 "ssr", "spc",
191 "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
192 "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1"
193 };
194 if (reg_nr < 0)
195 return NULL;
196 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
197 return NULL;
198 return register_names[reg_nr];
199 }
200
201 static char *
202 sh_sh3e_register_name (int reg_nr)
203 {
204 static char *register_names[] =
205 {
206 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
207 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
208 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
209 "fpul", "fpscr",
210 "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
211 "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
212 "ssr", "spc",
213 "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
214 "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
215 };
216 if (reg_nr < 0)
217 return NULL;
218 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
219 return NULL;
220 return register_names[reg_nr];
221 }
222
223 static char *
224 sh_sh_dsp_register_name (int reg_nr)
225 {
226 static char *register_names[] =
227 {
228 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
229 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
230 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
231 "", "dsr",
232 "a0g", "a0", "a1g", "a1", "m0", "m1", "x0", "x1",
233 "y0", "y1", "", "", "", "", "", "mod",
234 "", "",
235 "rs", "re", "", "", "", "", "", "",
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 char *
246 sh_sh3_dsp_register_name (int reg_nr)
247 {
248 static char *register_names[] =
249 {
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 "ssr", "spc",
257 "rs", "re", "", "", "", "", "", "",
258 "r0b", "r1b", "r2b", "r3b", "r4b", "r5b", "r6b", "r7b"
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 char *
269 sh_sh4_register_name (int reg_nr)
270 {
271 static char *register_names[] =
272 {
273 /* general registers 0-15 */
274 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
275 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
276 /* 16 - 22 */
277 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
278 /* 23, 24 */
279 "fpul", "fpscr",
280 /* floating point registers 25 - 40 */
281 "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
282 "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
283 /* 41, 42 */
284 "ssr", "spc",
285 /* bank 0 43 - 50 */
286 "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
287 /* bank 1 51 - 58 */
288 "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
289 /* double precision (pseudo) 59 - 66 */
290 "dr0", "dr2", "dr4", "dr6", "dr8", "dr10", "dr12", "dr14",
291 /* vectors (pseudo) 67 - 70 */
292 "fv0", "fv4", "fv8", "fv12",
293 /* FIXME: missing XF 71 - 86 */
294 /* FIXME: missing XD 87 - 94 */
295 };
296 if (reg_nr < 0)
297 return NULL;
298 if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
299 return NULL;
300 return register_names[reg_nr];
301 }
302
303 static unsigned char *
304 sh_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
305 {
306 /* 0xc3c3 is trapa #c3, and it works in big and little endian modes */
307 static unsigned char breakpoint[] = {0xc3, 0xc3};
308
309 *lenptr = sizeof (breakpoint);
310 return breakpoint;
311 }
312
313 /* Prologue looks like
314 [mov.l <regs>,@-r15]...
315 [sts.l pr,@-r15]
316 [mov.l r14,@-r15]
317 [mov r15,r14]
318
319 Actually it can be more complicated than this. For instance, with
320 newer gcc's:
321
322 mov.l r14,@-r15
323 add #-12,r15
324 mov r15,r14
325 mov r4,r1
326 mov r5,r2
327 mov.l r6,@(4,r14)
328 mov.l r7,@(8,r14)
329 mov.b r1,@r14
330 mov r14,r1
331 mov r14,r1
332 add #2,r1
333 mov.w r2,@r1
334
335 */
336
337 /* STS.L PR,@-r15 0100111100100010
338 r15-4-->r15, PR-->(r15) */
339 #define IS_STS(x) ((x) == 0x4f22)
340
341 /* MOV.L Rm,@-r15 00101111mmmm0110
342 r15-4-->r15, Rm-->(R15) */
343 #define IS_PUSH(x) (((x) & 0xff0f) == 0x2f06)
344
345 #define GET_PUSHED_REG(x) (((x) >> 4) & 0xf)
346
347 /* MOV r15,r14 0110111011110011
348 r15-->r14 */
349 #define IS_MOV_SP_FP(x) ((x) == 0x6ef3)
350
351 /* ADD #imm,r15 01111111iiiiiiii
352 r15+imm-->r15 */
353 #define IS_ADD_SP(x) (((x) & 0xff00) == 0x7f00)
354
355 #define IS_MOV_R3(x) (((x) & 0xff00) == 0x1a00)
356 #define IS_SHLL_R3(x) ((x) == 0x4300)
357
358 /* ADD r3,r15 0011111100111100
359 r15+r3-->r15 */
360 #define IS_ADD_R3SP(x) ((x) == 0x3f3c)
361
362 /* FMOV.S FRm,@-Rn Rn-4-->Rn, FRm-->(Rn) 1111nnnnmmmm1011
363 FMOV DRm,@-Rn Rn-8-->Rn, DRm-->(Rn) 1111nnnnmmm01011
364 FMOV XDm,@-Rn Rn-8-->Rn, XDm-->(Rn) 1111nnnnmmm11011 */
365 #define IS_FMOV(x) (((x) & 0xf00f) == 0xf00b)
366
367 /* MOV Rm,Rn Rm-->Rn 0110nnnnmmmm0011
368 MOV.L Rm,@(disp,Rn) Rm-->(dispx4+Rn) 0001nnnnmmmmdddd
369 MOV.L Rm,@Rn Rm-->(Rn) 0010nnnnmmmm0010
370 where Rm is one of r4,r5,r6,r7 which are the argument registers. */
371 #define IS_ARG_MOV(x) \
372 (((((x) & 0xf00f) == 0x6003) && (((x) & 0x00f0) >= 0x0040 && ((x) & 0x00f0) <= 0x0070)) \
373 || ((((x) & 0xf000) == 0x1000) && (((x) & 0x00f0) >= 0x0040 && ((x) & 0x00f0) <= 0x0070)) \
374 || ((((x) & 0xf00f) == 0x2002) && (((x) & 0x00f0) >= 0x0040 && ((x) & 0x00f0) <= 0x0070)))
375
376 /* MOV.L Rm,@(disp,r14) 00011110mmmmdddd
377 Rm-->(dispx4+r14) where Rm is one of r4,r5,r6,r7 */
378 #define IS_MOV_R14(x) \
379 ((((x) & 0xff00) == 0x1e) && (((x) & 0x00f0) >= 0x0040 && ((x) & 0x00f0) <= 0x0070))
380
381 #define FPSCR_SZ (1 << 20)
382
383 /* Skip any prologue before the guts of a function */
384
385 /* Skip the prologue using the debug information. If this fails we'll
386 fall back on the 'guess' method below. */
387 static CORE_ADDR
388 after_prologue (CORE_ADDR pc)
389 {
390 struct symtab_and_line sal;
391 CORE_ADDR func_addr, func_end;
392
393 /* If we can not find the symbol in the partial symbol table, then
394 there is no hope we can determine the function's start address
395 with this code. */
396 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
397 return 0;
398
399 /* Get the line associated with FUNC_ADDR. */
400 sal = find_pc_line (func_addr, 0);
401
402 /* There are only two cases to consider. First, the end of the source line
403 is within the function bounds. In that case we return the end of the
404 source line. Second is the end of the source line extends beyond the
405 bounds of the current function. We need to use the slow code to
406 examine instructions in that case. */
407 if (sal.end < func_end)
408 return sal.end;
409 else
410 return 0;
411 }
412
413 /* Here we look at each instruction in the function, and try to guess
414 where the prologue ends. Unfortunately this is not always
415 accurate. */
416 static CORE_ADDR
417 skip_prologue_hard_way (CORE_ADDR start_pc)
418 {
419 CORE_ADDR here, end;
420 int updated_fp = 0;
421
422 if (!start_pc)
423 return 0;
424
425 for (here = start_pc, end = start_pc + (2 * 28); here < end;)
426 {
427 int w = read_memory_integer (here, 2);
428 here += 2;
429 if (IS_FMOV (w) || IS_PUSH (w) || IS_STS (w) || IS_MOV_R3 (w)
430 || IS_ADD_R3SP (w) || IS_ADD_SP (w) || IS_SHLL_R3 (w)
431 || IS_ARG_MOV (w) || IS_MOV_R14 (w))
432 {
433 start_pc = here;
434 }
435 else if (IS_MOV_SP_FP (w))
436 {
437 start_pc = here;
438 updated_fp = 1;
439 }
440 else
441 /* Don't bail out yet, if we are before the copy of sp. */
442 if (updated_fp)
443 break;
444 }
445
446 return start_pc;
447 }
448
449 static CORE_ADDR
450 sh_skip_prologue (CORE_ADDR pc)
451 {
452 CORE_ADDR post_prologue_pc;
453
454 /* See if we can determine the end of the prologue via the symbol table.
455 If so, then return either PC, or the PC after the prologue, whichever
456 is greater. */
457
458 post_prologue_pc = after_prologue (pc);
459
460 /* If after_prologue returned a useful address, then use it. Else
461 fall back on the instruction skipping code. */
462 if (post_prologue_pc != 0)
463 return max (pc, post_prologue_pc);
464 else
465 return (skip_prologue_hard_way (pc));
466 }
467
468 /* Immediately after a function call, return the saved pc.
469 Can't always go through the frames for this because on some machines
470 the new frame is not set up until the new function executes
471 some instructions.
472
473 The return address is the value saved in the PR register + 4 */
474 static CORE_ADDR
475 sh_saved_pc_after_call (struct frame_info *frame)
476 {
477 return (ADDR_BITS_REMOVE(read_register(PR_REGNUM)));
478 }
479
480 /* Should call_function allocate stack space for a struct return? */
481 static int
482 sh_use_struct_convention (int gcc_p, struct type *type)
483 {
484 return (TYPE_LENGTH (type) > 1);
485 }
486
487 /* Store the address of the place in which to copy the structure the
488 subroutine will return. This is called from call_function.
489
490 We store structs through a pointer passed in R0 */
491 static void
492 sh_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
493 {
494 write_register (STRUCT_RETURN_REGNUM, (addr));
495 }
496
497 /* Disassemble an instruction. */
498 static int
499 gdb_print_insn_sh (bfd_vma memaddr, disassemble_info *info)
500 {
501 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
502 return print_insn_sh (memaddr, info);
503 else
504 return print_insn_shl (memaddr, info);
505 }
506
507 /* Given a GDB frame, determine the address of the calling function's frame.
508 This will be used to create a new GDB frame struct, and then
509 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
510
511 For us, the frame address is its stack pointer value, so we look up
512 the function prologue to determine the caller's sp value, and return it. */
513 static CORE_ADDR
514 sh_frame_chain (struct frame_info *frame)
515 {
516 if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
517 return frame->frame; /* dummy frame same as caller's frame */
518 if (frame->pc && !inside_entry_file (frame->pc))
519 return read_memory_integer (FRAME_FP (frame) + frame->extra_info->f_offset, 4);
520 else
521 return 0;
522 }
523
524 /* Find REGNUM on the stack. Otherwise, it's in an active register. One thing
525 we might want to do here is to check REGNUM against the clobber mask, and
526 somehow flag it as invalid if it isn't saved on the stack somewhere. This
527 would provide a graceful failure mode when trying to get the value of
528 caller-saves registers for an inner frame. */
529
530 static CORE_ADDR
531 sh_find_callers_reg (struct frame_info *fi, int regnum)
532 {
533 for (; fi; fi = fi->next)
534 if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
535 /* When the caller requests PR from the dummy frame, we return PC because
536 that's where the previous routine appears to have done a call from. */
537 return generic_read_register_dummy (fi->pc, fi->frame, regnum);
538 else
539 {
540 FRAME_INIT_SAVED_REGS (fi);
541 if (!fi->pc)
542 return 0;
543 if (fi->saved_regs[regnum] != 0)
544 return read_memory_integer (fi->saved_regs[regnum],
545 REGISTER_RAW_SIZE (regnum));
546 }
547 return read_register (regnum);
548 }
549
550 /* Put here the code to store, into a struct frame_saved_regs, the
551 addresses of the saved registers of frame described by FRAME_INFO.
552 This includes special registers such as pc and fp saved in special
553 ways in the stack frame. sp is even more special: the address we
554 return for it IS the sp for the next frame. */
555 static void
556 sh_nofp_frame_init_saved_regs (struct frame_info *fi)
557 {
558 int where[NUM_REGS];
559 int rn;
560 int have_fp = 0;
561 int depth;
562 int pc;
563 int opc;
564 int insn;
565 int r3_val = 0;
566 char *dummy_regs = generic_find_dummy_frame (fi->pc, fi->frame);
567
568 if (fi->saved_regs == NULL)
569 frame_saved_regs_zalloc (fi);
570 else
571 memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
572
573 if (dummy_regs)
574 {
575 /* DANGER! This is ONLY going to work if the char buffer format of
576 the saved registers is byte-for-byte identical to the
577 CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */
578 memcpy (fi->saved_regs, dummy_regs, sizeof (fi->saved_regs));
579 return;
580 }
581
582 fi->extra_info->leaf_function = 1;
583 fi->extra_info->f_offset = 0;
584
585 for (rn = 0; rn < NUM_REGS; rn++)
586 where[rn] = -1;
587
588 depth = 0;
589
590 /* Loop around examining the prologue insns until we find something
591 that does not appear to be part of the prologue. But give up
592 after 20 of them, since we're getting silly then. */
593
594 pc = get_pc_function_start (fi->pc);
595 if (!pc)
596 {
597 fi->pc = 0;
598 return;
599 }
600
601 for (opc = pc + (2 * 28); pc < opc; pc += 2)
602 {
603 insn = read_memory_integer (pc, 2);
604 /* See where the registers will be saved to */
605 if (IS_PUSH (insn))
606 {
607 rn = GET_PUSHED_REG (insn);
608 where[rn] = depth;
609 depth += 4;
610 }
611 else if (IS_STS (insn))
612 {
613 where[PR_REGNUM] = depth;
614 /* If we're storing the pr then this isn't a leaf */
615 fi->extra_info->leaf_function = 0;
616 depth += 4;
617 }
618 else if (IS_MOV_R3 (insn))
619 {
620 r3_val = ((insn & 0xff) ^ 0x80) - 0x80;
621 }
622 else if (IS_SHLL_R3 (insn))
623 {
624 r3_val <<= 1;
625 }
626 else if (IS_ADD_R3SP (insn))
627 {
628 depth += -r3_val;
629 }
630 else if (IS_ADD_SP (insn))
631 {
632 depth -= ((insn & 0xff) ^ 0x80) - 0x80;
633 }
634 else if (IS_MOV_SP_FP (insn))
635 break;
636 #if 0 /* This used to just stop when it found an instruction that
637 was not considered part of the prologue. Now, we just
638 keep going looking for likely instructions. */
639 else
640 break;
641 #endif
642 }
643
644 /* Now we know how deep things are, we can work out their addresses */
645
646 for (rn = 0; rn < NUM_REGS; rn++)
647 {
648 if (where[rn] >= 0)
649 {
650 if (rn == FP_REGNUM)
651 have_fp = 1;
652
653 fi->saved_regs[rn] = fi->frame - where[rn] + depth - 4;
654 }
655 else
656 {
657 fi->saved_regs[rn] = 0;
658 }
659 }
660
661 if (have_fp)
662 {
663 fi->saved_regs[SP_REGNUM] = read_memory_integer (fi->saved_regs[FP_REGNUM], 4);
664 }
665 else
666 {
667 fi->saved_regs[SP_REGNUM] = fi->frame - 4;
668 }
669
670 fi->extra_info->f_offset = depth - where[FP_REGNUM] - 4;
671 /* Work out the return pc - either from the saved pr or the pr
672 value */
673 }
674
675 static void
676 sh_fp_frame_init_saved_regs (struct frame_info *fi)
677 {
678 int where[NUM_REGS];
679 int rn;
680 int have_fp = 0;
681 int depth;
682 int pc;
683 int opc;
684 int insn;
685 int r3_val = 0;
686 char *dummy_regs = generic_find_dummy_frame (fi->pc, fi->frame);
687
688 if (fi->saved_regs == NULL)
689 frame_saved_regs_zalloc (fi);
690 else
691 memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
692
693 if (dummy_regs)
694 {
695 /* DANGER! This is ONLY going to work if the char buffer format of
696 the saved registers is byte-for-byte identical to the
697 CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */
698 memcpy (fi->saved_regs, dummy_regs, sizeof (fi->saved_regs));
699 return;
700 }
701
702 fi->extra_info->leaf_function = 1;
703 fi->extra_info->f_offset = 0;
704
705 for (rn = 0; rn < NUM_REGS; rn++)
706 where[rn] = -1;
707
708 depth = 0;
709
710 /* Loop around examining the prologue insns until we find something
711 that does not appear to be part of the prologue. But give up
712 after 20 of them, since we're getting silly then. */
713
714 pc = get_pc_function_start (fi->pc);
715 if (!pc)
716 {
717 fi->pc = 0;
718 return;
719 }
720
721 for (opc = pc + (2 * 28); pc < opc; pc += 2)
722 {
723 insn = read_memory_integer (pc, 2);
724 /* See where the registers will be saved to */
725 if (IS_PUSH (insn))
726 {
727 rn = GET_PUSHED_REG (insn);
728 where[rn] = depth;
729 depth += 4;
730 }
731 else if (IS_STS (insn))
732 {
733 where[PR_REGNUM] = depth;
734 /* If we're storing the pr then this isn't a leaf */
735 fi->extra_info->leaf_function = 0;
736 depth += 4;
737 }
738 else if (IS_MOV_R3 (insn))
739 {
740 r3_val = ((insn & 0xff) ^ 0x80) - 0x80;
741 }
742 else if (IS_SHLL_R3 (insn))
743 {
744 r3_val <<= 1;
745 }
746 else if (IS_ADD_R3SP (insn))
747 {
748 depth += -r3_val;
749 }
750 else if (IS_ADD_SP (insn))
751 {
752 depth -= ((insn & 0xff) ^ 0x80) - 0x80;
753 }
754 else if (IS_FMOV (insn))
755 {
756 if (read_register (gdbarch_tdep (current_gdbarch)->FPSCR_REGNUM) & FPSCR_SZ)
757 {
758 depth += 8;
759 }
760 else
761 {
762 depth += 4;
763 }
764 }
765 else if (IS_MOV_SP_FP (insn))
766 break;
767 #if 0 /* This used to just stop when it found an instruction that
768 was not considered part of the prologue. Now, we just
769 keep going looking for likely instructions. */
770 else
771 break;
772 #endif
773 }
774
775 /* Now we know how deep things are, we can work out their addresses */
776
777 for (rn = 0; rn < NUM_REGS; rn++)
778 {
779 if (where[rn] >= 0)
780 {
781 if (rn == FP_REGNUM)
782 have_fp = 1;
783
784 fi->saved_regs[rn] = fi->frame - where[rn] + depth - 4;
785 }
786 else
787 {
788 fi->saved_regs[rn] = 0;
789 }
790 }
791
792 if (have_fp)
793 {
794 fi->saved_regs[SP_REGNUM] = read_memory_integer (fi->saved_regs[FP_REGNUM], 4);
795 }
796 else
797 {
798 fi->saved_regs[SP_REGNUM] = fi->frame - 4;
799 }
800
801 fi->extra_info->f_offset = depth - where[FP_REGNUM] - 4;
802 /* Work out the return pc - either from the saved pr or the pr
803 value */
804 }
805
806 /* Initialize the extra info saved in a FRAME */
807 static void
808 sh_init_extra_frame_info (int fromleaf, struct frame_info *fi)
809 {
810
811 fi->extra_info = (struct frame_extra_info *)
812 frame_obstack_alloc (sizeof (struct frame_extra_info));
813
814 if (fi->next)
815 fi->pc = FRAME_SAVED_PC (fi->next);
816
817 if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
818 {
819 /* We need to setup fi->frame here because run_stack_dummy gets it wrong
820 by assuming it's always FP. */
821 fi->frame = generic_read_register_dummy (fi->pc, fi->frame,
822 SP_REGNUM);
823 fi->extra_info->return_pc = generic_read_register_dummy (fi->pc, fi->frame,
824 PC_REGNUM);
825 fi->extra_info->f_offset = -(CALL_DUMMY_LENGTH + 4);
826 fi->extra_info->leaf_function = 0;
827 return;
828 }
829 else
830 {
831 FRAME_INIT_SAVED_REGS (fi);
832 fi->extra_info->return_pc = sh_find_callers_reg (fi, PR_REGNUM);
833 }
834 }
835
836 /* Extract from an array REGBUF containing the (raw) register state
837 the address in which a function should return its structure value,
838 as a CORE_ADDR (or an expression that can be used as one). */
839 static CORE_ADDR
840 sh_extract_struct_value_address (char *regbuf)
841 {
842 return (extract_address ((regbuf), REGISTER_RAW_SIZE (0)));
843 }
844
845 static CORE_ADDR
846 sh_frame_saved_pc (struct frame_info *frame)
847 {
848 return ((frame)->extra_info->return_pc);
849 }
850
851 /* Discard from the stack the innermost frame,
852 restoring all saved registers. */
853 static void
854 sh_pop_frame (void)
855 {
856 register struct frame_info *frame = get_current_frame ();
857 register CORE_ADDR fp;
858 register int regnum;
859
860 if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
861 generic_pop_dummy_frame ();
862 else
863 {
864 fp = FRAME_FP (frame);
865 FRAME_INIT_SAVED_REGS (frame);
866
867 /* Copy regs from where they were saved in the frame */
868 for (regnum = 0; regnum < NUM_REGS; regnum++)
869 if (frame->saved_regs[regnum])
870 write_register (regnum, read_memory_integer (frame->saved_regs[regnum], 4));
871
872 write_register (PC_REGNUM, frame->extra_info->return_pc);
873 write_register (SP_REGNUM, fp + 4);
874 }
875 flush_cached_frames ();
876 }
877
878 /* Function: push_arguments
879 Setup the function arguments for calling a function in the inferior.
880
881 On the Hitachi SH architecture, there are four registers (R4 to R7)
882 which are dedicated for passing function arguments. Up to the first
883 four arguments (depending on size) may go into these registers.
884 The rest go on the stack.
885
886 Arguments that are smaller than 4 bytes will still take up a whole
887 register or a whole 32-bit word on the stack, and will be
888 right-justified in the register or the stack word. This includes
889 chars, shorts, and small aggregate types.
890
891 Arguments that are larger than 4 bytes may be split between two or
892 more registers. If there are not enough registers free, an argument
893 may be passed partly in a register (or registers), and partly on the
894 stack. This includes doubles, long longs, and larger aggregates.
895 As far as I know, there is no upper limit to the size of aggregates
896 that will be passed in this way; in other words, the convention of
897 passing a pointer to a large aggregate instead of a copy is not used.
898
899 An exceptional case exists for struct arguments (and possibly other
900 aggregates such as arrays) if the size is larger than 4 bytes but
901 not a multiple of 4 bytes. In this case the argument is never split
902 between the registers and the stack, but instead is copied in its
903 entirety onto the stack, AND also copied into as many registers as
904 there is room for. In other words, space in registers permitting,
905 two copies of the same argument are passed in. As far as I can tell,
906 only the one on the stack is used, although that may be a function
907 of the level of compiler optimization. I suspect this is a compiler
908 bug. Arguments of these odd sizes are left-justified within the
909 word (as opposed to arguments smaller than 4 bytes, which are
910 right-justified).
911
912 If the function is to return an aggregate type such as a struct, it
913 is either returned in the normal return value register R0 (if its
914 size is no greater than one byte), or else the caller must allocate
915 space into which the callee will copy the return value (if the size
916 is greater than one byte). In this case, a pointer to the return
917 value location is passed into the callee in register R2, which does
918 not displace any of the other arguments passed in via registers R4
919 to R7. */
920
921 static CORE_ADDR
922 sh_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
923 int struct_return, CORE_ADDR struct_addr)
924 {
925 int stack_offset, stack_alloc;
926 int argreg;
927 int argnum;
928 struct type *type;
929 CORE_ADDR regval;
930 char *val;
931 char valbuf[4];
932 int len;
933 int odd_sized_struct;
934
935 /* first force sp to a 4-byte alignment */
936 sp = sp & ~3;
937
938 /* The "struct return pointer" pseudo-argument has its own dedicated
939 register */
940 if (struct_return)
941 write_register (STRUCT_RETURN_REGNUM, struct_addr);
942
943 /* Now make sure there's space on the stack */
944 for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
945 stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3);
946 sp -= stack_alloc; /* make room on stack for args */
947
948 /* Now load as many as possible of the first arguments into
949 registers, and push the rest onto the stack. There are 16 bytes
950 in four registers available. Loop thru args from first to last. */
951
952 argreg = ARG0_REGNUM;
953 for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
954 {
955 type = VALUE_TYPE (args[argnum]);
956 len = TYPE_LENGTH (type);
957 memset (valbuf, 0, sizeof (valbuf));
958 if (len < 4)
959 {
960 /* value gets right-justified in the register or stack word */
961 memcpy (valbuf + (4 - len),
962 (char *) VALUE_CONTENTS (args[argnum]), len);
963 val = valbuf;
964 }
965 else
966 val = (char *) VALUE_CONTENTS (args[argnum]);
967
968 if (len > 4 && (len & 3) != 0)
969 odd_sized_struct = 1; /* such structs go entirely on stack */
970 else
971 odd_sized_struct = 0;
972 while (len > 0)
973 {
974 if (argreg > ARGLAST_REGNUM || odd_sized_struct)
975 { /* must go on the stack */
976 write_memory (sp + stack_offset, val, 4);
977 stack_offset += 4;
978 }
979 /* NOTE WELL!!!!! This is not an "else if" clause!!!
980 That's because some *&^%$ things get passed on the stack
981 AND in the registers! */
982 if (argreg <= ARGLAST_REGNUM)
983 { /* there's room in a register */
984 regval = extract_address (val, REGISTER_RAW_SIZE (argreg));
985 write_register (argreg++, regval);
986 }
987 /* Store the value 4 bytes at a time. This means that things
988 larger than 4 bytes may go partly in registers and partly
989 on the stack. */
990 len -= REGISTER_RAW_SIZE (argreg);
991 val += REGISTER_RAW_SIZE (argreg);
992 }
993 }
994 return sp;
995 }
996
997 /* Function: push_return_address (pc)
998 Set up the return address for the inferior function call.
999 Needed for targets where we don't actually execute a JSR/BSR instruction */
1000
1001 static CORE_ADDR
1002 sh_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
1003 {
1004 write_register (PR_REGNUM, CALL_DUMMY_ADDRESS ());
1005 return sp;
1006 }
1007
1008 /* Function: fix_call_dummy
1009 Poke the callee function's address into the destination part of
1010 the CALL_DUMMY. The address is actually stored in a data word
1011 following the actualy CALL_DUMMY instructions, which will load
1012 it into a register using PC-relative addressing. This function
1013 expects the CALL_DUMMY to look like this:
1014
1015 mov.w @(2,PC), R8
1016 jsr @R8
1017 nop
1018 trap
1019 <destination>
1020 */
1021
1022 #if 0
1023 void
1024 sh_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
1025 value_ptr *args, struct type *type, int gcc_p)
1026 {
1027 *(unsigned long *) (dummy + 8) = fun;
1028 }
1029 #endif
1030
1031 static int
1032 sh_coerce_float_to_double (struct type *formal, struct type *actual)
1033 {
1034 return 1;
1035 }
1036
1037 /* Find a function's return value in the appropriate registers (in
1038 regbuf), and copy it into valbuf. Extract from an array REGBUF
1039 containing the (raw) register state a function return value of type
1040 TYPE, and copy that, in virtual format, into VALBUF. */
1041 static void
1042 sh_extract_return_value (struct type *type, char *regbuf, char *valbuf)
1043 {
1044 int len = TYPE_LENGTH (type);
1045
1046 if (len <= 4)
1047 memcpy (valbuf, ((char *) regbuf) + 4 - len, len);
1048 else if (len <= 8)
1049 memcpy (valbuf, ((char *) regbuf) + 8 - len, len);
1050 else
1051 error ("bad size for return value");
1052 }
1053
1054 /* Write into appropriate registers a function return value
1055 of type TYPE, given in virtual format.
1056 If the architecture is sh4 or sh3e, store a function's return value
1057 in the R0 general register or in the FP0 floating point register,
1058 depending on the type of the return value. In all the other cases
1059 the result is stored in r0. */
1060 static void
1061 sh_default_store_return_value (struct type *type, char *valbuf)
1062 {
1063 char buf[32]; /* more than enough... */
1064
1065 if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (R0_REGNUM))
1066 {
1067 /* Add leading zeros to the value. */
1068 memset (buf, 0, REGISTER_RAW_SIZE (R0_REGNUM));
1069 memcpy (buf + REGISTER_RAW_SIZE (R0_REGNUM) - TYPE_LENGTH (type),
1070 valbuf, TYPE_LENGTH (type));
1071 write_register_bytes (REGISTER_BYTE (R0_REGNUM), buf,
1072 REGISTER_RAW_SIZE (R0_REGNUM));
1073 }
1074 else
1075 write_register_bytes (REGISTER_BYTE (R0_REGNUM), valbuf,
1076 TYPE_LENGTH (type));
1077 }
1078
1079 static void
1080 sh3e_sh4_store_return_value (struct type *type, char *valbuf)
1081 {
1082 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1083 write_register_bytes (REGISTER_BYTE (FP0_REGNUM),
1084 valbuf, TYPE_LENGTH (type));
1085 else
1086 sh_default_store_return_value (type, valbuf);
1087 }
1088
1089
1090 /* Print the registers in a form similar to the E7000 */
1091
1092 static void
1093 sh_generic_show_regs (void)
1094 {
1095 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1096 paddr (read_register (PC_REGNUM)),
1097 (long) read_register (gdbarch_tdep (current_gdbarch)->SR_REGNUM),
1098 (long) read_register (PR_REGNUM),
1099 (long) read_register (MACH_REGNUM),
1100 (long) read_register (MACL_REGNUM));
1101
1102 printf_filtered ("GBR=%08lx VBR=%08lx",
1103 (long) read_register (GBR_REGNUM),
1104 (long) read_register (VBR_REGNUM));
1105
1106 printf_filtered ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1107 (long) read_register (0),
1108 (long) read_register (1),
1109 (long) read_register (2),
1110 (long) read_register (3),
1111 (long) read_register (4),
1112 (long) read_register (5),
1113 (long) read_register (6),
1114 (long) read_register (7));
1115 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1116 (long) read_register (8),
1117 (long) read_register (9),
1118 (long) read_register (10),
1119 (long) read_register (11),
1120 (long) read_register (12),
1121 (long) read_register (13),
1122 (long) read_register (14),
1123 (long) read_register (15));
1124 }
1125
1126 static void
1127 sh3_show_regs (void)
1128 {
1129 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1130 paddr (read_register (PC_REGNUM)),
1131 (long) read_register (gdbarch_tdep (current_gdbarch)->SR_REGNUM),
1132 (long) read_register (PR_REGNUM),
1133 (long) read_register (MACH_REGNUM),
1134 (long) read_register (MACL_REGNUM));
1135
1136 printf_filtered ("GBR=%08lx VBR=%08lx",
1137 (long) read_register (GBR_REGNUM),
1138 (long) read_register (VBR_REGNUM));
1139 printf_filtered (" SSR=%08lx SPC=%08lx",
1140 (long) read_register (gdbarch_tdep (current_gdbarch)->SSR_REGNUM),
1141 (long) read_register (gdbarch_tdep (current_gdbarch)->SPC_REGNUM));
1142
1143 printf_filtered ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1144 (long) read_register (0),
1145 (long) read_register (1),
1146 (long) read_register (2),
1147 (long) read_register (3),
1148 (long) read_register (4),
1149 (long) read_register (5),
1150 (long) read_register (6),
1151 (long) read_register (7));
1152 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1153 (long) read_register (8),
1154 (long) read_register (9),
1155 (long) read_register (10),
1156 (long) read_register (11),
1157 (long) read_register (12),
1158 (long) read_register (13),
1159 (long) read_register (14),
1160 (long) read_register (15));
1161 }
1162
1163
1164 static void
1165 sh3e_show_regs (void)
1166 {
1167 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1168 paddr (read_register (PC_REGNUM)),
1169 (long) read_register (gdbarch_tdep (current_gdbarch)->SR_REGNUM),
1170 (long) read_register (PR_REGNUM),
1171 (long) read_register (MACH_REGNUM),
1172 (long) read_register (MACL_REGNUM));
1173
1174 printf_filtered ("GBR=%08lx VBR=%08lx",
1175 (long) read_register (GBR_REGNUM),
1176 (long) read_register (VBR_REGNUM));
1177 printf_filtered (" SSR=%08lx SPC=%08lx",
1178 (long) read_register (gdbarch_tdep (current_gdbarch)->SSR_REGNUM),
1179 (long) read_register (gdbarch_tdep (current_gdbarch)->SPC_REGNUM));
1180 printf_filtered (" FPUL=%08lx FPSCR=%08lx",
1181 (long) read_register (gdbarch_tdep (current_gdbarch)->FPUL_REGNUM),
1182 (long) read_register (gdbarch_tdep (current_gdbarch)->FPSCR_REGNUM));
1183
1184 printf_filtered ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1185 (long) read_register (0),
1186 (long) read_register (1),
1187 (long) read_register (2),
1188 (long) read_register (3),
1189 (long) read_register (4),
1190 (long) read_register (5),
1191 (long) read_register (6),
1192 (long) read_register (7));
1193 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1194 (long) read_register (8),
1195 (long) read_register (9),
1196 (long) read_register (10),
1197 (long) read_register (11),
1198 (long) read_register (12),
1199 (long) read_register (13),
1200 (long) read_register (14),
1201 (long) read_register (15));
1202
1203 printf_filtered (("FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1204 (long) read_register (FP0_REGNUM + 0),
1205 (long) read_register (FP0_REGNUM + 1),
1206 (long) read_register (FP0_REGNUM + 2),
1207 (long) read_register (FP0_REGNUM + 3),
1208 (long) read_register (FP0_REGNUM + 4),
1209 (long) read_register (FP0_REGNUM + 5),
1210 (long) read_register (FP0_REGNUM + 6),
1211 (long) read_register (FP0_REGNUM + 7));
1212 printf_filtered (("FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1213 (long) read_register (FP0_REGNUM + 8),
1214 (long) read_register (FP0_REGNUM + 9),
1215 (long) read_register (FP0_REGNUM + 10),
1216 (long) read_register (FP0_REGNUM + 11),
1217 (long) read_register (FP0_REGNUM + 12),
1218 (long) read_register (FP0_REGNUM + 13),
1219 (long) read_register (FP0_REGNUM + 14),
1220 (long) read_register (FP0_REGNUM + 15));
1221 }
1222
1223 static void
1224 sh3_dsp_show_regs (void)
1225 {
1226 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1227 paddr (read_register (PC_REGNUM)),
1228 (long) read_register (gdbarch_tdep (current_gdbarch)->SR_REGNUM),
1229 (long) read_register (PR_REGNUM),
1230 (long) read_register (MACH_REGNUM),
1231 (long) read_register (MACL_REGNUM));
1232
1233 printf_filtered ("GBR=%08lx VBR=%08lx",
1234 (long) read_register (GBR_REGNUM),
1235 (long) read_register (VBR_REGNUM));
1236
1237 printf_filtered (" SSR=%08lx SPC=%08lx",
1238 (long) read_register (gdbarch_tdep (current_gdbarch)->SSR_REGNUM),
1239 (long) read_register (gdbarch_tdep (current_gdbarch)->SPC_REGNUM));
1240
1241 printf_filtered (" DSR=%08lx",
1242 (long) read_register (gdbarch_tdep (current_gdbarch)->DSR_REGNUM));
1243
1244 printf_filtered ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1245 (long) read_register (0),
1246 (long) read_register (1),
1247 (long) read_register (2),
1248 (long) read_register (3),
1249 (long) read_register (4),
1250 (long) read_register (5),
1251 (long) read_register (6),
1252 (long) read_register (7));
1253 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1254 (long) read_register (8),
1255 (long) read_register (9),
1256 (long) read_register (10),
1257 (long) read_register (11),
1258 (long) read_register (12),
1259 (long) read_register (13),
1260 (long) read_register (14),
1261 (long) read_register (15));
1262
1263 printf_filtered ("A0G=%02lx A0=%08lx M0=%08lx X0=%08lx Y0=%08lx RS=%08lx MOD=%08lx\n",
1264 (long) read_register (gdbarch_tdep (current_gdbarch)->A0G_REGNUM) & 0xff,
1265 (long) read_register (gdbarch_tdep (current_gdbarch)->A0_REGNUM),
1266 (long) read_register (gdbarch_tdep (current_gdbarch)->M0_REGNUM),
1267 (long) read_register (gdbarch_tdep (current_gdbarch)->X0_REGNUM),
1268 (long) read_register (gdbarch_tdep (current_gdbarch)->Y0_REGNUM),
1269 (long) read_register (gdbarch_tdep (current_gdbarch)->RS_REGNUM),
1270 (long) read_register (gdbarch_tdep (current_gdbarch)->MOD_REGNUM));
1271 printf_filtered ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
1272 (long) read_register (gdbarch_tdep (current_gdbarch)->A1G_REGNUM) & 0xff,
1273 (long) read_register (gdbarch_tdep (current_gdbarch)->A1_REGNUM),
1274 (long) read_register (gdbarch_tdep (current_gdbarch)->M1_REGNUM),
1275 (long) read_register (gdbarch_tdep (current_gdbarch)->X1_REGNUM),
1276 (long) read_register (gdbarch_tdep (current_gdbarch)->Y1_REGNUM),
1277 (long) read_register (gdbarch_tdep (current_gdbarch)->RE_REGNUM));
1278 }
1279
1280 static void
1281 sh4_show_regs (void)
1282 {
1283 int pr = read_register (gdbarch_tdep (current_gdbarch)->FPSCR_REGNUM) & 0x80000;
1284 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1285 paddr (read_register (PC_REGNUM)),
1286 (long) read_register (gdbarch_tdep (current_gdbarch)->SR_REGNUM),
1287 (long) read_register (PR_REGNUM),
1288 (long) read_register (MACH_REGNUM),
1289 (long) read_register (MACL_REGNUM));
1290
1291 printf_filtered ("GBR=%08lx VBR=%08lx",
1292 (long) read_register (GBR_REGNUM),
1293 (long) read_register (VBR_REGNUM));
1294 printf_filtered (" SSR=%08lx SPC=%08lx",
1295 (long) read_register (gdbarch_tdep (current_gdbarch)->SSR_REGNUM),
1296 (long) read_register (gdbarch_tdep (current_gdbarch)->SPC_REGNUM));
1297 printf_filtered (" FPUL=%08lx FPSCR=%08lx",
1298 (long) read_register (gdbarch_tdep (current_gdbarch)->FPUL_REGNUM),
1299 (long) read_register (gdbarch_tdep (current_gdbarch)->FPSCR_REGNUM));
1300
1301 printf_filtered ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1302 (long) read_register (0),
1303 (long) read_register (1),
1304 (long) read_register (2),
1305 (long) read_register (3),
1306 (long) read_register (4),
1307 (long) read_register (5),
1308 (long) read_register (6),
1309 (long) read_register (7));
1310 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1311 (long) read_register (8),
1312 (long) read_register (9),
1313 (long) read_register (10),
1314 (long) read_register (11),
1315 (long) read_register (12),
1316 (long) read_register (13),
1317 (long) read_register (14),
1318 (long) read_register (15));
1319
1320 printf_filtered ((pr
1321 ? "DR0-DR6 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
1322 : "FP0-FP7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1323 (long) read_register (FP0_REGNUM + 0),
1324 (long) read_register (FP0_REGNUM + 1),
1325 (long) read_register (FP0_REGNUM + 2),
1326 (long) read_register (FP0_REGNUM + 3),
1327 (long) read_register (FP0_REGNUM + 4),
1328 (long) read_register (FP0_REGNUM + 5),
1329 (long) read_register (FP0_REGNUM + 6),
1330 (long) read_register (FP0_REGNUM + 7));
1331 printf_filtered ((pr
1332 ? "DR8-DR14 %08lx%08lx %08lx%08lx %08lx%08lx %08lx%08lx\n"
1333 : "FP8-FP15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n"),
1334 (long) read_register (FP0_REGNUM + 8),
1335 (long) read_register (FP0_REGNUM + 9),
1336 (long) read_register (FP0_REGNUM + 10),
1337 (long) read_register (FP0_REGNUM + 11),
1338 (long) read_register (FP0_REGNUM + 12),
1339 (long) read_register (FP0_REGNUM + 13),
1340 (long) read_register (FP0_REGNUM + 14),
1341 (long) read_register (FP0_REGNUM + 15));
1342 }
1343
1344 static void
1345 sh_dsp_show_regs (void)
1346 {
1347 printf_filtered ("PC=%s SR=%08lx PR=%08lx MACH=%08lx MACHL=%08lx\n",
1348 paddr (read_register (PC_REGNUM)),
1349 (long) read_register (gdbarch_tdep (current_gdbarch)->SR_REGNUM),
1350 (long) read_register (PR_REGNUM),
1351 (long) read_register (MACH_REGNUM),
1352 (long) read_register (MACL_REGNUM));
1353
1354 printf_filtered ("GBR=%08lx VBR=%08lx",
1355 (long) read_register (GBR_REGNUM),
1356 (long) read_register (VBR_REGNUM));
1357
1358 printf_filtered (" DSR=%08lx",
1359 (long) read_register (gdbarch_tdep (current_gdbarch)->DSR_REGNUM));
1360
1361 printf_filtered ("\nR0-R7 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1362 (long) read_register (0),
1363 (long) read_register (1),
1364 (long) read_register (2),
1365 (long) read_register (3),
1366 (long) read_register (4),
1367 (long) read_register (5),
1368 (long) read_register (6),
1369 (long) read_register (7));
1370 printf_filtered ("R8-R15 %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
1371 (long) read_register (8),
1372 (long) read_register (9),
1373 (long) read_register (10),
1374 (long) read_register (11),
1375 (long) read_register (12),
1376 (long) read_register (13),
1377 (long) read_register (14),
1378 (long) read_register (15));
1379
1380 printf_filtered ("A0G=%02lx A0=%08lx M0=%08lx X0=%08lx Y0=%08lx RS=%08lx MOD=%08lx\n",
1381 (long) read_register (gdbarch_tdep (current_gdbarch)->A0G_REGNUM) & 0xff,
1382 (long) read_register (gdbarch_tdep (current_gdbarch)->A0_REGNUM),
1383 (long) read_register (gdbarch_tdep (current_gdbarch)->M0_REGNUM),
1384 (long) read_register (gdbarch_tdep (current_gdbarch)->X0_REGNUM),
1385 (long) read_register (gdbarch_tdep (current_gdbarch)->Y0_REGNUM),
1386 (long) read_register (gdbarch_tdep (current_gdbarch)->RS_REGNUM),
1387 (long) read_register (gdbarch_tdep (current_gdbarch)->MOD_REGNUM));
1388 printf_filtered ("A1G=%02lx A1=%08lx M1=%08lx X1=%08lx Y1=%08lx RE=%08lx\n",
1389 (long) read_register (gdbarch_tdep (current_gdbarch)->A1G_REGNUM) & 0xff,
1390 (long) read_register (gdbarch_tdep (current_gdbarch)->A1_REGNUM),
1391 (long) read_register (gdbarch_tdep (current_gdbarch)->M1_REGNUM),
1392 (long) read_register (gdbarch_tdep (current_gdbarch)->X1_REGNUM),
1393 (long) read_register (gdbarch_tdep (current_gdbarch)->Y1_REGNUM),
1394 (long) read_register (gdbarch_tdep (current_gdbarch)->RE_REGNUM));
1395 }
1396
1397 void sh_show_regs_command (char *args, int from_tty)
1398 {
1399 if (sh_show_regs)
1400 (*sh_show_regs)();
1401 }
1402
1403 /* Index within `registers' of the first byte of the space for
1404 register N. */
1405 static int
1406 sh_default_register_byte (int reg_nr)
1407 {
1408 return (reg_nr * 4);
1409 }
1410
1411 static int
1412 sh_sh4_register_byte (int reg_nr)
1413 {
1414 if (reg_nr >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1415 && reg_nr <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1416 return (dr_reg_base_num (reg_nr) * 4);
1417 else if (reg_nr >= gdbarch_tdep (current_gdbarch)->FV0_REGNUM
1418 && reg_nr <= gdbarch_tdep (current_gdbarch)->FV_LAST_REGNUM)
1419 return (fv_reg_base_num (reg_nr) * 4);
1420 else
1421 return (reg_nr * 4);
1422 }
1423
1424 /* Number of bytes of storage in the actual machine representation for
1425 register REG_NR. */
1426 static int
1427 sh_default_register_raw_size (int reg_nr)
1428 {
1429 return 4;
1430 }
1431
1432 static int
1433 sh_sh4_register_raw_size (int reg_nr)
1434 {
1435 if (reg_nr >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1436 && reg_nr <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1437 return 8;
1438 else if (reg_nr >= gdbarch_tdep (current_gdbarch)->FV0_REGNUM
1439 && reg_nr <= gdbarch_tdep (current_gdbarch)->FV_LAST_REGNUM)
1440 return 16;
1441 else
1442 return 4;
1443 }
1444
1445 /* Number of bytes of storage in the program's representation
1446 for register N. */
1447 static int
1448 sh_register_virtual_size (int reg_nr)
1449 {
1450 return 4;
1451 }
1452
1453 /* Return the GDB type object for the "standard" data type
1454 of data in register N. */
1455
1456 static struct type *
1457 sh_sh3e_register_virtual_type (int reg_nr)
1458 {
1459 if ((reg_nr >= FP0_REGNUM
1460 && (reg_nr <= gdbarch_tdep (current_gdbarch)->FP_LAST_REGNUM))
1461 || (reg_nr == gdbarch_tdep (current_gdbarch)->FPUL_REGNUM))
1462 return builtin_type_float;
1463 else
1464 return builtin_type_int;
1465 }
1466
1467 static struct type *
1468 sh_sh4_register_virtual_type (int reg_nr)
1469 {
1470 if ((reg_nr >= FP0_REGNUM
1471 && (reg_nr <= gdbarch_tdep (current_gdbarch)->FP_LAST_REGNUM))
1472 || (reg_nr == gdbarch_tdep (current_gdbarch)->FPUL_REGNUM))
1473 return builtin_type_float;
1474 else if (reg_nr >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1475 && reg_nr <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1476 return builtin_type_double;
1477 else if (reg_nr >= gdbarch_tdep (current_gdbarch)->FV0_REGNUM
1478 && reg_nr <= gdbarch_tdep (current_gdbarch)->FV_LAST_REGNUM)
1479 return sh_sh4_build_float_register_type (3);
1480 else
1481 return builtin_type_int;
1482 }
1483
1484 static struct type *
1485 sh_sh4_build_float_register_type (int high)
1486 {
1487 struct type *temp;
1488
1489 temp = create_range_type (NULL, builtin_type_int, 0, high);
1490 return create_array_type (NULL, builtin_type_float, temp);
1491 }
1492
1493 static struct type *
1494 sh_default_register_virtual_type (int reg_nr)
1495 {
1496 return builtin_type_int;
1497 }
1498
1499 /* On the sh4, the DRi pseudo registers are problematic if the target
1500 is little endian. When the user writes one of those registers, for
1501 instance with 'ser var $dr0=1', we want the double to be stored
1502 like this:
1503 fr0 = 0x00 0x00 0x00 0x00 0x00 0xf0 0x3f
1504 fr1 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
1505
1506 This corresponds to little endian byte order & big endian word
1507 order. However if we let gdb write the register w/o conversion, it
1508 will write fr0 and fr1 this way:
1509 fr0 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
1510 fr1 = 0x00 0x00 0x00 0x00 0x00 0xf0 0x3f
1511 because it will consider fr0 and fr1 as a single LE stretch of memory.
1512
1513 To achieve what we want we must force gdb to store things in
1514 floatformat_ieee_double_littlebyte_bigword (which is defined in
1515 include/floatformat.h and libiberty/floatformat.c.
1516
1517 In case the target is big endian, there is no problem, the
1518 raw bytes will look like:
1519 fr0 = 0x3f 0xf0 0x00 0x00 0x00 0x00 0x00
1520 fr1 = 0x00 0x00 0x00 0x00 0x00 0x00 0x00
1521
1522 The other pseudo registers (the FVs) also don't pose a problem
1523 because they are stored as 4 individual FP elements. */
1524
1525 int
1526 sh_sh4_register_convertible (int nr)
1527 {
1528 if (TARGET_BYTE_ORDER == LITTLE_ENDIAN)
1529 return (gdbarch_tdep (current_gdbarch)->DR0_REGNUM <= nr
1530 && nr <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM);
1531 else
1532 return 0;
1533 }
1534
1535 void
1536 sh_sh4_register_convert_to_virtual (int regnum, struct type *type,
1537 char *from, char *to)
1538 {
1539 if (regnum >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1540 && regnum <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1541 {
1542 DOUBLEST val;
1543 floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword, from, &val);
1544 store_floating(to, TYPE_LENGTH(type), val);
1545 }
1546 else
1547 error("sh_register_convert_to_virtual called with non DR register number");
1548 }
1549
1550 void
1551 sh_sh4_register_convert_to_raw (struct type *type, int regnum,
1552 char *from, char *to)
1553 {
1554 if (regnum >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1555 && regnum <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1556 {
1557 DOUBLEST val = extract_floating (from, TYPE_LENGTH(type));
1558 floatformat_from_doublest (&floatformat_ieee_double_littlebyte_bigword, &val, to);
1559 }
1560 else
1561 error("sh_register_convert_to_raw called with non DR register number");
1562 }
1563
1564 void
1565 sh_fetch_pseudo_register (int reg_nr)
1566 {
1567 int base_regnum, portion;
1568
1569 if (!register_cached (reg_nr))
1570 {
1571 if (reg_nr >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1572 && reg_nr <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1573 {
1574 base_regnum = dr_reg_base_num (reg_nr);
1575
1576 /* Read the real regs for which this one is an alias. */
1577 for (portion = 0; portion < 2; portion++)
1578 if (!register_cached (base_regnum + portion))
1579 target_fetch_registers (base_regnum + portion);
1580 }
1581 else if (reg_nr >= gdbarch_tdep (current_gdbarch)->FV0_REGNUM
1582 && reg_nr <= gdbarch_tdep (current_gdbarch)->FV_LAST_REGNUM)
1583 {
1584 base_regnum = fv_reg_base_num (reg_nr);
1585
1586 /* Read the real regs for which this one is an alias. */
1587 for (portion = 0; portion < 4; portion++)
1588 if (!register_cached (base_regnum + portion))
1589 target_fetch_registers (base_regnum + portion);
1590
1591 }
1592 register_valid [reg_nr] = 1;
1593 }
1594 }
1595
1596 void
1597 sh_store_pseudo_register (int reg_nr)
1598 {
1599 int base_regnum, portion;
1600
1601 if (reg_nr >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1602 && reg_nr <= gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1603 {
1604 base_regnum = dr_reg_base_num (reg_nr);
1605
1606 /* Write the real regs for which this one is an alias. */
1607 for (portion = 0; portion < 2; portion++)
1608 {
1609 register_valid[base_regnum + portion] = 1;
1610 target_store_registers (base_regnum + portion);
1611 }
1612 }
1613 else if (reg_nr >= gdbarch_tdep (current_gdbarch)->FV0_REGNUM
1614 && reg_nr <= gdbarch_tdep (current_gdbarch)->FV_LAST_REGNUM)
1615 {
1616 base_regnum = fv_reg_base_num (reg_nr);
1617
1618 /* Write the real regs for which this one is an alias. */
1619 for (portion = 0; portion < 4; portion++)
1620 {
1621 register_valid[base_regnum + portion] = 1;
1622 target_store_registers (base_regnum + portion);
1623 }
1624 }
1625 }
1626
1627 static int
1628 fv_reg_base_num (int fv_regnum)
1629 {
1630 int fp_regnum;
1631
1632 fp_regnum = FP0_REGNUM +
1633 (fv_regnum - gdbarch_tdep (current_gdbarch)->FV0_REGNUM) * 4;
1634 return fp_regnum;
1635 }
1636
1637 static int
1638 dr_reg_base_num (int dr_regnum)
1639 {
1640 int fp_regnum;
1641
1642 fp_regnum = FP0_REGNUM +
1643 (dr_regnum - gdbarch_tdep (current_gdbarch)->DR0_REGNUM) * 2;
1644 return fp_regnum;
1645 }
1646
1647 static void
1648 do_fv_register_info (int fv_regnum)
1649 {
1650 int first_fp_reg_num = fv_reg_base_num (fv_regnum);
1651 printf_filtered ("fv%d\t0x%08x\t0x%08x\t0x%08x\t0x%08x\n",
1652 fv_regnum - gdbarch_tdep (current_gdbarch)->FV0_REGNUM,
1653 (int) read_register (first_fp_reg_num),
1654 (int) read_register (first_fp_reg_num + 1),
1655 (int) read_register (first_fp_reg_num + 2),
1656 (int) read_register (first_fp_reg_num + 3));
1657 }
1658
1659 static void
1660 do_dr_register_info (int dr_regnum)
1661 {
1662 int first_fp_reg_num = dr_reg_base_num (dr_regnum);
1663
1664 printf_filtered ("dr%d\t0x%08x%08x\n",
1665 dr_regnum - gdbarch_tdep (current_gdbarch)->DR0_REGNUM,
1666 (int) read_register (first_fp_reg_num),
1667 (int) read_register (first_fp_reg_num + 1));
1668 }
1669
1670 static void
1671 sh_do_pseudo_register (int regnum)
1672 {
1673 if (regnum < NUM_REGS || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
1674 internal_error ("Invalid pseudo register number %d\n", regnum);
1675 else if (regnum >= gdbarch_tdep (current_gdbarch)->DR0_REGNUM
1676 && regnum < gdbarch_tdep (current_gdbarch)->DR_LAST_REGNUM)
1677 do_dr_register_info (regnum);
1678 else if (regnum >= gdbarch_tdep (current_gdbarch)->FV0_REGNUM
1679 && regnum <= gdbarch_tdep (current_gdbarch)->FV_LAST_REGNUM)
1680 do_fv_register_info (regnum);
1681 }
1682
1683
1684 static void
1685 sh_do_fp_register (int regnum)
1686 { /* do values for FP (float) regs */
1687 char *raw_buffer;
1688 double flt; /* double extracted from raw hex data */
1689 int inv;
1690 int j;
1691
1692 /* Allocate space for the float. */
1693 raw_buffer = (char *) alloca (REGISTER_RAW_SIZE (FP0_REGNUM));
1694
1695 /* Get the data in raw format. */
1696 if (read_relative_register_raw_bytes (regnum, raw_buffer))
1697 error ("can't read register %d (%s)", regnum, REGISTER_NAME (regnum));
1698
1699 /* Get the register as a number */
1700 flt = unpack_double (builtin_type_float, raw_buffer, &inv);
1701
1702 /* Print the name and some spaces. */
1703 fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
1704 print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), gdb_stdout);
1705
1706 /* Print the value. */
1707 printf_filtered (inv ? "<invalid float>" : "%-10.9g", flt);
1708
1709 /* Print the fp register as hex. */
1710 printf_filtered ("\t(raw 0x");
1711 for (j = 0; j < REGISTER_RAW_SIZE (regnum); j++)
1712 {
1713 register int idx = TARGET_BYTE_ORDER == BIG_ENDIAN ? j
1714 : REGISTER_RAW_SIZE (regnum) - 1 - j;
1715 printf_filtered ("%02x", (unsigned char) raw_buffer[idx]);
1716 }
1717 printf_filtered (")");
1718 printf_filtered ("\n");
1719 }
1720
1721 static void
1722 sh_do_register (int regnum)
1723 {
1724 char raw_buffer[MAX_REGISTER_RAW_SIZE];
1725
1726 fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
1727 print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), gdb_stdout);
1728
1729 /* Get the data in raw format. */
1730 if (read_relative_register_raw_bytes (regnum, raw_buffer))
1731 printf_filtered ("*value not available*\n");
1732
1733 val_print (REGISTER_VIRTUAL_TYPE (regnum), raw_buffer, 0, 0,
1734 gdb_stdout, 'x', 1, 0, Val_pretty_default);
1735 printf_filtered ("\t");
1736 val_print (REGISTER_VIRTUAL_TYPE (regnum), raw_buffer, 0, 0,
1737 gdb_stdout, 0, 1, 0, Val_pretty_default);
1738 printf_filtered ("\n");
1739 }
1740
1741 static void
1742 sh_print_register (int regnum)
1743 {
1744 if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
1745 internal_error ("Invalid register number %d\n", regnum);
1746
1747 else if (regnum >= 0 && regnum < NUM_REGS)
1748 {
1749 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
1750 sh_do_fp_register (regnum); /* FP regs */
1751 else
1752 sh_do_register (regnum); /* All other regs */
1753 }
1754
1755 else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
1756 sh_do_pseudo_register (regnum);
1757 }
1758
1759 void
1760 sh_do_registers_info (int regnum, int fpregs)
1761 {
1762 if (regnum != -1) /* do one specified register */
1763 {
1764 if (*(REGISTER_NAME (regnum)) == '\0')
1765 error ("Not a valid register for the current processor type");
1766
1767 sh_print_register (regnum);
1768 }
1769 else
1770 /* do all (or most) registers */
1771 {
1772 regnum = 0;
1773 while (regnum < NUM_REGS)
1774 {
1775 /* If the register name is empty, it is undefined for this
1776 processor, so don't display anything. */
1777 if (REGISTER_NAME (regnum) == NULL
1778 || *(REGISTER_NAME (regnum)) == '\0')
1779 {
1780 regnum++;
1781 continue;
1782 }
1783
1784 if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (regnum)) == TYPE_CODE_FLT)
1785 {
1786 if (fpregs)
1787 {
1788 /* true for "INFO ALL-REGISTERS" command */
1789 sh_do_fp_register (regnum); /* FP regs */
1790 regnum ++;
1791 }
1792 else
1793 regnum += (gdbarch_tdep (current_gdbarch)->FP_LAST_REGNUM - FP0_REGNUM); /* skip FP regs */
1794 }
1795 else
1796 {
1797 sh_do_register (regnum); /* All other regs */
1798 regnum++;
1799 }
1800 }
1801
1802 if (fpregs)
1803 while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
1804 {
1805 sh_do_pseudo_register (regnum);
1806 regnum++;
1807 }
1808 }
1809 }
1810
1811 #ifdef SVR4_SHARED_LIBS
1812
1813 /* Fetch (and possibly build) an appropriate link_map_offsets structure
1814 for native i386 linux targets using the struct offsets defined in
1815 link.h (but without actual reference to that file).
1816
1817 This makes it possible to access i386-linux shared libraries from
1818 a gdb that was not built on an i386-linux host (for cross debugging).
1819 */
1820
1821 struct link_map_offsets *
1822 sh_linux_svr4_fetch_link_map_offsets (void)
1823 {
1824 static struct link_map_offsets lmo;
1825 static struct link_map_offsets *lmp = 0;
1826
1827 if (lmp == 0)
1828 {
1829 lmp = &lmo;
1830
1831 lmo.r_debug_size = 8; /* 20 not actual size but all we need */
1832
1833 lmo.r_map_offset = 4;
1834 lmo.r_map_size = 4;
1835
1836 lmo.link_map_size = 20; /* 552 not actual size but all we need */
1837
1838 lmo.l_addr_offset = 0;
1839 lmo.l_addr_size = 4;
1840
1841 lmo.l_name_offset = 4;
1842 lmo.l_name_size = 4;
1843
1844 lmo.l_next_offset = 12;
1845 lmo.l_next_size = 4;
1846
1847 lmo.l_prev_offset = 16;
1848 lmo.l_prev_size = 4;
1849 }
1850
1851 return lmp;
1852 }
1853 #endif /* SVR4_SHARED_LIBS */
1854
1855 static gdbarch_init_ftype sh_gdbarch_init;
1856
1857 static struct gdbarch *
1858 sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1859 {
1860 static LONGEST sh_call_dummy_words[] = {0};
1861 struct gdbarch *gdbarch;
1862 struct gdbarch_tdep *tdep;
1863 gdbarch_register_name_ftype *sh_register_name;
1864 gdbarch_store_return_value_ftype *sh_store_return_value;
1865 gdbarch_register_virtual_type_ftype *sh_register_virtual_type;
1866
1867 /* Find a candidate among the list of pre-declared architectures. */
1868 arches = gdbarch_list_lookup_by_info (arches, &info);
1869 if (arches != NULL)
1870 return arches->gdbarch;
1871
1872 /* None found, create a new architecture from the information
1873 provided. */
1874 tdep = XMALLOC (struct gdbarch_tdep);
1875 gdbarch = gdbarch_alloc (&info, tdep);
1876
1877 /* Initialize the register numbers that are not common to all the
1878 variants to -1, if necessary thse will be overwritten in the case
1879 statement below. */
1880 tdep->FPUL_REGNUM = -1;
1881 tdep->FPSCR_REGNUM = -1;
1882 tdep->SR_REGNUM = 22;
1883 tdep->DSR_REGNUM = -1;
1884 tdep->FP_LAST_REGNUM = -1;
1885 tdep->A0G_REGNUM = -1;
1886 tdep->A0_REGNUM = -1;
1887 tdep->A1G_REGNUM = -1;
1888 tdep->A1_REGNUM = -1;
1889 tdep->M0_REGNUM = -1;
1890 tdep->M1_REGNUM = -1;
1891 tdep->X0_REGNUM = -1;
1892 tdep->X1_REGNUM = -1;
1893 tdep->Y0_REGNUM = -1;
1894 tdep->Y1_REGNUM = -1;
1895 tdep->MOD_REGNUM = -1;
1896 tdep->RS_REGNUM = -1;
1897 tdep->RE_REGNUM = -1;
1898 tdep->SSR_REGNUM = -1;
1899 tdep->SPC_REGNUM = -1;
1900 tdep->DR0_REGNUM = -1;
1901 tdep->DR_LAST_REGNUM = -1;
1902 tdep->FV0_REGNUM = -1;
1903 tdep->FV_LAST_REGNUM = -1;
1904
1905 set_gdbarch_fp0_regnum (gdbarch, -1);
1906 set_gdbarch_num_pseudo_regs (gdbarch, 0);
1907 set_gdbarch_max_register_raw_size (gdbarch, 4);
1908 set_gdbarch_max_register_virtual_size (gdbarch, 4);
1909 set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1910 set_gdbarch_num_regs (gdbarch, 59);
1911 set_gdbarch_sp_regnum (gdbarch, 15);
1912 set_gdbarch_fp_regnum (gdbarch, 14);
1913 set_gdbarch_pc_regnum (gdbarch, 16);
1914 set_gdbarch_register_size (gdbarch, 4);
1915 set_gdbarch_register_bytes (gdbarch, NUM_REGS * 4);
1916 set_gdbarch_fetch_pseudo_register (gdbarch, sh_fetch_pseudo_register);
1917 set_gdbarch_store_pseudo_register (gdbarch, sh_store_pseudo_register);
1918 set_gdbarch_do_registers_info (gdbarch, sh_do_registers_info);
1919 set_gdbarch_breakpoint_from_pc (gdbarch, sh_breakpoint_from_pc);
1920 print_sh_insn = gdb_print_insn_sh;
1921
1922 switch (info.bfd_arch_info->mach)
1923 {
1924 case bfd_mach_sh:
1925 sh_register_name = sh_sh_register_name;
1926 sh_show_regs = sh_generic_show_regs;
1927 sh_store_return_value = sh_default_store_return_value;
1928 sh_register_virtual_type = sh_default_register_virtual_type;
1929 set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
1930 set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
1931 set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
1932 set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
1933 break;
1934 case bfd_mach_sh2:
1935 sh_register_name = sh_sh_register_name;
1936 sh_show_regs = sh_generic_show_regs;
1937 sh_store_return_value = sh_default_store_return_value;
1938 sh_register_virtual_type = sh_default_register_virtual_type;
1939 set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
1940 set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
1941 set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
1942 set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
1943 break;
1944 case bfd_mach_sh_dsp:
1945 sh_register_name = sh_sh_dsp_register_name;
1946 sh_show_regs = sh_dsp_show_regs;
1947 sh_store_return_value = sh_default_store_return_value;
1948 sh_register_virtual_type = sh_default_register_virtual_type;
1949 set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
1950 set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
1951 set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
1952 set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
1953 tdep->DSR_REGNUM = 24;
1954 tdep->A0G_REGNUM = 25;
1955 tdep->A0_REGNUM = 26;
1956 tdep->A1G_REGNUM = 27;
1957 tdep->A1_REGNUM = 28;
1958 tdep->M0_REGNUM = 29;
1959 tdep->M1_REGNUM = 30;
1960 tdep->X0_REGNUM = 31;
1961 tdep->X1_REGNUM = 32;
1962 tdep->Y0_REGNUM = 33;
1963 tdep->Y1_REGNUM = 34;
1964 tdep->MOD_REGNUM = 40;
1965 tdep->RS_REGNUM = 43;
1966 tdep->RE_REGNUM = 44;
1967 break;
1968 case bfd_mach_sh3:
1969 sh_register_name = sh_sh3_register_name;
1970 sh_show_regs = sh3_show_regs;
1971 sh_store_return_value = sh_default_store_return_value;
1972 sh_register_virtual_type = sh_default_register_virtual_type;
1973 set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
1974 set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
1975 set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
1976 set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
1977 tdep->SSR_REGNUM = 41;
1978 tdep->SPC_REGNUM = 42;
1979 break;
1980 case bfd_mach_sh3e:
1981 sh_register_name = sh_sh3e_register_name;
1982 sh_show_regs = sh3e_show_regs;
1983 sh_store_return_value = sh3e_sh4_store_return_value;
1984 sh_register_virtual_type = sh_sh3e_register_virtual_type;
1985 set_gdbarch_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs);
1986 set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
1987 set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
1988 set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
1989 set_gdbarch_fp0_regnum (gdbarch, 25);
1990 tdep->FPUL_REGNUM = 23;
1991 tdep->FPSCR_REGNUM = 24;
1992 tdep->FP_LAST_REGNUM = 40;
1993 tdep->SSR_REGNUM = 41;
1994 tdep->SPC_REGNUM = 42;
1995 break;
1996 case bfd_mach_sh3_dsp:
1997 sh_register_name = sh_sh3_dsp_register_name;
1998 sh_show_regs = sh3_dsp_show_regs;
1999 sh_store_return_value = sh_default_store_return_value;
2000 sh_register_virtual_type = sh_default_register_virtual_type;
2001 set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
2002 set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
2003 set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
2004 set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
2005 tdep->DSR_REGNUM = 24;
2006 tdep->A0G_REGNUM = 25;
2007 tdep->A0_REGNUM = 26;
2008 tdep->A1G_REGNUM = 27;
2009 tdep->A1_REGNUM = 28;
2010 tdep->M0_REGNUM = 29;
2011 tdep->M1_REGNUM = 30;
2012 tdep->X0_REGNUM = 31;
2013 tdep->X1_REGNUM = 32;
2014 tdep->Y0_REGNUM = 33;
2015 tdep->Y1_REGNUM = 34;
2016 tdep->MOD_REGNUM = 40;
2017 tdep->RS_REGNUM = 43;
2018 tdep->RE_REGNUM = 44;
2019 tdep->SSR_REGNUM = 41;
2020 tdep->SPC_REGNUM = 42;
2021 break;
2022 case bfd_mach_sh4:
2023 sh_register_name = sh_sh4_register_name;
2024 sh_show_regs = sh4_show_regs;
2025 sh_store_return_value = sh3e_sh4_store_return_value;
2026 sh_register_virtual_type = sh_sh4_register_virtual_type;
2027 set_gdbarch_frame_init_saved_regs (gdbarch, sh_fp_frame_init_saved_regs);
2028 set_gdbarch_fp0_regnum (gdbarch, 25);
2029 set_gdbarch_register_raw_size (gdbarch, sh_sh4_register_raw_size);
2030 set_gdbarch_register_virtual_size (gdbarch, sh_sh4_register_raw_size);
2031 set_gdbarch_register_byte (gdbarch, sh_sh4_register_byte);
2032 set_gdbarch_num_pseudo_regs (gdbarch, 12);
2033 set_gdbarch_max_register_raw_size (gdbarch, 4 * 4);
2034 set_gdbarch_max_register_virtual_size (gdbarch, 4 * 4);
2035 set_gdbarch_register_convert_to_raw (gdbarch, sh_sh4_register_convert_to_raw);
2036 set_gdbarch_register_convert_to_virtual (gdbarch, sh_sh4_register_convert_to_virtual);
2037 set_gdbarch_register_convertible (gdbarch, sh_sh4_register_convertible);
2038 tdep->FPUL_REGNUM = 23;
2039 tdep->FPSCR_REGNUM = 24;
2040 tdep->FP_LAST_REGNUM = 40;
2041 tdep->SSR_REGNUM = 41;
2042 tdep->SPC_REGNUM = 42;
2043 tdep->DR0_REGNUM = 59;
2044 tdep->DR_LAST_REGNUM = 66;
2045 tdep->FV0_REGNUM = 67;
2046 tdep->FV_LAST_REGNUM = 70;
2047 break;
2048 default:
2049 sh_register_name = sh_generic_register_name;
2050 sh_show_regs = sh_generic_show_regs;
2051 sh_store_return_value = sh_default_store_return_value;
2052 sh_register_virtual_type = sh_default_register_virtual_type;
2053 set_gdbarch_frame_init_saved_regs (gdbarch, sh_nofp_frame_init_saved_regs);
2054 set_gdbarch_register_raw_size (gdbarch, sh_default_register_raw_size);
2055 set_gdbarch_register_virtual_size (gdbarch, sh_default_register_raw_size);
2056 set_gdbarch_register_byte (gdbarch, sh_default_register_byte);
2057 break;
2058 }
2059
2060 set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
2061 set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
2062 set_gdbarch_read_fp (gdbarch, generic_target_read_fp);
2063 set_gdbarch_write_fp (gdbarch, generic_target_write_fp);
2064 set_gdbarch_read_sp (gdbarch, generic_target_read_sp);
2065 set_gdbarch_write_sp (gdbarch, generic_target_write_sp);
2066
2067 set_gdbarch_register_name (gdbarch, sh_register_name);
2068 set_gdbarch_register_virtual_type (gdbarch, sh_register_virtual_type);
2069
2070 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
2071 set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2072 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2073 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2074 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
2075 set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
2076 set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT);/*??should be 8?*/
2077
2078 set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
2079 set_gdbarch_call_dummy_length (gdbarch, 0);
2080 set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
2081 set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
2082 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1); /*???*/
2083 set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
2084 set_gdbarch_call_dummy_start_offset (gdbarch, 0);
2085 set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
2086 set_gdbarch_call_dummy_words (gdbarch, sh_call_dummy_words);
2087 set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (sh_call_dummy_words));
2088 set_gdbarch_call_dummy_p (gdbarch, 1);
2089 set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
2090 set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
2091 set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
2092 set_gdbarch_coerce_float_to_double (gdbarch,
2093 sh_coerce_float_to_double);
2094
2095 set_gdbarch_extract_return_value (gdbarch, sh_extract_return_value);
2096 set_gdbarch_push_arguments (gdbarch, sh_push_arguments);
2097 set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
2098 set_gdbarch_push_return_address (gdbarch, sh_push_return_address);
2099
2100 set_gdbarch_store_struct_return (gdbarch, sh_store_struct_return);
2101 set_gdbarch_store_return_value (gdbarch, sh_store_return_value);
2102 set_gdbarch_extract_struct_value_address (gdbarch, sh_extract_struct_value_address);
2103 set_gdbarch_use_struct_convention (gdbarch, sh_use_struct_convention);
2104 set_gdbarch_init_extra_frame_info (gdbarch, sh_init_extra_frame_info);
2105 set_gdbarch_pop_frame (gdbarch, sh_pop_frame);
2106 set_gdbarch_skip_prologue (gdbarch, sh_skip_prologue);
2107 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2108 set_gdbarch_decr_pc_after_break (gdbarch, 0);
2109 set_gdbarch_function_start_offset (gdbarch, 0);
2110
2111 set_gdbarch_frame_args_skip (gdbarch, 0);
2112 set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue);
2113 set_gdbarch_frame_chain (gdbarch, sh_frame_chain);
2114 set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
2115 set_gdbarch_frame_saved_pc (gdbarch, sh_frame_saved_pc);
2116 set_gdbarch_frame_args_address (gdbarch, default_frame_address);
2117 set_gdbarch_frame_locals_address (gdbarch, default_frame_address);
2118 set_gdbarch_saved_pc_after_call (gdbarch, sh_saved_pc_after_call);
2119 set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
2120 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
2121 set_gdbarch_ieee_float (gdbarch, 1);
2122 tm_print_insn = print_sh_insn;
2123
2124 return gdbarch;
2125 }
2126
2127 void
2128 _initialize_sh_tdep (void)
2129 {
2130 struct cmd_list_element *c;
2131
2132 register_gdbarch_init (bfd_arch_sh, sh_gdbarch_init);
2133
2134 add_com ("regs", class_vars, sh_show_regs_command, "Print all registers");
2135 }
The GNU Binutils are a collection of binary tools.