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 static CORE_ADDR mn10300_analyze_prologue
PARAMS ((struct frame_info
*fi
,
34 /* Additional info used by the frame */
36 struct frame_extra_info
43 static char *mn10300_generic_register_names
[] =
44 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
45 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
46 "", "", "", "", "", "", "", "",
47 "", "", "", "", "", "", "", "fp" };
49 static char **mn10300_register_names
= mn10300_generic_register_names
;
52 mn10300_register_name (i
)
55 return mn10300_register_names
[i
];
59 mn10300_saved_pc_after_call (fi
)
60 struct frame_info
*fi
;
62 return read_memory_integer (read_register (SP_REGNUM
), 4);
66 mn10300_extract_return_value (type
, regbuf
, valbuf
)
71 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
72 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (4), TYPE_LENGTH (type
));
74 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), TYPE_LENGTH (type
));
78 mn10300_extract_struct_value_address (regbuf
)
81 return extract_address (regbuf
+ REGISTER_BYTE (4),
82 REGISTER_RAW_SIZE (4));
86 mn10300_store_return_value (type
, valbuf
)
90 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
91 write_register_bytes (REGISTER_BYTE (4), valbuf
, TYPE_LENGTH (type
));
93 write_register_bytes (REGISTER_BYTE (0), valbuf
, TYPE_LENGTH (type
));
96 static struct frame_info
*analyze_dummy_frame
PARAMS ((CORE_ADDR
, CORE_ADDR
));
97 static struct frame_info
*
98 analyze_dummy_frame (pc
, frame
)
102 static struct frame_info
*dummy
= NULL
;
105 dummy
= xmalloc (sizeof (struct frame_info
));
106 dummy
->saved_regs
= xmalloc (SIZEOF_FRAME_SAVED_REGS
);
107 dummy
->extra_info
= xmalloc (sizeof (struct frame_extra_info
));
112 dummy
->frame
= frame
;
113 dummy
->extra_info
->status
= 0;
114 dummy
->extra_info
->stack_size
= 0;
115 memset (dummy
->saved_regs
, '\000', SIZEOF_FRAME_SAVED_REGS
);
116 mn10300_analyze_prologue (dummy
, 0);
120 /* Values for frame_info.status */
122 #define MY_FRAME_IN_SP 0x1
123 #define MY_FRAME_IN_FP 0x2
124 #define NO_MORE_FRAMES 0x4
127 /* Should call_function allocate stack space for a struct return? */
129 mn10300_use_struct_convention (gcc_p
, type
)
133 return (TYPE_NFIELDS (type
) > 1 || TYPE_LENGTH (type
) > 8);
136 /* The breakpoint instruction must be the same size as the smallest
137 instruction in the instruction set.
139 The Matsushita mn10x00 processors have single byte instructions
140 so we need a single byte breakpoint. Matsushita hasn't defined
141 one, so we defined it ourselves. */
144 mn10300_breakpoint_from_pc (bp_addr
, bp_size
)
148 static char breakpoint
[] = {0xff};
154 /* Fix fi->frame if it's bogus at this point. This is a helper
155 function for mn10300_analyze_prologue. */
158 fix_frame_pointer (fi
, stack_size
)
159 struct frame_info
*fi
;
162 if (fi
&& fi
->next
== NULL
)
164 if (fi
->extra_info
->status
& MY_FRAME_IN_SP
)
165 fi
->frame
= read_sp () - stack_size
;
166 else if (fi
->extra_info
->status
& MY_FRAME_IN_FP
)
167 fi
->frame
= read_register (A3_REGNUM
);
172 /* Set offsets of registers saved by movm instruction.
173 This is a helper function for mn10300_analyze_prologue. */
176 set_movm_offsets (fi
, movm_args
)
177 struct frame_info
*fi
;
182 if (fi
== NULL
|| movm_args
== 0)
185 if (movm_args
& 0x10)
187 fi
->saved_regs
[A3_REGNUM
] = fi
->frame
+ offset
;
190 if (movm_args
& 0x20)
192 fi
->saved_regs
[A2_REGNUM
] = fi
->frame
+ offset
;
195 if (movm_args
& 0x40)
197 fi
->saved_regs
[D3_REGNUM
] = fi
->frame
+ offset
;
200 if (movm_args
& 0x80)
202 fi
->saved_regs
[D2_REGNUM
] = fi
->frame
+ offset
;
208 /* The main purpose of this file is dealing with prologues to extract
209 information about stack frames and saved registers.
211 For reference here's how prologues look on the mn10300:
214 movm [d2,d3,a2,a3],sp
218 Without frame pointer:
219 movm [d2,d3,a2,a3],sp (if needed)
222 One day we might keep the stack pointer constant, that won't
223 change the code for prologues, but it will make the frame
224 pointerless case much more common. */
226 /* Analyze the prologue to determine where registers are saved,
227 the end of the prologue, etc etc. Return the end of the prologue
230 We store into FI (if non-null) several tidbits of information:
232 * stack_size -- size of this stack frame. Note that if we stop in
233 certain parts of the prologue/epilogue we may claim the size of the
234 current frame is zero. This happens when the current frame has
235 not been allocated yet or has already been deallocated.
237 * fsr -- Addresses of registers saved in the stack by this frame.
239 * status -- A (relatively) generic status indicator. It's a bitmask
240 with the following bits:
242 MY_FRAME_IN_SP: The base of the current frame is actually in
243 the stack pointer. This can happen for frame pointerless
244 functions, or cases where we're stopped in the prologue/epilogue
245 itself. For these cases mn10300_analyze_prologue will need up
246 update fi->frame before returning or analyzing the register
249 MY_FRAME_IN_FP: The base of the current frame is in the
250 frame pointer register ($a2).
252 NO_MORE_FRAMES: Set this if the current frame is "start" or
253 if the first instruction looks like mov <imm>,sp. This tells
254 frame chain to not bother trying to unwind past this frame. */
257 mn10300_analyze_prologue (fi
, pc
)
258 struct frame_info
*fi
;
261 CORE_ADDR func_addr
, func_end
, addr
, stop
;
262 CORE_ADDR stack_size
;
264 unsigned char buf
[4];
265 int status
, movm_args
= 0;
268 /* Use the PC in the frame if it's provided to look up the
269 start of this function. */
270 pc
= (fi
? fi
->pc
: pc
);
272 /* Find the start of this function. */
273 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
275 /* Do nothing if we couldn't find the start of this function or if we're
276 stopped at the first instruction in the prologue. */
280 /* If we're in start, then give up. */
281 if (strcmp (name
, "start") == 0)
284 fi
->extra_info
->status
= NO_MORE_FRAMES
;
288 /* At the start of a function our frame is in the stack pointer. */
290 fi
->extra_info
->status
= MY_FRAME_IN_SP
;
292 /* Get the next two bytes into buf, we need two because rets is a two
293 byte insn and the first isn't enough to uniquely identify it. */
294 status
= read_memory_nobpt (pc
, buf
, 2);
298 /* If we're physically on an "rets" instruction, then our frame has
299 already been deallocated. Note this can also be true for retf
300 and ret if they specify a size of zero.
302 In this case fi->frame is bogus, we need to fix it. */
303 if (fi
&& buf
[0] == 0xf0 && buf
[1] == 0xfc)
305 if (fi
->next
== NULL
)
306 fi
->frame
= read_sp ();
310 /* Similarly if we're stopped on the first insn of a prologue as our
311 frame hasn't been allocated yet. */
312 if (fi
&& fi
->pc
== func_addr
)
314 if (fi
->next
== NULL
)
315 fi
->frame
= read_sp ();
319 /* Figure out where to stop scanning. */
320 stop
= fi
? fi
->pc
: func_end
;
322 /* Don't walk off the end of the function. */
323 stop
= stop
> func_end
? func_end
: stop
;
325 /* Start scanning on the first instruction of this function. */
328 /* Suck in two bytes. */
329 status
= read_memory_nobpt (addr
, buf
, 2);
332 fix_frame_pointer (fi
, 0);
336 /* First see if this insn sets the stack pointer; if so, it's something
337 we won't understand, so quit now. */
338 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
341 fi
->extra_info
->status
= NO_MORE_FRAMES
;
345 /* Now look for movm [regs],sp, which saves the callee saved registers.
347 At this time we don't know if fi->frame is valid, so we only note
348 that we encountered a movm instruction. Later, we'll set the entries
349 in fsr.regs as needed. */
352 /* Extract the register list for the movm instruction. */
353 status
= read_memory_nobpt (addr
+ 1, buf
, 1);
358 /* Quit now if we're beyond the stop point. */
361 /* Fix fi->frame since it's bogus at this point. */
362 if (fi
&& fi
->next
== NULL
)
363 fi
->frame
= read_sp ();
365 /* Note if/where callee saved registers were saved. */
366 set_movm_offsets (fi
, movm_args
);
370 /* Get the next two bytes so the prologue scan can continue. */
371 status
= read_memory_nobpt (addr
, buf
, 2);
374 /* Fix fi->frame since it's bogus at this point. */
375 if (fi
&& fi
->next
== NULL
)
376 fi
->frame
= read_sp ();
378 /* Note if/where callee saved registers were saved. */
379 set_movm_offsets (fi
, movm_args
);
384 /* Now see if we set up a frame pointer via "mov sp,a3" */
389 /* The frame pointer is now valid. */
392 fi
->extra_info
->status
|= MY_FRAME_IN_FP
;
393 fi
->extra_info
->status
&= ~MY_FRAME_IN_SP
;
396 /* Quit now if we're beyond the stop point. */
399 /* Fix fi->frame if it's bogus at this point. */
400 fix_frame_pointer (fi
, 0);
402 /* Note if/where callee saved registers were saved. */
403 set_movm_offsets (fi
, movm_args
);
407 /* Get two more bytes so scanning can continue. */
408 status
= read_memory_nobpt (addr
, buf
, 2);
411 /* Fix fi->frame if it's bogus at this point. */
412 fix_frame_pointer (fi
, 0);
414 /* Note if/where callee saved registers were saved. */
415 set_movm_offsets (fi
, movm_args
);
420 /* Next we should allocate the local frame. No more prologue insns
421 are found after allocating the local frame.
423 Search for add imm8,sp (0xf8feXX)
424 or add imm16,sp (0xfafeXXXX)
425 or add imm32,sp (0xfcfeXXXXXXXX).
427 If none of the above was found, then this prologue has no
430 status
= read_memory_nobpt (addr
, buf
, 2);
433 /* Fix fi->frame if it's bogus at this point. */
434 fix_frame_pointer (fi
, 0);
436 /* Note if/where callee saved registers were saved. */
437 set_movm_offsets (fi
, movm_args
);
442 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
444 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
446 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
451 /* Suck in imm_size more bytes, they'll hold the size of the
453 status
= read_memory_nobpt (addr
+ 2, buf
, imm_size
);
456 /* Fix fi->frame if it's bogus at this point. */
457 fix_frame_pointer (fi
, 0);
459 /* Note if/where callee saved registers were saved. */
460 set_movm_offsets (fi
, movm_args
);
464 /* Note the size of the stack in the frame info structure. */
465 stack_size
= extract_signed_integer (buf
, imm_size
);
467 fi
->extra_info
->stack_size
= stack_size
;
469 /* We just consumed 2 + imm_size bytes. */
470 addr
+= 2 + imm_size
;
472 /* No more prologue insns follow, so begin preparation to return. */
473 /* Fix fi->frame if it's bogus at this point. */
474 fix_frame_pointer (fi
, stack_size
);
476 /* Note if/where callee saved registers were saved. */
477 set_movm_offsets (fi
, movm_args
);
481 /* We never found an insn which allocates local stack space, regardless
482 this is the end of the prologue. */
483 /* Fix fi->frame if it's bogus at this point. */
484 fix_frame_pointer (fi
, 0);
486 /* Note if/where callee saved registers were saved. */
487 set_movm_offsets (fi
, movm_args
);
491 /* Function: frame_chain
492 Figure out and return the caller's frame pointer given current
495 We don't handle dummy frames yet but we would probably just return the
496 stack pointer that was in use at the time the function call was made? */
499 mn10300_frame_chain (fi
)
500 struct frame_info
*fi
;
502 struct frame_info
*dummy
;
503 /* Walk through the prologue to determine the stack size,
504 location of saved registers, end of the prologue, etc. */
505 if (fi
->extra_info
->status
== 0)
506 mn10300_analyze_prologue (fi
, (CORE_ADDR
)0);
508 /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
509 if (fi
->extra_info
->status
& NO_MORE_FRAMES
)
512 /* Now that we've analyzed our prologue, determine the frame
513 pointer for our caller.
515 If our caller has a frame pointer, then we need to
516 find the entry value of $a3 to our function.
518 If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
519 location pointed to by fsr.regs[A3_REGNUM].
521 Else it's still in $a3.
523 If our caller does not have a frame pointer, then his
524 frame base is fi->frame + -caller's stack size. */
526 /* The easiest way to get that info is to analyze our caller's frame.
527 So we set up a dummy frame and call mn10300_analyze_prologue to
528 find stuff for us. */
529 dummy
= analyze_dummy_frame (FRAME_SAVED_PC (fi
), fi
->frame
);
531 if (dummy
->extra_info
->status
& MY_FRAME_IN_FP
)
533 /* Our caller has a frame pointer. So find the frame in $a3 or
535 if (fi
->saved_regs
[A3_REGNUM
])
536 return (read_memory_integer (fi
->saved_regs
[A3_REGNUM
], REGISTER_SIZE
));
538 return read_register (A3_REGNUM
);
544 adjust
+= (fi
->saved_regs
[D2_REGNUM
] ? 4 : 0);
545 adjust
+= (fi
->saved_regs
[D3_REGNUM
] ? 4 : 0);
546 adjust
+= (fi
->saved_regs
[A2_REGNUM
] ? 4 : 0);
547 adjust
+= (fi
->saved_regs
[A3_REGNUM
] ? 4 : 0);
549 /* Our caller does not have a frame pointer. So his frame starts
550 at the base of our frame (fi->frame) + register save space
552 return fi
->frame
+ adjust
+ -dummy
->extra_info
->stack_size
;
556 /* Function: skip_prologue
557 Return the address of the first inst past the prologue of the function. */
560 mn10300_skip_prologue (pc
)
563 /* We used to check the debug symbols, but that can lose if
564 we have a null prologue. */
565 return mn10300_analyze_prologue (NULL
, pc
);
569 /* Function: pop_frame
570 This routine gets called when either the user uses the `return'
571 command, or the call dummy breakpoint gets hit. */
574 mn10300_pop_frame (frame
)
575 struct frame_info
*frame
;
579 if (PC_IN_CALL_DUMMY(frame
->pc
, frame
->frame
, frame
->frame
))
580 generic_pop_dummy_frame ();
583 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
585 /* Restore any saved registers. */
586 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
587 if (frame
->saved_regs
[regnum
] != 0)
591 value
= read_memory_unsigned_integer (frame
->saved_regs
[regnum
],
592 REGISTER_RAW_SIZE (regnum
));
593 write_register (regnum
, value
);
596 /* Actually cut back the stack. */
597 write_register (SP_REGNUM
, FRAME_FP (frame
));
599 /* Don't we need to set the PC?!? XXX FIXME. */
602 /* Throw away any cached frame information. */
603 flush_cached_frames ();
606 /* Function: push_arguments
607 Setup arguments for a call to the target. Arguments go in
608 order on the stack. */
611 mn10300_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
615 unsigned char struct_return
;
616 CORE_ADDR struct_addr
;
620 int stack_offset
= 0;
621 int regsused
= struct_return
? 1 : 0;
623 /* This should be a nop, but align the stack just in case something
624 went wrong. Stacks are four byte aligned on the mn10300. */
627 /* Now make space on the stack for the args.
629 XXX This doesn't appear to handle pass-by-invisible reference
631 for (argnum
= 0; argnum
< nargs
; argnum
++)
633 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3;
635 while (regsused
< 2 && arg_length
> 0)
643 /* Allocate stack space. */
646 regsused
= struct_return
? 1 : 0;
647 /* Push all arguments onto the stack. */
648 for (argnum
= 0; argnum
< nargs
; argnum
++)
653 /* XXX Check this. What about UNIONS? */
654 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
655 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
657 /* XXX Wrong, we want a pointer to this argument. */
658 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
659 val
= (char *)VALUE_CONTENTS (*args
);
663 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
664 val
= (char *)VALUE_CONTENTS (*args
);
667 while (regsused
< 2 && len
> 0)
669 write_register (regsused
, extract_unsigned_integer (val
, 4));
677 write_memory (sp
+ stack_offset
, val
, 4);
686 /* Make space for the flushback area. */
691 /* Function: push_return_address (pc)
692 Set up the return address for the inferior function call.
693 Needed for targets where we don't actually execute a JSR/BSR instruction */
696 mn10300_push_return_address (pc
, sp
)
700 unsigned char buf
[4];
702 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
703 write_memory (sp
- 4, buf
, 4);
707 /* Function: store_struct_return (addr,sp)
708 Store the structure value return address for an inferior function
712 mn10300_store_struct_return (addr
, sp
)
716 /* The structure return address is passed as the first argument. */
717 write_register (0, addr
);
721 /* Function: frame_saved_pc
722 Find the caller of this frame. We do this by seeing if RP_REGNUM
723 is saved in the stack anywhere, otherwise we get it from the
724 registers. If the inner frame is a dummy frame, return its PC
725 instead of RP, because that's where "caller" of the dummy-frame
729 mn10300_frame_saved_pc (fi
)
730 struct frame_info
*fi
;
734 adjust
+= (fi
->saved_regs
[D2_REGNUM
] ? 4 : 0);
735 adjust
+= (fi
->saved_regs
[D3_REGNUM
] ? 4 : 0);
736 adjust
+= (fi
->saved_regs
[A2_REGNUM
] ? 4 : 0);
737 adjust
+= (fi
->saved_regs
[A3_REGNUM
] ? 4 : 0);
739 return (read_memory_integer (fi
->frame
+ adjust
, REGISTER_SIZE
));
742 /* Function: mn10300_init_extra_frame_info
743 Setup the frame's frame pointer, pc, and frame addresses for saved
744 registers. Most of the work is done in mn10300_analyze_prologue().
746 Note that when we are called for the last frame (currently active frame),
747 that fi->pc and fi->frame will already be setup. However, fi->frame will
748 be valid only if this routine uses FP. For previous frames, fi-frame will
749 always be correct. mn10300_analyze_prologue will fix fi->frame if
752 We can be called with the PC in the call dummy under two circumstances.
753 First, during normal backtracing, second, while figuring out the frame
754 pointer just prior to calling the target function (see run_stack_dummy). */
757 mn10300_init_extra_frame_info (fi
)
758 struct frame_info
*fi
;
761 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
763 frame_saved_regs_zalloc (fi
);
764 fi
->extra_info
= (struct frame_extra_info
*)
765 frame_obstack_alloc (sizeof (struct frame_extra_info
));
767 fi
->extra_info
->status
= 0;
768 fi
->extra_info
->stack_size
= 0;
770 mn10300_analyze_prologue (fi
, 0);
773 /* Function: mn10300_virtual_frame_pointer
774 Return the register that the function uses for a frame pointer,
775 plus any necessary offset to be applied to the register before
776 any frame pointer offsets. */
779 mn10300_virtual_frame_pointer (pc
, reg
, offset
)
784 struct frame_info
*dummy
= analyze_dummy_frame (pc
, 0);
785 /* Set up a dummy frame_info, Analyze the prolog and fill in the
787 /* Results will tell us which type of frame it uses. */
788 if (dummy
->extra_info
->status
& MY_FRAME_IN_SP
)
791 *offset
= -(dummy
->extra_info
->stack_size
);
800 /* This can be made more generic later. */
802 set_machine_hook (filename
)
807 if (bfd_get_mach (exec_bfd
) == bfd_mach_mn10300
808 || bfd_get_mach (exec_bfd
) == 0)
810 mn10300_register_names
= mn10300_generic_register_names
;
816 _initialize_mn10300_tdep ()
818 /* printf("_initialize_mn10300_tdep\n"); */
820 tm_print_insn
= print_insn_mn10300
;
822 specify_exec_file_hook (set_machine_hook
);