1 /* Target-dependent code for Hitachi Super-H, for GDB.
2 Copyright (C) 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 Contributed by Steve Chamberlain
34 #include "inferior.h" /* for BEFORE_TEXT_END etc. */
36 extern int remote_write_size
; /* in remote.c */
38 /* Default to the original SH. */
40 #define DEFAULT_SH_TYPE "sh"
42 /* This value is the model of SH in use. */
44 char *sh_processor_type
;
46 char *tmp_sh_processor_type
;
48 /* A set of original names, to be used when restoring back to generic
49 registers from a specific set. */
51 char *sh_generic_reg_names
[] = REGISTER_NAMES
;
53 char *sh_reg_names
[] = {
54 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
55 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
56 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
58 "", "", "", "", "", "", "", "",
59 "", "", "", "", "", "", "", "",
61 "", "", "", "", "", "", "", "",
62 "", "", "", "", "", "", "", "",
65 char *sh3_reg_names
[] = {
66 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
67 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
68 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
70 "", "", "", "", "", "", "", "",
71 "", "", "", "", "", "", "", "",
73 "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
74 "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1"
77 char *sh3e_reg_names
[] = {
78 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
79 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
80 "pc", "pr", "gbr", "vbr", "mach", "macl", "sr",
82 "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
83 "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
85 "r0b0", "r1b0", "r2b0", "r3b0", "r4b0", "r5b0", "r6b0", "r7b0",
86 "r0b1", "r1b1", "r2b1", "r3b1", "r4b1", "r5b1", "r6b1", "r7b1",
92 } sh_processor_type_table
[] = {
93 { "sh", sh_reg_names
},
94 { "sh3", sh3_reg_names
},
95 { "sh3e", sh3e_reg_names
},
99 /* Prologue looks like
100 [mov.l <regs>,@-r15]...
106 #define IS_STS(x) ((x) == 0x4f22)
107 #define IS_PUSH(x) (((x) & 0xff0f) == 0x2f06)
108 #define GET_PUSHED_REG(x) (((x) >> 4) & 0xf)
109 #define IS_MOV_SP_FP(x) ((x) == 0x6ef3)
110 #define IS_ADD_SP(x) (((x) & 0xff00) == 0x7f00)
111 #define IS_MOV_R3(x) (((x) & 0xff00) == 0x1a00)
112 #define IS_SHLL_R3(x) ((x) == 0x4300)
113 #define IS_ADD_R3SP(x) ((x) == 0x3f3c)
115 /* Skip any prologue before the guts of a function */
118 sh_skip_prologue (start_pc
)
123 w
= read_memory_integer (start_pc
, 2);
133 w
= read_memory_integer (start_pc
, 2);
139 /* Disassemble an instruction. */
142 gdb_print_insn_sh (memaddr
, info
)
144 disassemble_info
*info
;
146 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
147 return print_insn_sh (memaddr
, info
);
149 return print_insn_shl (memaddr
, info
);
152 /* Given a GDB frame, determine the address of the calling function's frame.
153 This will be used to create a new GDB frame struct, and then
154 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
156 For us, the frame address is its stack pointer value, so we look up
157 the function prologue to determine the caller's sp value, and return it. */
160 sh_frame_chain (frame
)
161 struct frame_info
*frame
;
163 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
164 return frame
->frame
; /* dummy frame same as caller's frame */
165 if (!inside_entry_file (frame
->pc
))
166 return read_memory_integer (FRAME_FP (frame
) + frame
->f_offset
, 4);
171 /* Find REGNUM on the stack. Otherwise, it's in an active register. One thing
172 we might want to do here is to check REGNUM against the clobber mask, and
173 somehow flag it as invalid if it isn't saved on the stack somewhere. This
174 would provide a graceful failure mode when trying to get the value of
175 caller-saves registers for an inner frame. */
178 sh_find_callers_reg (fi
, regnum
)
179 struct frame_info
*fi
;
182 struct frame_saved_regs fsr
;
184 for (; fi
; fi
= fi
->next
)
185 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
186 /* When the caller requests PR from the dummy frame, we return PC because
187 that's where the previous routine appears to have done a call from. */
188 return generic_read_register_dummy (fi
->pc
, fi
->frame
, regnum
);
191 FRAME_FIND_SAVED_REGS(fi
, fsr
);
192 if (fsr
.regs
[regnum
] != 0)
193 return read_memory_integer (fsr
.regs
[regnum
],
194 REGISTER_RAW_SIZE(regnum
));
196 return read_register (regnum
);
199 /* Put here the code to store, into a struct frame_saved_regs, the
200 addresses of the saved registers of frame described by FRAME_INFO.
201 This includes special registers such as pc and fp saved in special
202 ways in the stack frame. sp is even more special: the address we
203 return for it IS the sp for the next frame. */
206 sh_frame_find_saved_regs (fi
, fsr
)
207 struct frame_info
*fi
;
208 struct frame_saved_regs
*fsr
;
218 char * dummy_regs
= generic_find_dummy_frame (fi
->pc
, fi
->frame
);
222 /* DANGER! This is ONLY going to work if the char buffer format of
223 the saved registers is byte-for-byte identical to the
224 CORE_ADDR regs[NUM_REGS] format used by struct frame_saved_regs! */
225 memcpy (&fsr
->regs
, dummy_regs
, sizeof(fsr
));
229 opc
= pc
= get_pc_function_start (fi
->pc
);
231 insn
= read_memory_integer (pc
, 2);
233 fi
->leaf_function
= 1;
236 for (rn
= 0; rn
< NUM_REGS
; rn
++)
241 /* Loop around examining the prologue insns, but give up
242 after 15 of them, since we're getting silly then */
243 while (pc
< opc
+ 15 * 2)
245 /* See where the registers will be saved to */
249 rn
= GET_PUSHED_REG (insn
);
251 insn
= read_memory_integer (pc
, 2);
254 else if (IS_STS (insn
))
257 where
[PR_REGNUM
] = depth
;
258 insn
= read_memory_integer (pc
, 2);
259 /* If we're storing the pr then this isn't a leaf */
260 fi
->leaf_function
= 0;
263 else if (IS_MOV_R3 (insn
))
265 r3_val
= (char) (insn
& 0xff);
267 insn
= read_memory_integer (pc
, 2);
269 else if (IS_SHLL_R3 (insn
))
273 insn
= read_memory_integer (pc
, 2);
275 else if (IS_ADD_R3SP (insn
))
279 insn
= read_memory_integer (pc
, 2);
281 else if (IS_ADD_SP (insn
))
284 depth
+= -((char) (insn
& 0xff));
285 insn
= read_memory_integer (pc
, 2);
291 /* Now we know how deep things are, we can work out their addresses */
293 for (rn
= 0; rn
< NUM_REGS
; rn
++)
300 fsr
->regs
[rn
] = fi
->frame
- where
[rn
] + depth
- 4;
310 fsr
->regs
[SP_REGNUM
] = read_memory_integer (fsr
->regs
[FP_REGNUM
], 4);
314 fsr
->regs
[SP_REGNUM
] = fi
->frame
- 4;
317 fi
->f_offset
= depth
- where
[FP_REGNUM
] - 4;
318 /* Work out the return pc - either from the saved pr or the pr
322 /* initialize the extra info saved in a FRAME */
325 sh_init_extra_frame_info (fromleaf
, fi
)
327 struct frame_info
*fi
;
329 struct frame_saved_regs fsr
;
332 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
334 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
336 /* We need to setup fi->frame here because run_stack_dummy gets it wrong
337 by assuming it's always FP. */
338 fi
->frame
= generic_read_register_dummy (fi
->pc
, fi
->frame
,
340 fi
->return_pc
= generic_read_register_dummy (fi
->pc
, fi
->frame
,
342 fi
->f_offset
= -(CALL_DUMMY_LENGTH
+ 4);
343 fi
->leaf_function
= 0;
348 FRAME_FIND_SAVED_REGS (fi
, fsr
);
349 fi
->return_pc
= sh_find_callers_reg (fi
, PR_REGNUM
);
353 /* Discard from the stack the innermost frame,
354 restoring all saved registers. */
359 register struct frame_info
*frame
= get_current_frame ();
360 register CORE_ADDR fp
;
362 struct frame_saved_regs fsr
;
364 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
365 generic_pop_dummy_frame ();
368 fp
= FRAME_FP (frame
);
369 get_frame_saved_regs (frame
, &fsr
);
371 /* Copy regs from where they were saved in the frame */
372 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
373 if (fsr
.regs
[regnum
])
374 write_register (regnum
, read_memory_integer (fsr
.regs
[regnum
], 4));
376 write_register (PC_REGNUM
, frame
->return_pc
);
377 write_register (SP_REGNUM
, fp
+ 4);
379 flush_cached_frames ();
382 /* Function: push_arguments
383 Setup the function arguments for calling a function in the inferior.
385 On the Hitachi SH architecture, there are four registers (R4 to R7)
386 which are dedicated for passing function arguments. Up to the first
387 four arguments (depending on size) may go into these registers.
388 The rest go on the stack.
390 Arguments that are smaller than 4 bytes will still take up a whole
391 register or a whole 32-bit word on the stack, and will be
392 right-justified in the register or the stack word. This includes
393 chars, shorts, and small aggregate types.
395 Arguments that are larger than 4 bytes may be split between two or
396 more registers. If there are not enough registers free, an argument
397 may be passed partly in a register (or registers), and partly on the
398 stack. This includes doubles, long longs, and larger aggregates.
399 As far as I know, there is no upper limit to the size of aggregates
400 that will be passed in this way; in other words, the convention of
401 passing a pointer to a large aggregate instead of a copy is not used.
403 An exceptional case exists for struct arguments (and possibly other
404 aggregates such as arrays) if the size is larger than 4 bytes but
405 not a multiple of 4 bytes. In this case the argument is never split
406 between the registers and the stack, but instead is copied in its
407 entirety onto the stack, AND also copied into as many registers as
408 there is room for. In other words, space in registers permitting,
409 two copies of the same argument are passed in. As far as I can tell,
410 only the one on the stack is used, although that may be a function
411 of the level of compiler optimization. I suspect this is a compiler
412 bug. Arguments of these odd sizes are left-justified within the
413 word (as opposed to arguments smaller than 4 bytes, which are
417 If the function is to return an aggregate type such as a struct, it
418 is either returned in the normal return value register R0 (if its
419 size is no greater than one byte), or else the caller must allocate
420 space into which the callee will copy the return value (if the size
421 is greater than one byte). In this case, a pointer to the return
422 value location is passed into the callee in register R2, which does
423 not displace any of the other arguments passed in via registers R4
427 sh_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
431 unsigned char struct_return
;
432 CORE_ADDR struct_addr
;
434 int stack_offset
, stack_alloc
;
442 int odd_sized_struct
;
444 /* first force sp to a 4-byte alignment */
447 /* The "struct return pointer" pseudo-argument has its own dedicated
450 write_register (STRUCT_RETURN_REGNUM
, struct_addr
);
452 /* Now make sure there's space on the stack */
453 for (argnum
= 0, stack_alloc
= 0;
454 argnum
< nargs
; argnum
++)
455 stack_alloc
+= ((TYPE_LENGTH(VALUE_TYPE(args
[argnum
])) + 3) & ~3);
456 sp
-= stack_alloc
; /* make room on stack for args */
459 /* Now load as many as possible of the first arguments into
460 registers, and push the rest onto the stack. There are 16 bytes
461 in four registers available. Loop thru args from first to last. */
463 argreg
= ARG0_REGNUM
;
464 for (argnum
= 0, stack_offset
= 0; argnum
< nargs
; argnum
++)
466 type
= VALUE_TYPE (args
[argnum
]);
467 len
= TYPE_LENGTH (type
);
468 memset(valbuf
, 0, sizeof(valbuf
));
470 { /* value gets right-justified in the register or stack word */
471 memcpy(valbuf
+ (4 - len
),
472 (char *) VALUE_CONTENTS (args
[argnum
]), len
);
476 val
= (char *) VALUE_CONTENTS (args
[argnum
]);
478 if (len
> 4 && (len
& 3) != 0)
479 odd_sized_struct
= 1; /* such structs go entirely on stack */
481 odd_sized_struct
= 0;
484 if (argreg
> ARGLAST_REGNUM
|| odd_sized_struct
)
485 { /* must go on the stack */
486 write_memory (sp
+ stack_offset
, val
, 4);
489 /* NOTE WELL!!!!! This is not an "else if" clause!!!
490 That's because some *&^%$ things get passed on the stack
491 AND in the registers! */
492 if (argreg
<= ARGLAST_REGNUM
)
493 { /* there's room in a register */
494 regval
= extract_address (val
, REGISTER_RAW_SIZE(argreg
));
495 write_register (argreg
++, regval
);
497 /* Store the value 4 bytes at a time. This means that things
498 larger than 4 bytes may go partly in registers and partly
500 len
-= REGISTER_RAW_SIZE(argreg
);
501 val
+= REGISTER_RAW_SIZE(argreg
);
507 /* Function: push_return_address (pc)
508 Set up the return address for the inferior function call.
509 Needed for targets where we don't actually execute a JSR/BSR instruction */
512 sh_push_return_address (pc
, sp
)
516 write_register (PR_REGNUM
, CALL_DUMMY_ADDRESS ());
520 /* Function: fix_call_dummy
521 Poke the callee function's address into the destination part of
522 the CALL_DUMMY. The address is actually stored in a data word
523 following the actualy CALL_DUMMY instructions, which will load
524 it into a register using PC-relative addressing. This function
525 expects the CALL_DUMMY to look like this:
535 sh_fix_call_dummy (dummy
, pc
, fun
, nargs
, args
, type
, gcc_p
)
544 *(unsigned long *) (dummy
+ 8) = fun
;
547 /* Function: get_saved_register
548 Just call the generic_get_saved_register function. */
551 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
555 struct frame_info
*frame
;
557 enum lval_type
*lval
;
559 generic_get_saved_register (raw_buffer
, optimized
, addrp
,
560 frame
, regnum
, lval
);
564 /* Command to set the processor type. */
567 sh_set_processor_type_command (args
, from_tty
)
574 /* The `set' commands work by setting the value, then calling the hook,
575 so we let the general command modify a scratch location, then decide
576 here if we really want to modify the processor type. */
577 if (tmp_sh_processor_type
== NULL
|| *tmp_sh_processor_type
== '\0')
579 printf_unfiltered ("The known SH processor types are as follows:\n\n");
580 for (i
= 0; sh_processor_type_table
[i
].name
!= NULL
; ++i
)
581 printf_unfiltered ("%s\n", sh_processor_type_table
[i
].name
);
583 /* Restore the value. */
584 tmp_sh_processor_type
= strsave (sh_processor_type
);
589 if (!sh_set_processor_type (tmp_sh_processor_type
))
591 /* Restore to a valid value before erroring out. */
592 temp
= tmp_sh_processor_type
;
593 tmp_sh_processor_type
= strsave (sh_processor_type
);
594 error ("Unknown processor type `%s'.", temp
);
598 /* This is a dummy not actually run. */
601 sh_show_processor_type_command (args
, from_tty
)
607 /* Modify the actual processor type. */
610 sh_set_processor_type (str
)
618 for (i
= 0; sh_processor_type_table
[i
].name
!= NULL
; ++i
)
620 if (strcasecmp (str
, sh_processor_type_table
[i
].name
) == 0)
622 sh_processor_type
= str
;
624 for (j
= 0; j
< NUM_REGS
; ++j
)
625 reg_names
[j
] = sh_processor_type_table
[i
].regnames
[j
];
634 /* Print the registers in a form similar to the E7000 */
637 sh_show_regs (args
, from_tty
)
641 printf_filtered ("PC=%08x SR=%08x PR=%08x MACH=%08x MACHL=%08x\n",
642 read_register (PC_REGNUM
),
643 read_register (SR_REGNUM
),
644 read_register (PR_REGNUM
),
645 read_register (MACH_REGNUM
),
646 read_register (MACL_REGNUM
));
648 printf_filtered ("R0-R7 %08x %08x %08x %08x %08x %08x %08x %08x\n",
657 printf_filtered ("R8-R15 %08x %08x %08x %08x %08x %08x %08x %08x\n",
668 /* Function: extract_return_value
669 Find a function's return value in the appropriate registers (in regbuf),
670 and copy it into valbuf. */
673 sh_extract_return_value (type
, regbuf
, valbuf
)
678 int len
= TYPE_LENGTH(type
);
681 memcpy (valbuf
, ((char *) regbuf
) + 4 - len
, len
);
683 memcpy (valbuf
, ((char *) regbuf
) + 8 - len
, len
);
685 error ("bad size for return value");
689 _initialize_sh_tdep ()
691 struct cmd_list_element
*c
;
693 tm_print_insn
= gdb_print_insn_sh
;
695 c
= add_set_cmd ("processor", class_support
, var_string_noescape
,
696 (char *) &tmp_sh_processor_type
,
697 "Set the type of SH processor in use.\n\
698 Set this to be able to access processor-type-specific registers.\n\
701 c
->function
.cfunc
= sh_set_processor_type_command
;
702 c
= add_show_from_set (c
, &showlist
);
703 c
->function
.cfunc
= sh_show_processor_type_command
;
705 tmp_sh_processor_type
= strsave (DEFAULT_SH_TYPE
);
706 sh_set_processor_type_command (strsave (DEFAULT_SH_TYPE
), 0);
708 add_com ("regs", class_vars
, sh_show_regs
, "Print all registers");
710 /* Reduce the remote write size because some CMONs can't take
711 more than 400 bytes in a packet. 300 seems like a safe bet. */
712 remote_write_size
= 300;