1 /* Target-machine dependent code for Hitachi Super-H, for GDB.
2 Copyright (C) 1993 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 Contributed by Steve Chamberlain
33 #include "../opcodes/sh-opc.h"
37 /* Prologue looks like
38 [mov.l <regs>,@-r15]...
44 #define IS_STS(x) ((x) == 0x4f22)
45 #define IS_PUSH(x) (((x) & 0xff0f) == 0x2f06)
46 #define GET_PUSHED_REG(x) (((x) >> 4) & 0xf)
47 #define IS_MOV_SP_FP(x) ((x) == 0x6ef3)
48 #define IS_ADD_SP(x) (((x) & 0xff00) == 0x7f00)
49 #define IS_MOV_R3(x) (((x) & 0xff00) == 0x1a00)
50 #define IS_SHLL_R3(x) ((x) == 0x4300)
51 #define IS_ADD_R3SP(x) ((x) == 0x3f3c)
53 /* Skip any prologue before the guts of a function */
56 sh_skip_prologue (start_pc
)
61 w
= read_memory_integer (start_pc
, 2);
71 w
= read_memory_integer (start_pc
, 2);
77 /* Disassemble an instruction */
80 print_insn (memaddr
, stream
)
84 disassemble_info info
;
86 GDB_INIT_DISASSEMBLE_INFO (info
, stream
);
88 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
89 return print_insn_sh (memaddr
, &info
);
91 return print_insn_shl (memaddr
, &info
);
93 /* Given a GDB frame, determine the address of the calling function's frame.
94 This will be used to create a new GDB frame struct, and then
95 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
97 For us, the frame address is its stack pointer value, so we look up
98 the function prologue to determine the caller's sp value, and return it. */
101 sh_frame_chain (frame
)
102 struct frame_info
*frame
;
104 if (!inside_entry_file (frame
->pc
))
105 return read_memory_integer (FRAME_FP (frame
) + frame
->f_offset
, 4);
110 /* Put here the code to store, into a struct frame_saved_regs,
111 the addresses of the saved registers of frame described by FRAME_INFO.
112 This includes special registers such as pc and fp saved in special
113 ways in the stack frame. sp is even more special:
114 the address we return for it IS the sp for the next frame. */
118 frame_find_saved_regs (fi
, fsr
)
119 struct frame_info
*fi
;
120 struct frame_saved_regs
*fsr
;
132 opc
= pc
= get_pc_function_start (fi
->pc
);
134 insn
= read_memory_integer (pc
, 2);
136 fi
->leaf_function
= 1;
139 for (rn
= 0; rn
< NUM_REGS
; rn
++)
144 /* Loop around examining the prologue insns, but give up
145 after 15 of them, since we're getting silly then */
146 while (pc
< opc
+ 15 * 2)
148 /* See where the registers will be saved to */
152 rn
= GET_PUSHED_REG (insn
);
154 insn
= read_memory_integer (pc
, 2);
157 else if (IS_STS (insn
))
160 where
[PR_REGNUM
] = depth
;
161 insn
= read_memory_integer (pc
, 2);
162 /* If we're storing the pr then this isn't a leaf */
163 fi
->leaf_function
= 0;
166 else if (IS_MOV_R3 (insn
))
168 r3_val
= (char) (insn
& 0xff);
170 insn
= read_memory_integer (pc
, 2);
172 else if (IS_SHLL_R3 (insn
))
176 insn
= read_memory_integer (pc
, 2);
178 else if (IS_ADD_R3SP (insn
))
182 insn
= read_memory_integer (pc
, 2);
184 else if (IS_ADD_SP (insn
))
187 depth
+= -((char) (insn
& 0xff));
188 insn
= read_memory_integer (pc
, 2);
194 /* Now we know how deep things are, we can work out their addresses */
196 for (rn
= 0; rn
< NUM_REGS
; rn
++)
203 fsr
->regs
[rn
] = fi
->frame
- where
[rn
] + depth
- 4;
213 fsr
->regs
[SP_REGNUM
] = read_memory_integer (fsr
->regs
[FP_REGNUM
], 4);
217 fsr
->regs
[SP_REGNUM
] = fi
->frame
- 4;
220 fi
->f_offset
= depth
- where
[FP_REGNUM
] - 4;
221 /* Work out the return pc - either from the saved pr or the pr
223 /* Just called, so dig out the real return */
224 if (fi
->return_pc
== 0)
226 fi
->return_pc
= read_register (PR_REGNUM
) + 4;
231 if (fsr
->regs
[PR_REGNUM
])
233 fi
->return_pc
= read_memory_integer (fsr
->regs
[PR_REGNUM
], 4) + 4;
237 fi
->return_pc
= read_register (PR_REGNUM
) + 4;
242 /* initialize the extra info saved in a FRAME */
245 init_extra_frame_info (fromleaf
, fi
)
247 struct frame_info
*fi
;
249 struct frame_saved_regs dummy
;
250 frame_find_saved_regs (fi
, &dummy
);
254 /* Discard from the stack the innermost frame,
255 restoring all saved registers. */
260 register struct frame_info
*frame
= get_current_frame ();
261 register CORE_ADDR fp
;
263 struct frame_saved_regs fsr
;
265 fp
= FRAME_FP (frame
);
266 get_frame_saved_regs (frame
, &fsr
);
268 /* Copy regs from where they were saved in the frame */
269 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
271 if (fsr
.regs
[regnum
])
273 write_register (regnum
, read_memory_integer (fsr
.regs
[regnum
], 4));
277 write_register (PC_REGNUM
, frame
->return_pc
);
278 write_register (SP_REGNUM
, fp
+ 4);
279 flush_cached_frames ();
282 /* Print the registers in a form similar to the E7000 */
285 show_regs (args
, from_tty
)
289 printf_filtered ("PC=%08x SR=%08x PR=%08x MACH=%08x MACHL=%08x\n",
290 read_register (PC_REGNUM
),
291 read_register (SR_REGNUM
),
292 read_register (PR_REGNUM
),
293 read_register (MACH_REGNUM
),
294 read_register (MACL_REGNUM
));
296 printf_filtered ("R0-R7 %08x %08x %08x %08x %08x %08x %08x %08x\n",
305 printf_filtered ("R8-R15 %08x %08x %08x %08x %08x %08x %08x %08x\n",
318 _initialize_sh_tdep ()
320 extern int sim_memory_size
;
321 /* FIXME, there should be a way to make a CORE_ADDR variable settable. */
323 (add_set_cmd ("memory_size", class_support
, var_uinteger
,
324 (char *) &sim_memory_size
,
325 "Set simulated memory size of simulator target.", &setlist
),
328 add_com ("regs", class_vars
, show_regs
, "Print all registers");