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", "", "", ""};
40 /* end-sanitize-am33 */
42 static CORE_ADDR mn10300_analyze_prologue
PARAMS ((struct frame_info
*fi
,
45 /* Values for frame_info.status */
47 #define MY_FRAME_IN_SP 0x1
48 #define MY_FRAME_IN_FP 0x2
49 #define NO_MORE_FRAMES 0x4
52 /* Fix fi->frame if it's bogus at this point. This is a helper
53 function for mn10300_analyze_prologue. */
56 fix_frame_pointer (fi
, stack_size
)
57 struct frame_info
*fi
;
60 if (fi
&& fi
->next
== NULL
)
62 if (fi
->status
& MY_FRAME_IN_SP
)
63 fi
->frame
= read_sp () - stack_size
;
64 else if (fi
->status
& MY_FRAME_IN_FP
)
65 fi
->frame
= read_register (A3_REGNUM
);
70 /* Set offsets of registers saved by movm instruction.
71 This is a helper function for mn10300_analyze_prologue. */
74 set_movm_offsets (fi
, movm_args
)
75 struct frame_info
*fi
;
80 if (fi
== NULL
|| movm_args
== 0)
85 fi
->fsr
.regs
[A3_REGNUM
] = fi
->frame
+ offset
;
90 fi
->fsr
.regs
[A2_REGNUM
] = fi
->frame
+ offset
;
95 fi
->fsr
.regs
[D3_REGNUM
] = fi
->frame
+ offset
;
100 fi
->fsr
.regs
[D2_REGNUM
] = fi
->frame
+ offset
;
103 /* start-sanitize-am33 */
104 if (am33_mode
&& movm_args
& 0x02)
106 fi
->fsr
.regs
[E0_REGNUM
+5] = fi
->frame
+ offset
;
107 fi
->fsr
.regs
[E0_REGNUM
+4] = fi
->frame
+ offset
+ 4;
108 fi
->fsr
.regs
[E0_REGNUM
+3] = fi
->frame
+ offset
+ 8;
109 fi
->fsr
.regs
[E0_REGNUM
+2] = fi
->frame
+ offset
+ 12;
111 /* end-sanitize-am33 */
115 /* The main purpose of this file is dealing with prologues to extract
116 information about stack frames and saved registers.
118 For reference here's how prologues look on the mn10300:
121 movm [d2,d3,a2,a3],sp
125 Without frame pointer:
126 movm [d2,d3,a2,a3],sp (if needed)
129 One day we might keep the stack pointer constant, that won't
130 change the code for prologues, but it will make the frame
131 pointerless case much more common. */
133 /* Analyze the prologue to determine where registers are saved,
134 the end of the prologue, etc etc. Return the end of the prologue
137 We store into FI (if non-null) several tidbits of information:
139 * stack_size -- size of this stack frame. Note that if we stop in
140 certain parts of the prologue/epilogue we may claim the size of the
141 current frame is zero. This happens when the current frame has
142 not been allocated yet or has already been deallocated.
144 * fsr -- Addresses of registers saved in the stack by this frame.
146 * status -- A (relatively) generic status indicator. It's a bitmask
147 with the following bits:
149 MY_FRAME_IN_SP: The base of the current frame is actually in
150 the stack pointer. This can happen for frame pointerless
151 functions, or cases where we're stopped in the prologue/epilogue
152 itself. For these cases mn10300_analyze_prologue will need up
153 update fi->frame before returning or analyzing the register
156 MY_FRAME_IN_FP: The base of the current frame is in the
157 frame pointer register ($a2).
159 NO_MORE_FRAMES: Set this if the current frame is "start" or
160 if the first instruction looks like mov <imm>,sp. This tells
161 frame chain to not bother trying to unwind past this frame. */
164 mn10300_analyze_prologue (fi
, pc
)
165 struct frame_info
*fi
;
168 CORE_ADDR func_addr
, func_end
, addr
, stop
;
169 CORE_ADDR stack_size
;
171 unsigned char buf
[4];
172 int status
, movm_args
= 0;
175 /* Use the PC in the frame if it's provided to look up the
176 start of this function. */
177 pc
= (fi
? fi
->pc
: pc
);
179 /* Find the start of this function. */
180 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
182 /* Do nothing if we couldn't find the start of this function or if we're
183 stopped at the first instruction in the prologue. */
187 /* If we're in start, then give up. */
188 if (strcmp (name
, "start") == 0)
190 fi
->status
= NO_MORE_FRAMES
;
194 /* At the start of a function our frame is in the stack pointer. */
196 fi
->status
= MY_FRAME_IN_SP
;
198 /* Get the next two bytes into buf, we need two because rets is a two
199 byte insn and the first isn't enough to uniquely identify it. */
200 status
= read_memory_nobpt (pc
, buf
, 2);
204 /* If we're physically on an "rets" instruction, then our frame has
205 already been deallocated. Note this can also be true for retf
206 and ret if they specify a size of zero.
208 In this case fi->frame is bogus, we need to fix it. */
209 if (fi
&& buf
[0] == 0xf0 && buf
[1] == 0xfc)
211 if (fi
->next
== NULL
)
212 fi
->frame
= read_sp ();
216 /* Similarly if we're stopped on the first insn of a prologue as our
217 frame hasn't been allocated yet. */
218 if (fi
&& fi
->pc
== func_addr
)
220 if (fi
->next
== NULL
)
221 fi
->frame
= read_sp ();
225 /* Figure out where to stop scanning. */
226 stop
= fi
? fi
->pc
: func_end
;
228 /* Don't walk off the end of the function. */
229 stop
= stop
> func_end
? func_end
: stop
;
231 /* Start scanning on the first instruction of this function. */
234 /* Suck in two bytes. */
235 status
= read_memory_nobpt (addr
, buf
, 2);
238 fix_frame_pointer (fi
, 0);
242 /* First see if this insn sets the stack pointer; if so, it's something
243 we won't understand, so quit now. */
244 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
247 fi
->status
= NO_MORE_FRAMES
;
251 /* Now look for movm [regs],sp, which saves the callee saved registers.
253 At this time we don't know if fi->frame is valid, so we only note
254 that we encountered a movm instruction. Later, we'll set the entries
255 in fsr.regs as needed. */
258 /* Extract the register list for the movm instruction. */
259 status
= read_memory_nobpt (addr
+ 1, buf
, 1);
264 /* Quit now if we're beyond the stop point. */
267 /* Fix fi->frame since it's bogus at this point. */
268 if (fi
&& fi
->next
== NULL
)
269 fi
->frame
= read_sp ();
271 /* Note if/where callee saved registers were saved. */
272 set_movm_offsets (fi
, movm_args
);
276 /* Get the next two bytes so the prologue scan can continue. */
277 status
= read_memory_nobpt (addr
, buf
, 2);
280 /* Fix fi->frame since it's bogus at this point. */
281 if (fi
&& fi
->next
== NULL
)
282 fi
->frame
= read_sp ();
284 /* Note if/where callee saved registers were saved. */
285 set_movm_offsets (fi
, movm_args
);
290 /* Now see if we set up a frame pointer via "mov sp,a3" */
295 /* The frame pointer is now valid. */
298 fi
->status
|= MY_FRAME_IN_FP
;
299 fi
->status
&= ~MY_FRAME_IN_SP
;
302 /* Quit now if we're beyond the stop point. */
305 /* Fix fi->frame if it's bogus at this point. */
306 fix_frame_pointer (fi
, 0);
308 /* Note if/where callee saved registers were saved. */
309 set_movm_offsets (fi
, movm_args
);
313 /* Get two more bytes so scanning can continue. */
314 status
= read_memory_nobpt (addr
, buf
, 2);
317 /* Fix fi->frame if it's bogus at this point. */
318 fix_frame_pointer (fi
, 0);
320 /* Note if/where callee saved registers were saved. */
321 set_movm_offsets (fi
, movm_args
);
326 /* Next we should allocate the local frame. No more prologue insns
327 are found after allocating the local frame.
329 Search for add imm8,sp (0xf8feXX)
330 or add imm16,sp (0xfafeXXXX)
331 or add imm32,sp (0xfcfeXXXXXXXX).
333 If none of the above was found, then this prologue has no
336 status
= read_memory_nobpt (addr
, buf
, 2);
339 /* Fix fi->frame if it's bogus at this point. */
340 fix_frame_pointer (fi
, 0);
342 /* Note if/where callee saved registers were saved. */
343 set_movm_offsets (fi
, movm_args
);
348 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
350 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
352 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
357 /* Suck in imm_size more bytes, they'll hold the size of the
359 status
= read_memory_nobpt (addr
+ 2, buf
, imm_size
);
362 /* Fix fi->frame if it's bogus at this point. */
363 fix_frame_pointer (fi
, 0);
365 /* Note if/where callee saved registers were saved. */
366 set_movm_offsets (fi
, movm_args
);
370 /* Note the size of the stack in the frame info structure. */
371 stack_size
= extract_signed_integer (buf
, imm_size
);
373 fi
->stack_size
= stack_size
;
375 /* We just consumed 2 + imm_size bytes. */
376 addr
+= 2 + imm_size
;
378 /* No more prologue insns follow, so begin preparation to return. */
379 /* Fix fi->frame if it's bogus at this point. */
380 fix_frame_pointer (fi
, stack_size
);
382 /* Note if/where callee saved registers were saved. */
383 set_movm_offsets (fi
, movm_args
);
387 /* We never found an insn which allocates local stack space, regardless
388 this is the end of the prologue. */
389 /* Fix fi->frame if it's bogus at this point. */
390 fix_frame_pointer (fi
, 0);
392 /* Note if/where callee saved registers were saved. */
393 set_movm_offsets (fi
, movm_args
);
397 /* Function: frame_chain
398 Figure out and return the caller's frame pointer given current
401 We don't handle dummy frames yet but we would probably just return the
402 stack pointer that was in use at the time the function call was made? */
405 mn10300_frame_chain (fi
)
406 struct frame_info
*fi
;
408 struct frame_info dummy_frame
;
410 /* Walk through the prologue to determine the stack size,
411 location of saved registers, end of the prologue, etc. */
413 mn10300_analyze_prologue (fi
, (CORE_ADDR
)0);
415 /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
416 if (fi
->status
& NO_MORE_FRAMES
)
419 /* Now that we've analyzed our prologue, determine the frame
420 pointer for our caller.
422 If our caller has a frame pointer, then we need to
423 find the entry value of $a3 to our function.
425 If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
426 location pointed to by fsr.regs[A3_REGNUM].
428 Else it's still in $a3.
430 If our caller does not have a frame pointer, then his
431 frame base is fi->frame + -caller's stack size. */
433 /* The easiest way to get that info is to analyze our caller's frame.
435 So we set up a dummy frame and call mn10300_analyze_prologue to
436 find stuff for us. */
437 dummy_frame
.pc
= FRAME_SAVED_PC (fi
);
438 dummy_frame
.frame
= fi
->frame
;
439 memset (dummy_frame
.fsr
.regs
, '\000', sizeof dummy_frame
.fsr
.regs
);
440 dummy_frame
.status
= 0;
441 dummy_frame
.stack_size
= 0;
442 mn10300_analyze_prologue (&dummy_frame
, 0);
444 if (dummy_frame
.status
& MY_FRAME_IN_FP
)
446 /* Our caller has a frame pointer. So find the frame in $a3 or
448 if (fi
->fsr
.regs
[A3_REGNUM
])
449 return (read_memory_integer (fi
->fsr
.regs
[A3_REGNUM
], REGISTER_SIZE
));
451 return read_register (A3_REGNUM
);
457 adjust
+= (fi
->fsr
.regs
[D2_REGNUM
] ? 4 : 0);
458 adjust
+= (fi
->fsr
.regs
[D3_REGNUM
] ? 4 : 0);
459 adjust
+= (fi
->fsr
.regs
[A2_REGNUM
] ? 4 : 0);
460 adjust
+= (fi
->fsr
.regs
[A3_REGNUM
] ? 4 : 0);
461 /* start-sanitize-am33 */
464 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+5] ? 4 : 0);
465 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+4] ? 4 : 0);
466 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+3] ? 4 : 0);
467 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+2] ? 4 : 0);
469 /* end-sanitize-am33 */
471 /* Our caller does not have a frame pointer. So his frame starts
472 at the base of our frame (fi->frame) + register save space
474 return fi
->frame
+ adjust
+ -dummy_frame
.stack_size
;
478 /* Function: skip_prologue
479 Return the address of the first inst past the prologue of the function. */
482 mn10300_skip_prologue (pc
)
485 /* We used to check the debug symbols, but that can lose if
486 we have a null prologue. */
487 return mn10300_analyze_prologue (NULL
, pc
);
491 /* Function: pop_frame
492 This routine gets called when either the user uses the `return'
493 command, or the call dummy breakpoint gets hit. */
496 mn10300_pop_frame (frame
)
497 struct frame_info
*frame
;
501 if (PC_IN_CALL_DUMMY(frame
->pc
, frame
->frame
, frame
->frame
))
502 generic_pop_dummy_frame ();
505 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
507 /* Restore any saved registers. */
508 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
509 if (frame
->fsr
.regs
[regnum
] != 0)
513 value
= read_memory_unsigned_integer (frame
->fsr
.regs
[regnum
],
514 REGISTER_RAW_SIZE (regnum
));
515 write_register (regnum
, value
);
518 /* Actually cut back the stack. */
519 write_register (SP_REGNUM
, FRAME_FP (frame
));
521 /* Don't we need to set the PC?!? XXX FIXME. */
524 /* Throw away any cached frame information. */
525 flush_cached_frames ();
528 /* Function: push_arguments
529 Setup arguments for a call to the target. Arguments go in
530 order on the stack. */
533 mn10300_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
537 unsigned char struct_return
;
538 CORE_ADDR struct_addr
;
542 int stack_offset
= 0;
543 int regsused
= struct_return
? 1 : 0;
545 /* This should be a nop, but align the stack just in case something
546 went wrong. Stacks are four byte aligned on the mn10300. */
549 /* Now make space on the stack for the args.
551 XXX This doesn't appear to handle pass-by-invisible reference
553 for (argnum
= 0; argnum
< nargs
; argnum
++)
555 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3;
557 while (regsused
< 2 && arg_length
> 0)
565 /* Allocate stack space. */
568 regsused
= struct_return
? 1 : 0;
569 /* Push all arguments onto the stack. */
570 for (argnum
= 0; argnum
< nargs
; argnum
++)
575 /* XXX Check this. What about UNIONS? */
576 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
577 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
579 /* XXX Wrong, we want a pointer to this argument. */
580 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
581 val
= (char *)VALUE_CONTENTS (*args
);
585 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
586 val
= (char *)VALUE_CONTENTS (*args
);
589 while (regsused
< 2 && len
> 0)
591 write_register (regsused
, extract_unsigned_integer (val
, 4));
599 write_memory (sp
+ stack_offset
, val
, 4);
608 /* Make space for the flushback area. */
613 /* Function: push_return_address (pc)
614 Set up the return address for the inferior function call.
615 Needed for targets where we don't actually execute a JSR/BSR instruction */
618 mn10300_push_return_address (pc
, sp
)
622 unsigned char buf
[4];
624 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
625 write_memory (sp
- 4, buf
, 4);
629 /* Function: store_struct_return (addr,sp)
630 Store the structure value return address for an inferior function
634 mn10300_store_struct_return (addr
, sp
)
638 /* The structure return address is passed as the first argument. */
639 write_register (0, addr
);
643 /* Function: frame_saved_pc
644 Find the caller of this frame. We do this by seeing if RP_REGNUM
645 is saved in the stack anywhere, otherwise we get it from the
646 registers. If the inner frame is a dummy frame, return its PC
647 instead of RP, because that's where "caller" of the dummy-frame
651 mn10300_frame_saved_pc (fi
)
652 struct frame_info
*fi
;
656 adjust
+= (fi
->fsr
.regs
[D2_REGNUM
] ? 4 : 0);
657 adjust
+= (fi
->fsr
.regs
[D3_REGNUM
] ? 4 : 0);
658 adjust
+= (fi
->fsr
.regs
[A2_REGNUM
] ? 4 : 0);
659 adjust
+= (fi
->fsr
.regs
[A3_REGNUM
] ? 4 : 0);
660 /* start-sanitize-am33 */
663 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+5] ? 4 : 0);
664 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+4] ? 4 : 0);
665 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+3] ? 4 : 0);
666 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+2] ? 4 : 0);
668 /* end-sanitize-am33 */
670 return (read_memory_integer (fi
->frame
+ adjust
, REGISTER_SIZE
));
674 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
678 struct frame_info
*frame
;
680 enum lval_type
*lval
;
682 generic_get_saved_register (raw_buffer
, optimized
, addrp
,
683 frame
, regnum
, lval
);
686 /* Function: init_extra_frame_info
687 Setup the frame's frame pointer, pc, and frame addresses for saved
688 registers. Most of the work is done in mn10300_analyze_prologue().
690 Note that when we are called for the last frame (currently active frame),
691 that fi->pc and fi->frame will already be setup. However, fi->frame will
692 be valid only if this routine uses FP. For previous frames, fi-frame will
693 always be correct. mn10300_analyze_prologue will fix fi->frame if
696 We can be called with the PC in the call dummy under two circumstances.
697 First, during normal backtracing, second, while figuring out the frame
698 pointer just prior to calling the target function (see run_stack_dummy). */
701 mn10300_init_extra_frame_info (fi
)
702 struct frame_info
*fi
;
705 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
707 memset (fi
->fsr
.regs
, '\000', sizeof fi
->fsr
.regs
);
711 mn10300_analyze_prologue (fi
, 0);
714 /* This can be made more generic later. */
716 set_machine_hook (filename
)
721 if (bfd_get_mach (exec_bfd
) == bfd_mach_mn10300
722 || bfd_get_mach (exec_bfd
) == 0)
724 for (i
= 0; i
< NUM_REGS
; i
++)
725 reg_names
[i
] = mn10300_generic_register_names
[i
];
728 /* start-sanitize-am33 */
730 if (bfd_get_mach (exec_bfd
) == bfd_mach_am33
)
732 for (i
= 0; i
< NUM_REGS
; i
++)
733 reg_names
[i
] = am33_register_names
[i
];
736 /* end-sanitize-am33 */
740 _initialize_mn10300_tdep ()
742 /* printf("_initialize_mn10300_tdep\n"); */
744 tm_print_insn
= print_insn_mn10300
;
746 specify_exec_file_hook (set_machine_hook
);