Commit | Line | Data |
---|---|---|
1f46923f SC |
1 | /* Target-machine dependent code for Hitachi H8/300, for GDB. |
2 | Copyright (C) 1988, 1990, 1991 Free Software Foundation, Inc. | |
3 | ||
4 | This file is part of GDB. | |
5 | ||
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. | |
10 | ||
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. | |
15 | ||
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. */ | |
19 | ||
ec25d19b | 20 | /* |
1f46923f | 21 | Contributed by Steve Chamberlain |
ec25d19b | 22 | sac@cygnus.com |
1f46923f SC |
23 | */ |
24 | ||
400943fb | 25 | #include "defs.h" |
1f46923f SC |
26 | #include "frame.h" |
27 | #include "obstack.h" | |
28 | #include "symtab.h" | |
df14b38b | 29 | #include <dis-asm.h> |
256b4f37 SC |
30 | #undef NUM_REGS |
31 | #define NUM_REGS 11 | |
32 | ||
1f46923f | 33 | #define UNSIGNED_SHORT(X) ((X) & 0xffff) |
400943fb SC |
34 | |
35 | /* an easy to debug H8 stack frame looks like: | |
ec25d19b SC |
36 | 0x6df6 push r6 |
37 | 0x0d76 mov.w r7,r6 | |
38 | 0x6dfn push reg | |
39 | 0x7905 nnnn mov.w #n,r5 or 0x1b87 subs #2,sp | |
40 | 0x1957 sub.w r5,sp | |
400943fb SC |
41 | |
42 | */ | |
1f46923f | 43 | |
400943fb | 44 | #define IS_PUSH(x) ((x & 0xff00)==0x6d00) |
ec25d19b | 45 | #define IS_PUSH_FP(x) (x == 0x6df6) |
1f46923f SC |
46 | #define IS_MOVE_FP(x) (x == 0x0d76) |
47 | #define IS_MOV_SP_FP(x) (x == 0x0d76) | |
48 | #define IS_SUB2_SP(x) (x==0x1b87) | |
49 | #define IS_MOVK_R5(x) (x==0x7905) | |
ec25d19b SC |
50 | #define IS_SUB_R5SP(x) (x==0x1957) |
51 | CORE_ADDR examine_prologue (); | |
1f46923f | 52 | |
ec25d19b SC |
53 | void frame_find_saved_regs (); |
54 | CORE_ADDR | |
55 | h8300_skip_prologue (start_pc) | |
56 | CORE_ADDR start_pc; | |
0a8f9d31 | 57 | |
0a8f9d31 | 58 | { |
ec25d19b | 59 | short int w; |
1f46923f | 60 | |
df14b38b | 61 | w = read_memory_unsigned_integer (start_pc, 2); |
400943fb | 62 | /* Skip past all push insns */ |
ec25d19b SC |
63 | while (IS_PUSH_FP (w)) |
64 | { | |
65 | start_pc += 2; | |
df14b38b | 66 | w = read_memory_unsigned_integer (start_pc, 2); |
ec25d19b | 67 | } |
0a8f9d31 | 68 | |
1f46923f | 69 | /* Skip past a move to FP */ |
ec25d19b SC |
70 | if (IS_MOVE_FP (w)) |
71 | { | |
72 | start_pc += 2; | |
df14b38b | 73 | w = read_memory_unsigned_integer (start_pc, 2); |
1f46923f SC |
74 | } |
75 | ||
ec25d19b | 76 | /* Skip the stack adjust */ |
0a8f9d31 | 77 | |
ec25d19b SC |
78 | if (IS_MOVK_R5 (w)) |
79 | { | |
80 | start_pc += 2; | |
df14b38b | 81 | w = read_memory_unsigned_integer (start_pc, 2); |
ec25d19b SC |
82 | } |
83 | if (IS_SUB_R5SP (w)) | |
84 | { | |
85 | start_pc += 2; | |
df14b38b | 86 | w = read_memory_unsigned_integer (start_pc, 2); |
ec25d19b SC |
87 | } |
88 | while (IS_SUB2_SP (w)) | |
89 | { | |
90 | start_pc += 2; | |
df14b38b | 91 | w = read_memory_unsigned_integer (start_pc, 2); |
ec25d19b SC |
92 | } |
93 | ||
94 | return start_pc; | |
95 | ||
96 | } | |
1f46923f | 97 | |
400943fb | 98 | int |
ec25d19b SC |
99 | print_insn (memaddr, stream) |
100 | CORE_ADDR memaddr; | |
101 | FILE *stream; | |
0a8f9d31 | 102 | { |
df14b38b SC |
103 | disassemble_info info; |
104 | GDB_INIT_DISASSEMBLE_INFO(info, stream); | |
105 | return print_insn_h8300 (memaddr, &info); | |
0a8f9d31 | 106 | } |
ec25d19b | 107 | |
1f46923f SC |
108 | /* Given a GDB frame, determine the address of the calling function's frame. |
109 | This will be used to create a new GDB frame struct, and then | |
110 | INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame. | |
111 | ||
112 | For us, the frame address is its stack pointer value, so we look up | |
113 | the function prologue to determine the caller's sp value, and return it. */ | |
114 | ||
115 | FRAME_ADDR | |
116 | FRAME_CHAIN (thisframe) | |
117 | FRAME thisframe; | |
118 | { | |
119 | ||
120 | frame_find_saved_regs (thisframe, (struct frame_saved_regs *) 0); | |
ec25d19b | 121 | return thisframe->fsr->regs[SP_REGNUM]; |
1f46923f SC |
122 | } |
123 | ||
1f46923f SC |
124 | /* Put here the code to store, into a struct frame_saved_regs, |
125 | the addresses of the saved registers of frame described by FRAME_INFO. | |
126 | This includes special registers such as pc and fp saved in special | |
127 | ways in the stack frame. sp is even more special: | |
128 | the address we return for it IS the sp for the next frame. | |
129 | ||
130 | We cache the result of doing this in the frame_cache_obstack, since | |
131 | it is fairly expensive. */ | |
132 | ||
133 | void | |
134 | frame_find_saved_regs (fi, fsr) | |
135 | struct frame_info *fi; | |
136 | struct frame_saved_regs *fsr; | |
137 | { | |
138 | register CORE_ADDR next_addr; | |
139 | register CORE_ADDR *saved_regs; | |
140 | register int regnum; | |
141 | register struct frame_saved_regs *cache_fsr; | |
142 | extern struct obstack frame_cache_obstack; | |
143 | CORE_ADDR ip; | |
144 | struct symtab_and_line sal; | |
145 | CORE_ADDR limit; | |
146 | ||
147 | if (!fi->fsr) | |
148 | { | |
149 | cache_fsr = (struct frame_saved_regs *) | |
ec25d19b SC |
150 | obstack_alloc (&frame_cache_obstack, |
151 | sizeof (struct frame_saved_regs)); | |
1f46923f | 152 | bzero (cache_fsr, sizeof (struct frame_saved_regs)); |
ec25d19b | 153 | |
1f46923f SC |
154 | fi->fsr = cache_fsr; |
155 | ||
156 | /* Find the start and end of the function prologue. If the PC | |
157 | is in the function prologue, we only consider the part that | |
158 | has executed already. */ | |
ec25d19b | 159 | |
1f46923f SC |
160 | ip = get_pc_function_start (fi->pc); |
161 | sal = find_pc_line (ip, 0); | |
ec25d19b | 162 | limit = (sal.end && sal.end < fi->pc) ? sal.end : fi->pc; |
1f46923f SC |
163 | |
164 | /* This will fill in fields in *fi as well as in cache_fsr. */ | |
165 | examine_prologue (ip, limit, fi->frame, cache_fsr, fi); | |
166 | } | |
167 | ||
168 | if (fsr) | |
169 | *fsr = *fi->fsr; | |
170 | } | |
1f46923f SC |
171 | |
172 | /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or | |
173 | is not the address of a valid instruction, the address of the next | |
174 | instruction beyond ADDR otherwise. *PWORD1 receives the first word | |
175 | of the instruction.*/ | |
176 | ||
1f46923f | 177 | CORE_ADDR |
ec25d19b SC |
178 | NEXT_PROLOGUE_INSN (addr, lim, pword1) |
179 | CORE_ADDR addr; | |
180 | CORE_ADDR lim; | |
181 | short *pword1; | |
1f46923f | 182 | { |
ec25d19b SC |
183 | if (addr < lim + 8) |
184 | { | |
185 | read_memory (addr, pword1, sizeof (*pword1)); | |
186 | SWAP_TARGET_AND_HOST (pword1, sizeof (short)); | |
1f46923f | 187 | |
ec25d19b SC |
188 | return addr + 2; |
189 | } | |
1f46923f | 190 | return 0; |
1f46923f SC |
191 | } |
192 | ||
193 | /* Examine the prologue of a function. `ip' points to the first instruction. | |
ec25d19b | 194 | `limit' is the limit of the prologue (e.g. the addr of the first |
1f46923f | 195 | linenumber, or perhaps the program counter if we're stepping through). |
ec25d19b | 196 | `frame_sp' is the stack pointer value in use in this frame. |
1f46923f | 197 | `fsr' is a pointer to a frame_saved_regs structure into which we put |
ec25d19b | 198 | info about the registers saved by this frame. |
1f46923f SC |
199 | `fi' is a struct frame_info pointer; we fill in various fields in it |
200 | to reflect the offsets of the arg pointer and the locals pointer. */ | |
201 | ||
1f46923f SC |
202 | static CORE_ADDR |
203 | examine_prologue (ip, limit, after_prolog_fp, fsr, fi) | |
204 | register CORE_ADDR ip; | |
205 | register CORE_ADDR limit; | |
206 | FRAME_ADDR after_prolog_fp; | |
207 | struct frame_saved_regs *fsr; | |
208 | struct frame_info *fi; | |
209 | { | |
210 | register CORE_ADDR next_ip; | |
211 | int r; | |
212 | int i; | |
213 | int have_fp = 0; | |
ec25d19b | 214 | |
1f46923f SC |
215 | register int src; |
216 | register struct pic_prologue_code *pcode; | |
217 | INSN_WORD insn_word; | |
218 | int size, offset; | |
ddf30c37 | 219 | unsigned int reg_save_depth = 2; /* Number of things pushed onto |
1f46923f SC |
220 | stack, starts at 2, 'cause the |
221 | PC is already there */ | |
222 | ||
223 | unsigned int auto_depth = 0; /* Number of bytes of autos */ | |
1f46923f | 224 | |
ddf30c37 | 225 | char in_frame[11]; /* One for each reg */ |
1f46923f | 226 | |
ddf30c37 | 227 | memset (in_frame, 1, 11); |
256b4f37 | 228 | for (r = 0; r < 8; r++) |
ec25d19b SC |
229 | { |
230 | fsr->regs[r] = 0; | |
231 | } | |
232 | if (after_prolog_fp == 0) | |
233 | { | |
234 | after_prolog_fp = read_register (SP_REGNUM); | |
235 | } | |
236 | if (ip == 0 || ip & ~0xffff) | |
237 | return 0; | |
1f46923f | 238 | |
ec25d19b | 239 | next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word); |
1f46923f | 240 | |
ec25d19b SC |
241 | /* Skip over any fp push instructions */ |
242 | fsr->regs[6] = after_prolog_fp; | |
243 | while (next_ip && IS_PUSH_FP (insn_word)) | |
244 | { | |
245 | ip = next_ip; | |
1f46923f | 246 | |
ec25d19b SC |
247 | in_frame[insn_word & 0x7] = reg_save_depth; |
248 | next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word); | |
249 | reg_save_depth += 2; | |
250 | } | |
1f46923f SC |
251 | |
252 | /* Is this a move into the fp */ | |
ec25d19b SC |
253 | if (next_ip && IS_MOV_SP_FP (insn_word)) |
254 | { | |
255 | ip = next_ip; | |
256 | next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word); | |
257 | have_fp = 1; | |
258 | } | |
1f46923f SC |
259 | |
260 | /* Skip over any stack adjustment, happens either with a number of | |
261 | sub#2,sp or a mov #x,r5 sub r5,sp */ | |
262 | ||
ec25d19b | 263 | if (next_ip && IS_SUB2_SP (insn_word)) |
1f46923f | 264 | { |
ec25d19b SC |
265 | while (next_ip && IS_SUB2_SP (insn_word)) |
266 | { | |
267 | auto_depth += 2; | |
268 | ip = next_ip; | |
269 | next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word); | |
270 | } | |
1f46923f | 271 | } |
ec25d19b SC |
272 | else |
273 | { | |
274 | if (next_ip && IS_MOVK_R5 (insn_word)) | |
275 | { | |
276 | ip = next_ip; | |
277 | next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word); | |
278 | auto_depth += insn_word; | |
279 | ||
280 | next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn_word); | |
281 | auto_depth += insn_word; | |
282 | ||
283 | } | |
284 | } | |
285 | /* Work out which regs are stored where */ | |
286 | while (next_ip && IS_PUSH (insn_word)) | |
1f46923f SC |
287 | { |
288 | ip = next_ip; | |
ec25d19b SC |
289 | next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn_word); |
290 | fsr->regs[r] = after_prolog_fp + auto_depth; | |
291 | auto_depth += 2; | |
1f46923f | 292 | } |
1f46923f | 293 | |
1f46923f | 294 | /* The args are always reffed based from the stack pointer */ |
ec25d19b | 295 | fi->args_pointer = after_prolog_fp; |
1f46923f | 296 | /* Locals are always reffed based from the fp */ |
ec25d19b | 297 | fi->locals_pointer = after_prolog_fp; |
1f46923f | 298 | /* The PC is at a known place */ |
df14b38b | 299 | fi->from_pc = read_memory_unsigned_integer (after_prolog_fp + 2, BINWORD); |
1f46923f SC |
300 | |
301 | /* Rememeber any others too */ | |
1f46923f | 302 | in_frame[PC_REGNUM] = 0; |
ec25d19b SC |
303 | |
304 | if (have_fp) | |
305 | /* We keep the old FP in the SP spot */ | |
df14b38b SC |
306 | fsr->regs[SP_REGNUM] = (read_memory_unsigned_integer |
307 | (fsr->regs[6]), BINWORD); | |
ec25d19b SC |
308 | else |
309 | fsr->regs[SP_REGNUM] = after_prolog_fp + auto_depth; | |
310 | ||
1f46923f SC |
311 | return (ip); |
312 | } | |
313 | ||
314 | void | |
315 | init_extra_frame_info (fromleaf, fi) | |
316 | int fromleaf; | |
317 | struct frame_info *fi; | |
318 | { | |
319 | fi->fsr = 0; /* Not yet allocated */ | |
320 | fi->args_pointer = 0; /* Unknown */ | |
321 | fi->locals_pointer = 0; /* Unknown */ | |
322 | fi->from_pc = 0; | |
ec25d19b | 323 | |
1f46923f | 324 | } |
ec25d19b | 325 | |
1f46923f SC |
326 | /* Return the saved PC from this frame. |
327 | ||
328 | If the frame has a memory copy of SRP_REGNUM, use that. If not, | |
329 | just use the register SRP_REGNUM itself. */ | |
330 | ||
331 | CORE_ADDR | |
332 | frame_saved_pc (frame) | |
ec25d19b | 333 | FRAME frame; |
1f46923f SC |
334 | |
335 | { | |
336 | return frame->from_pc; | |
337 | } | |
338 | ||
1f46923f SC |
339 | CORE_ADDR |
340 | frame_locals_address (fi) | |
341 | struct frame_info *fi; | |
342 | { | |
ec25d19b SC |
343 | if (!fi->locals_pointer) |
344 | { | |
345 | struct frame_saved_regs ignore; | |
346 | ||
347 | get_frame_saved_regs (fi, &ignore); | |
1f46923f | 348 | |
ec25d19b | 349 | } |
1f46923f SC |
350 | return fi->locals_pointer; |
351 | } | |
352 | ||
353 | /* Return the address of the argument block for the frame | |
354 | described by FI. Returns 0 if the address is unknown. */ | |
355 | ||
356 | CORE_ADDR | |
357 | frame_args_address (fi) | |
358 | struct frame_info *fi; | |
359 | { | |
ec25d19b SC |
360 | if (!fi->args_pointer) |
361 | { | |
362 | struct frame_saved_regs ignore; | |
363 | ||
364 | get_frame_saved_regs (fi, &ignore); | |
365 | ||
366 | } | |
1f46923f | 367 | |
1f46923f SC |
368 | return fi->args_pointer; |
369 | } | |
370 | ||
ec25d19b SC |
371 | void |
372 | h8300_pop_frame () | |
1f46923f SC |
373 | { |
374 | unsigned regnum; | |
375 | struct frame_saved_regs fsr; | |
376 | struct frame_info *fi; | |
377 | ||
ec25d19b | 378 | FRAME frame = get_current_frame (); |
1f46923f | 379 | |
ec25d19b SC |
380 | fi = get_frame_info (frame); |
381 | get_frame_saved_regs (fi, &fsr); | |
382 | ||
256b4f37 | 383 | for (regnum = 0; regnum < 8; regnum++) |
1f46923f | 384 | { |
ec25d19b SC |
385 | if (fsr.regs[regnum]) |
386 | { | |
df14b38b | 387 | write_register (regnum, read_memory_integer(fsr.regs[regnum]), BINWORD); |
ec25d19b SC |
388 | } |
389 | ||
390 | flush_cached_frames (); | |
391 | set_current_frame (create_new_frame (read_register (FP_REGNUM), | |
392 | read_pc ())); | |
393 | ||
1f46923f | 394 | } |
1f46923f SC |
395 | |
396 | } | |
ec25d19b SC |
397 | |
398 | void | |
399 | print_register_hook (regno) | |
400 | { | |
401 | if (regno == 8) | |
402 | { | |
403 | /* CCR register */ | |
404 | ||
405 | int C, Z, N, V; | |
406 | unsigned char b[2]; | |
407 | unsigned char l; | |
408 | ||
409 | read_relative_register_raw_bytes (regno, b); | |
410 | l = b[1]; | |
411 | printf ("\t"); | |
412 | printf ("I-%d - ", (l & 0x80) != 0); | |
413 | printf ("H-%d - ", (l & 0x20) != 0); | |
414 | N = (l & 0x8) != 0; | |
415 | Z = (l & 0x4) != 0; | |
416 | V = (l & 0x2) != 0; | |
417 | C = (l & 0x1) != 0; | |
418 | printf ("N-%d ", N); | |
419 | printf ("Z-%d ", Z); | |
420 | printf ("V-%d ", V); | |
421 | printf ("C-%d ", C); | |
422 | if ((C | Z) == 0) | |
423 | printf ("u> "); | |
424 | if ((C | Z) == 1) | |
425 | printf ("u<= "); | |
426 | if ((C == 0)) | |
427 | printf ("u>= "); | |
428 | if (C == 1) | |
429 | printf ("u< "); | |
430 | if (Z == 0) | |
431 | printf ("!= "); | |
432 | if (Z == 1) | |
433 | printf ("== "); | |
434 | if ((N ^ V) == 0) | |
435 | printf (">= "); | |
436 | if ((N ^ V) == 1) | |
437 | printf ("< "); | |
438 | if ((Z | (N ^ V)) == 0) | |
439 | printf ("> "); | |
440 | if ((Z | (N ^ V)) == 1) | |
441 | printf ("<= "); | |
442 | } | |
443 | } |