1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
2 Copyright 1996, 1997, 1998 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. */
27 #include "gdb_string.h"
31 char *mn10300_generic_register_names
[] = REGISTER_NAMES
;
33 /* start-sanitize-am33 */
34 char *am33_register_names
[] =
35 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
36 "sp", "pc", "mdr", "psw", "lir", "lar", "",
37 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
38 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""};
39 /* end-sanitize-am33 */
42 /* Set offsets of registers saved by movm instruction.
43 This is a helper function for mn10300_analyze_prologue. */
46 set_movm_offsets (fi
, found_movm
)
47 struct frame_info
*fi
;
50 if (fi
== NULL
|| found_movm
== 0)
52 fi
->fsr
.regs
[7] = fi
->frame
;
53 fi
->fsr
.regs
[6] = fi
->frame
+ 4;
54 fi
->fsr
.regs
[3] = fi
->frame
+ 8;
55 fi
->fsr
.regs
[2] = fi
->frame
+ 12;
56 /* start-sanitize-am33 */
57 fi
->fsr
.regs
[E0_REGNUM
+5] = fi
->frame
+ 16;
58 fi
->fsr
.regs
[E0_REGNUM
+4] = fi
->frame
+ 20;
59 fi
->fsr
.regs
[E0_REGNUM
+3] = fi
->frame
+ 24;
60 fi
->fsr
.regs
[E0_REGNUM
+2] = fi
->frame
+ 28;
61 /* end-sanitize-am33 */
65 /* The main purpose of this file is dealing with prologues to extract
66 information about stack frames and saved registers.
68 For reference here's how prologues look on the mn10300:
75 Without frame pointer:
76 movm [d2,d3,a2,a3],sp (if needed)
79 One day we might keep the stack pointer constant, that won't
80 change the code for prologues, but it will make the frame
81 pointerless case much more common. */
83 /* Analyze the prologue to determine where registers are saved,
84 the end of the prologue, etc etc. Return the end of the prologue
87 We store into FI (if non-null) several tidbits of information:
89 * stack_size -- size of this stack frame. Note that if we stop in
90 certain parts of the prologue/epilogue we may claim the size of the
91 current frame is zero. This happens when the current frame has
92 not been allocated yet or has already been deallocated.
94 * fsr -- Addresses of registers saved in the stack by this frame.
96 * status -- A (relatively) generic status indicator. It's a bitmask
97 with the following bits:
99 MY_FRAME_IN_SP: The base of the current frame is actually in
100 the stack pointer. This can happen for frame pointerless
101 functions, or cases where we're stopped in the prologue/epilogue
102 itself. For these cases mn10300_analyze_prologue will need up
103 update fi->frame before returning or analyzing the register
106 MY_FRAME_IN_FP: The base of the current frame is in the
107 frame pointer register ($a2).
109 NO_MORE_FRAMES: Set this if the current frame is "start" or
110 if the first instruction looks like mov <imm>,sp. This tells
111 frame chain to not bother trying to unwind past this frame. */
113 #define MY_FRAME_IN_SP 0x1
114 #define MY_FRAME_IN_FP 0x2
115 #define NO_MORE_FRAMES 0x4
118 mn10300_analyze_prologue (fi
, pc
)
119 struct frame_info
*fi
;
122 CORE_ADDR func_addr
, func_end
, addr
, stop
;
123 CORE_ADDR stack_size
;
125 unsigned char buf
[4];
126 int status
, found_movm
= 0;
129 /* Use the PC in the frame if it's provided to look up the
130 start of this function. */
131 pc
= (fi
? fi
->pc
: pc
);
133 /* Find the start of this function. */
134 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
136 /* Do nothing if we couldn't find the start of this function or if we're
137 stopped at the first instruction in the prologue. */
141 /* If we're in start, then give up. */
142 if (strcmp (name
, "start") == 0)
144 fi
->status
= NO_MORE_FRAMES
;
148 /* At the start of a function our frame is in the stack pointer. */
150 fi
->status
= MY_FRAME_IN_SP
;
152 /* Get the next two bytes into buf, we need two because rets is a two
153 byte insn and the first isn't enough to uniquely identify it. */
154 status
= read_memory_nobpt (pc
, buf
, 2);
158 /* If we're physically on an "rets" instruction, then our frame has
159 already been deallocated. Note this can also be true for retf
160 and ret if they specify a size of zero.
162 In this case fi->frame is bogus, we need to fix it. */
163 if (fi
&& buf
[0] == 0xf0 && buf
[1] == 0xfc)
165 if (fi
->next
== NULL
)
166 fi
->frame
= read_sp ();
170 /* Similarly if we're stopped on the first insn of a prologue as our
171 frame hasn't been allocated yet. */
172 if (fi
&& fi
->pc
== func_addr
)
174 if (fi
->next
== NULL
)
175 fi
->frame
= read_sp ();
179 /* Figure out where to stop scanning. */
180 stop
= fi
? fi
->pc
: func_end
;
182 /* Don't walk off the end of the function. */
183 stop
= stop
> func_end
? func_end
: stop
;
185 /* Start scanning on the first instruction of this function. */
188 /* Suck in two bytes. */
189 status
= read_memory_nobpt (addr
, buf
, 2);
192 if (fi
&& fi
->next
== NULL
&& fi
->status
& MY_FRAME_IN_SP
)
193 fi
->frame
= read_sp ();
197 /* First see if this insn sets the stack pointer; if so, it's something
198 we won't understand, so quit now. */
199 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
202 fi
->status
= NO_MORE_FRAMES
;
206 /* Now look for movm [regs],sp, which saves the callee saved registers.
208 At this time we don't know if fi->frame is valid, so we only note
209 that we encountered a movm instruction. Later, we'll set the entries
210 in fsr.regs as needed. */
216 /* Quit now if we're beyond the stop point. */
219 /* Fix fi->frame since it's bogus at this point. */
220 if (fi
&& fi
->next
== NULL
)
221 fi
->frame
= read_sp ();
223 /* Note if/where callee saved registers were saved. */
224 set_movm_offsets (fi
, found_movm
);
228 /* Get the next two bytes so the prologue scan can continue. */
229 status
= read_memory_nobpt (addr
, buf
, 2);
232 /* Fix fi->frame since it's bogus at this point. */
233 if (fi
&& fi
->next
== NULL
)
234 fi
->frame
= read_sp ();
236 /* Note if/where callee saved registers were saved. */
237 set_movm_offsets (fi
, found_movm
);
242 /* Now see if we set up a frame pointer via "mov sp,a3" */
247 /* The frame pointer is now valid. */
250 fi
->status
|= MY_FRAME_IN_FP
;
251 fi
->status
&= ~MY_FRAME_IN_SP
;
254 /* Quit now if we're beyond the stop point. */
257 /* Note if/where callee saved registers were saved. */
258 set_movm_offsets (fi
, found_movm
);
262 /* Get two more bytes so scanning can continue. */
263 status
= read_memory_nobpt (addr
, buf
, 2);
266 /* Note if/where callee saved registers were saved. */
267 set_movm_offsets (fi
, found_movm
);
272 /* Next we should allocate the local frame. No more prologue insns
273 are found after allocating the local frame.
275 Search for add imm8,sp (0xf8feXX)
276 or add imm16,sp (0xfafeXXXX)
277 or add imm32,sp (0xfcfeXXXXXXXX).
279 If none of the above was found, then this prologue has no
282 status
= read_memory_nobpt (addr
, buf
, 2);
285 /* Fix fi->frame if it's bogus at this point. */
286 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
287 fi
->frame
= read_sp ();
289 /* Note if/where callee saved registers were saved. */
290 set_movm_offsets (fi
, found_movm
);
295 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
297 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
299 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
304 /* Suck in imm_size more bytes, they'll hold the size of the
306 status
= read_memory_nobpt (addr
+ 2, buf
, imm_size
);
309 /* Fix fi->frame if it's bogus at this point. */
310 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
311 fi
->frame
= read_sp ();
313 /* Note if/where callee saved registers were saved. */
314 set_movm_offsets (fi
, found_movm
);
318 /* Note the size of the stack in the frame info structure. */
319 stack_size
= extract_signed_integer (buf
, imm_size
);
321 fi
->stack_size
= stack_size
;
323 /* We just consumed 2 + imm_size bytes. */
324 addr
+= 2 + imm_size
;
326 /* No more prologue insns follow, so begin preparation to return. */
327 /* Fix fi->frame if it's bogus at this point. */
328 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
329 fi
->frame
= read_sp () - stack_size
;
331 /* Note if/where callee saved registers were saved. */
332 set_movm_offsets (fi
, found_movm
);
336 /* We never found an insn which allocates local stack space, regardless
337 this is the end of the prologue. */
338 /* Fix fi->frame if it's bogus at this point. */
339 if (fi
&& fi
->next
== NULL
&& (fi
->status
& MY_FRAME_IN_SP
))
340 fi
->frame
= read_sp ();
342 /* Note if/where callee saved registers were saved. */
343 set_movm_offsets (fi
, found_movm
);
347 /* Function: frame_chain
348 Figure out and return the caller's frame pointer given current
351 We don't handle dummy frames yet but we would probably just return the
352 stack pointer that was in use at the time the function call was made? */
355 mn10300_frame_chain (fi
)
356 struct frame_info
*fi
;
358 struct frame_info dummy_frame
;
360 /* Walk through the prologue to determine the stack size,
361 location of saved registers, end of the prologue, etc. */
363 mn10300_analyze_prologue (fi
, (CORE_ADDR
)0);
365 /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
366 if (fi
->status
& NO_MORE_FRAMES
)
369 /* Now that we've analyzed our prologue, determine the frame
370 pointer for our caller.
372 If our caller has a frame pointer, then we need to
373 find the entry value of $a3 to our function.
375 If fsr.regs[7] is nonzero, then it's at the memory
376 location pointed to by fsr.regs[7].
378 Else it's still in $a3.
380 If our caller does not have a frame pointer, then his
381 frame base is fi->frame + -caller's stack size. */
383 /* The easiest way to get that info is to analyze our caller's frame.
385 So we set up a dummy frame and call mn10300_analyze_prologue to
386 find stuff for us. */
387 dummy_frame
.pc
= FRAME_SAVED_PC (fi
);
388 dummy_frame
.frame
= fi
->frame
;
389 memset (dummy_frame
.fsr
.regs
, '\000', sizeof dummy_frame
.fsr
.regs
);
390 dummy_frame
.status
= 0;
391 dummy_frame
.stack_size
= 0;
392 mn10300_analyze_prologue (&dummy_frame
);
394 if (dummy_frame
.status
& MY_FRAME_IN_FP
)
396 /* Our caller has a frame pointer. So find the frame in $a3 or
399 return (read_memory_integer (fi
->fsr
.regs
[FP_REGNUM
], REGISTER_SIZE
));
401 return read_register (FP_REGNUM
);
407 adjust
+= (fi
->fsr
.regs
[2] ? 4 : 0);
408 adjust
+= (fi
->fsr
.regs
[3] ? 4 : 0);
409 adjust
+= (fi
->fsr
.regs
[6] ? 4 : 0);
410 adjust
+= (fi
->fsr
.regs
[7] ? 4 : 0);
411 /* start-sanitize-am33 */
412 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+5] ? 4 : 0);
413 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+4] ? 4 : 0);
414 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+3] ? 4 : 0);
415 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+2] ? 4 : 0);
416 /* end-sanitize-am33 */
418 /* Our caller does not have a frame pointer. So his frame starts
419 at the base of our frame (fi->frame) + register save space
421 return fi
->frame
+ adjust
+ -dummy_frame
.stack_size
;
425 /* Function: skip_prologue
426 Return the address of the first inst past the prologue of the function. */
429 mn10300_skip_prologue (pc
)
432 /* We used to check the debug symbols, but that can lose if
433 we have a null prologue. */
434 return mn10300_analyze_prologue (NULL
, pc
);
438 /* Function: pop_frame
439 This routine gets called when either the user uses the `return'
440 command, or the call dummy breakpoint gets hit. */
443 mn10300_pop_frame (frame
)
444 struct frame_info
*frame
;
448 if (PC_IN_CALL_DUMMY(frame
->pc
, frame
->frame
, frame
->frame
))
449 generic_pop_dummy_frame ();
452 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
454 /* Restore any saved registers. */
455 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
456 if (frame
->fsr
.regs
[regnum
] != 0)
460 value
= read_memory_unsigned_integer (frame
->fsr
.regs
[regnum
],
461 REGISTER_RAW_SIZE (regnum
));
462 write_register (regnum
, value
);
465 /* Actually cut back the stack. */
466 write_register (SP_REGNUM
, FRAME_FP (frame
));
468 /* Don't we need to set the PC?!? XXX FIXME. */
471 /* Throw away any cached frame information. */
472 flush_cached_frames ();
475 /* Function: push_arguments
476 Setup arguments for a call to the target. Arguments go in
477 order on the stack. */
480 mn10300_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
484 unsigned char struct_return
;
485 CORE_ADDR struct_addr
;
489 int stack_offset
= 0;
490 int regsused
= struct_return
? 1 : 0;
492 /* This should be a nop, but align the stack just in case something
493 went wrong. Stacks are four byte aligned on the mn10300. */
496 /* Now make space on the stack for the args.
498 XXX This doesn't appear to handle pass-by-invisible reference
500 for (argnum
= 0; argnum
< nargs
; argnum
++)
502 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3;
504 while (regsused
< 2 && arg_length
> 0)
512 /* Allocate stack space. */
515 regsused
= struct_return
? 1 : 0;
516 /* Push all arguments onto the stack. */
517 for (argnum
= 0; argnum
< nargs
; argnum
++)
522 /* XXX Check this. What about UNIONS? */
523 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
524 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
526 /* XXX Wrong, we want a pointer to this argument. */
527 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
528 val
= (char *)VALUE_CONTENTS (*args
);
532 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
533 val
= (char *)VALUE_CONTENTS (*args
);
536 while (regsused
< 2 && len
> 0)
538 write_register (regsused
, extract_unsigned_integer (val
, 4));
546 write_memory (sp
+ stack_offset
, val
, 4);
555 /* Make space for the flushback area. */
560 /* Function: push_return_address (pc)
561 Set up the return address for the inferior function call.
562 Needed for targets where we don't actually execute a JSR/BSR instruction */
565 mn10300_push_return_address (pc
, sp
)
569 unsigned char buf
[4];
571 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
572 write_memory (sp
- 4, buf
, 4);
576 /* Function: store_struct_return (addr,sp)
577 Store the structure value return address for an inferior function
581 mn10300_store_struct_return (addr
, sp
)
585 /* The structure return address is passed as the first argument. */
586 write_register (0, addr
);
590 /* Function: frame_saved_pc
591 Find the caller of this frame. We do this by seeing if RP_REGNUM
592 is saved in the stack anywhere, otherwise we get it from the
593 registers. If the inner frame is a dummy frame, return its PC
594 instead of RP, because that's where "caller" of the dummy-frame
598 mn10300_frame_saved_pc (fi
)
599 struct frame_info
*fi
;
603 adjust
+= (fi
->fsr
.regs
[2] ? 4 : 0);
604 adjust
+= (fi
->fsr
.regs
[3] ? 4 : 0);
605 adjust
+= (fi
->fsr
.regs
[6] ? 4 : 0);
606 adjust
+= (fi
->fsr
.regs
[7] ? 4 : 0);
607 /* start-sanitize-am33 */
608 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+5] ? 4 : 0);
609 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+4] ? 4 : 0);
610 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+3] ? 4 : 0);
611 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+2] ? 4 : 0);
612 /* end-sanitize-am33 */
614 return (read_memory_integer (fi
->frame
+ adjust
, REGISTER_SIZE
));
618 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
622 struct frame_info
*frame
;
624 enum lval_type
*lval
;
626 generic_get_saved_register (raw_buffer
, optimized
, addrp
,
627 frame
, regnum
, lval
);
630 /* Function: init_extra_frame_info
631 Setup the frame's frame pointer, pc, and frame addresses for saved
632 registers. Most of the work is done in mn10300_analyze_prologue().
634 Note that when we are called for the last frame (currently active frame),
635 that fi->pc and fi->frame will already be setup. However, fi->frame will
636 be valid only if this routine uses FP. For previous frames, fi-frame will
637 always be correct. mn10300_analyze_prologue will fix fi->frame if
640 We can be called with the PC in the call dummy under two circumstances.
641 First, during normal backtracing, second, while figuring out the frame
642 pointer just prior to calling the target function (see run_stack_dummy). */
645 mn10300_init_extra_frame_info (fi
)
646 struct frame_info
*fi
;
649 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
651 memset (fi
->fsr
.regs
, '\000', sizeof fi
->fsr
.regs
);
655 mn10300_analyze_prologue (fi
, 0);
658 /* This can be made more generic later. */
660 set_machine_hook (filename
)
665 if (bfd_get_mach (exec_bfd
) == bfd_mach_mn10300
666 || bfd_get_mach (exec_bfd
) == 0)
668 for (i
= 0; i
< NUM_REGS
; i
++)
669 reg_names
[i
] = mn10300_generic_register_names
[i
];
672 /* start-sanitize-am33 */
673 if (bfd_get_mach (exec_bfd
) == bfd_mach_am33
)
675 for (i
= 0; i
< NUM_REGS
; i
++)
676 reg_names
[i
] = am33_register_names
[i
];
678 /* end-sanitize-am33 */
682 _initialize_mn10300_tdep ()
684 /* printf("_initialize_mn10300_tdep\n"); */
686 tm_print_insn
= print_insn_mn10300
;
688 specify_exec_file_hook (set_machine_hook
);