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 /* Should call_function allocate stack space for a struct return? */
54 mn10300_use_struct_convention (gcc_p
, type
)
58 return (TYPE_NFIELDS (type
) > 1 || TYPE_LENGTH (type
) > 8);
62 /* Fix fi->frame if it's bogus at this point. This is a helper
63 function for mn10300_analyze_prologue. */
66 fix_frame_pointer (fi
, stack_size
)
67 struct frame_info
*fi
;
70 if (fi
&& fi
->next
== NULL
)
72 if (fi
->status
& MY_FRAME_IN_SP
)
73 fi
->frame
= read_sp () - stack_size
;
74 else if (fi
->status
& MY_FRAME_IN_FP
)
75 fi
->frame
= read_register (A3_REGNUM
);
80 /* Set offsets of registers saved by movm instruction.
81 This is a helper function for mn10300_analyze_prologue. */
84 set_movm_offsets (fi
, movm_args
)
85 struct frame_info
*fi
;
90 if (fi
== NULL
|| movm_args
== 0)
95 fi
->fsr
.regs
[A3_REGNUM
] = fi
->frame
+ offset
;
100 fi
->fsr
.regs
[A2_REGNUM
] = fi
->frame
+ offset
;
103 if (movm_args
& 0x40)
105 fi
->fsr
.regs
[D3_REGNUM
] = fi
->frame
+ offset
;
108 if (movm_args
& 0x80)
110 fi
->fsr
.regs
[D2_REGNUM
] = fi
->frame
+ offset
;
113 /* start-sanitize-am33 */
114 if (am33_mode
&& movm_args
& 0x02)
116 fi
->fsr
.regs
[E0_REGNUM
+5] = fi
->frame
+ offset
;
117 fi
->fsr
.regs
[E0_REGNUM
+4] = fi
->frame
+ offset
+ 4;
118 fi
->fsr
.regs
[E0_REGNUM
+3] = fi
->frame
+ offset
+ 8;
119 fi
->fsr
.regs
[E0_REGNUM
+2] = fi
->frame
+ offset
+ 12;
121 /* end-sanitize-am33 */
125 /* The main purpose of this file is dealing with prologues to extract
126 information about stack frames and saved registers.
128 For reference here's how prologues look on the mn10300:
131 movm [d2,d3,a2,a3],sp
135 Without frame pointer:
136 movm [d2,d3,a2,a3],sp (if needed)
139 One day we might keep the stack pointer constant, that won't
140 change the code for prologues, but it will make the frame
141 pointerless case much more common. */
143 /* Analyze the prologue to determine where registers are saved,
144 the end of the prologue, etc etc. Return the end of the prologue
147 We store into FI (if non-null) several tidbits of information:
149 * stack_size -- size of this stack frame. Note that if we stop in
150 certain parts of the prologue/epilogue we may claim the size of the
151 current frame is zero. This happens when the current frame has
152 not been allocated yet or has already been deallocated.
154 * fsr -- Addresses of registers saved in the stack by this frame.
156 * status -- A (relatively) generic status indicator. It's a bitmask
157 with the following bits:
159 MY_FRAME_IN_SP: The base of the current frame is actually in
160 the stack pointer. This can happen for frame pointerless
161 functions, or cases where we're stopped in the prologue/epilogue
162 itself. For these cases mn10300_analyze_prologue will need up
163 update fi->frame before returning or analyzing the register
166 MY_FRAME_IN_FP: The base of the current frame is in the
167 frame pointer register ($a2).
169 NO_MORE_FRAMES: Set this if the current frame is "start" or
170 if the first instruction looks like mov <imm>,sp. This tells
171 frame chain to not bother trying to unwind past this frame. */
174 mn10300_analyze_prologue (fi
, pc
)
175 struct frame_info
*fi
;
178 CORE_ADDR func_addr
, func_end
, addr
, stop
;
179 CORE_ADDR stack_size
;
181 unsigned char buf
[4];
182 int status
, movm_args
= 0;
185 /* Use the PC in the frame if it's provided to look up the
186 start of this function. */
187 pc
= (fi
? fi
->pc
: pc
);
189 /* Find the start of this function. */
190 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
192 /* Do nothing if we couldn't find the start of this function or if we're
193 stopped at the first instruction in the prologue. */
197 /* If we're in start, then give up. */
198 if (strcmp (name
, "start") == 0)
201 fi
->status
= NO_MORE_FRAMES
;
205 /* At the start of a function our frame is in the stack pointer. */
207 fi
->status
= MY_FRAME_IN_SP
;
209 /* Get the next two bytes into buf, we need two because rets is a two
210 byte insn and the first isn't enough to uniquely identify it. */
211 status
= read_memory_nobpt (pc
, buf
, 2);
215 /* If we're physically on an "rets" instruction, then our frame has
216 already been deallocated. Note this can also be true for retf
217 and ret if they specify a size of zero.
219 In this case fi->frame is bogus, we need to fix it. */
220 if (fi
&& buf
[0] == 0xf0 && buf
[1] == 0xfc)
222 if (fi
->next
== NULL
)
223 fi
->frame
= read_sp ();
227 /* Similarly if we're stopped on the first insn of a prologue as our
228 frame hasn't been allocated yet. */
229 if (fi
&& fi
->pc
== func_addr
)
231 if (fi
->next
== NULL
)
232 fi
->frame
= read_sp ();
236 /* Figure out where to stop scanning. */
237 stop
= fi
? fi
->pc
: func_end
;
239 /* Don't walk off the end of the function. */
240 stop
= stop
> func_end
? func_end
: stop
;
242 /* Start scanning on the first instruction of this function. */
245 /* Suck in two bytes. */
246 status
= read_memory_nobpt (addr
, buf
, 2);
249 fix_frame_pointer (fi
, 0);
253 /* First see if this insn sets the stack pointer; if so, it's something
254 we won't understand, so quit now. */
255 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
258 fi
->status
= NO_MORE_FRAMES
;
262 /* Now look for movm [regs],sp, which saves the callee saved registers.
264 At this time we don't know if fi->frame is valid, so we only note
265 that we encountered a movm instruction. Later, we'll set the entries
266 in fsr.regs as needed. */
269 /* Extract the register list for the movm instruction. */
270 status
= read_memory_nobpt (addr
+ 1, buf
, 1);
275 /* Quit now if we're beyond the stop point. */
278 /* Fix fi->frame since it's bogus at this point. */
279 if (fi
&& fi
->next
== NULL
)
280 fi
->frame
= read_sp ();
282 /* Note if/where callee saved registers were saved. */
283 set_movm_offsets (fi
, movm_args
);
287 /* Get the next two bytes so the prologue scan can continue. */
288 status
= read_memory_nobpt (addr
, buf
, 2);
291 /* Fix fi->frame since it's bogus at this point. */
292 if (fi
&& fi
->next
== NULL
)
293 fi
->frame
= read_sp ();
295 /* Note if/where callee saved registers were saved. */
296 set_movm_offsets (fi
, movm_args
);
301 /* Now see if we set up a frame pointer via "mov sp,a3" */
306 /* The frame pointer is now valid. */
309 fi
->status
|= MY_FRAME_IN_FP
;
310 fi
->status
&= ~MY_FRAME_IN_SP
;
313 /* Quit now if we're beyond the stop point. */
316 /* Fix fi->frame if it's bogus at this point. */
317 fix_frame_pointer (fi
, 0);
319 /* Note if/where callee saved registers were saved. */
320 set_movm_offsets (fi
, movm_args
);
324 /* Get two more bytes so scanning can continue. */
325 status
= read_memory_nobpt (addr
, buf
, 2);
328 /* Fix fi->frame if it's bogus at this point. */
329 fix_frame_pointer (fi
, 0);
331 /* Note if/where callee saved registers were saved. */
332 set_movm_offsets (fi
, movm_args
);
337 /* Next we should allocate the local frame. No more prologue insns
338 are found after allocating the local frame.
340 Search for add imm8,sp (0xf8feXX)
341 or add imm16,sp (0xfafeXXXX)
342 or add imm32,sp (0xfcfeXXXXXXXX).
344 If none of the above was found, then this prologue has no
347 status
= read_memory_nobpt (addr
, buf
, 2);
350 /* Fix fi->frame if it's bogus at this point. */
351 fix_frame_pointer (fi
, 0);
353 /* Note if/where callee saved registers were saved. */
354 set_movm_offsets (fi
, movm_args
);
359 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
361 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
363 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
368 /* Suck in imm_size more bytes, they'll hold the size of the
370 status
= read_memory_nobpt (addr
+ 2, buf
, imm_size
);
373 /* Fix fi->frame if it's bogus at this point. */
374 fix_frame_pointer (fi
, 0);
376 /* Note if/where callee saved registers were saved. */
377 set_movm_offsets (fi
, movm_args
);
381 /* Note the size of the stack in the frame info structure. */
382 stack_size
= extract_signed_integer (buf
, imm_size
);
384 fi
->stack_size
= stack_size
;
386 /* We just consumed 2 + imm_size bytes. */
387 addr
+= 2 + imm_size
;
389 /* No more prologue insns follow, so begin preparation to return. */
390 /* Fix fi->frame if it's bogus at this point. */
391 fix_frame_pointer (fi
, stack_size
);
393 /* Note if/where callee saved registers were saved. */
394 set_movm_offsets (fi
, movm_args
);
398 /* We never found an insn which allocates local stack space, regardless
399 this is the end of the prologue. */
400 /* Fix fi->frame if it's bogus at this point. */
401 fix_frame_pointer (fi
, 0);
403 /* Note if/where callee saved registers were saved. */
404 set_movm_offsets (fi
, movm_args
);
408 /* Function: frame_chain
409 Figure out and return the caller's frame pointer given current
412 We don't handle dummy frames yet but we would probably just return the
413 stack pointer that was in use at the time the function call was made? */
416 mn10300_frame_chain (fi
)
417 struct frame_info
*fi
;
419 struct frame_info dummy_frame
;
421 /* Walk through the prologue to determine the stack size,
422 location of saved registers, end of the prologue, etc. */
424 mn10300_analyze_prologue (fi
, (CORE_ADDR
)0);
426 /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
427 if (fi
->status
& NO_MORE_FRAMES
)
430 /* Now that we've analyzed our prologue, determine the frame
431 pointer for our caller.
433 If our caller has a frame pointer, then we need to
434 find the entry value of $a3 to our function.
436 If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
437 location pointed to by fsr.regs[A3_REGNUM].
439 Else it's still in $a3.
441 If our caller does not have a frame pointer, then his
442 frame base is fi->frame + -caller's stack size. */
444 /* The easiest way to get that info is to analyze our caller's frame.
446 So we set up a dummy frame and call mn10300_analyze_prologue to
447 find stuff for us. */
448 dummy_frame
.pc
= FRAME_SAVED_PC (fi
);
449 dummy_frame
.frame
= fi
->frame
;
450 memset (dummy_frame
.fsr
.regs
, '\000', sizeof dummy_frame
.fsr
.regs
);
451 dummy_frame
.status
= 0;
452 dummy_frame
.stack_size
= 0;
453 mn10300_analyze_prologue (&dummy_frame
, 0);
455 if (dummy_frame
.status
& MY_FRAME_IN_FP
)
457 /* Our caller has a frame pointer. So find the frame in $a3 or
459 if (fi
->fsr
.regs
[A3_REGNUM
])
460 return (read_memory_integer (fi
->fsr
.regs
[A3_REGNUM
], REGISTER_SIZE
));
462 return read_register (A3_REGNUM
);
468 adjust
+= (fi
->fsr
.regs
[D2_REGNUM
] ? 4 : 0);
469 adjust
+= (fi
->fsr
.regs
[D3_REGNUM
] ? 4 : 0);
470 adjust
+= (fi
->fsr
.regs
[A2_REGNUM
] ? 4 : 0);
471 adjust
+= (fi
->fsr
.regs
[A3_REGNUM
] ? 4 : 0);
472 /* start-sanitize-am33 */
475 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+5] ? 4 : 0);
476 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+4] ? 4 : 0);
477 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+3] ? 4 : 0);
478 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+2] ? 4 : 0);
480 /* end-sanitize-am33 */
482 /* Our caller does not have a frame pointer. So his frame starts
483 at the base of our frame (fi->frame) + register save space
485 return fi
->frame
+ adjust
+ -dummy_frame
.stack_size
;
489 /* Function: skip_prologue
490 Return the address of the first inst past the prologue of the function. */
493 mn10300_skip_prologue (pc
)
496 /* We used to check the debug symbols, but that can lose if
497 we have a null prologue. */
498 return mn10300_analyze_prologue (NULL
, pc
);
502 /* Function: pop_frame
503 This routine gets called when either the user uses the `return'
504 command, or the call dummy breakpoint gets hit. */
507 mn10300_pop_frame (frame
)
508 struct frame_info
*frame
;
512 if (PC_IN_CALL_DUMMY(frame
->pc
, frame
->frame
, frame
->frame
))
513 generic_pop_dummy_frame ();
516 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
518 /* Restore any saved registers. */
519 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
520 if (frame
->fsr
.regs
[regnum
] != 0)
524 value
= read_memory_unsigned_integer (frame
->fsr
.regs
[regnum
],
525 REGISTER_RAW_SIZE (regnum
));
526 write_register (regnum
, value
);
529 /* Actually cut back the stack. */
530 write_register (SP_REGNUM
, FRAME_FP (frame
));
532 /* Don't we need to set the PC?!? XXX FIXME. */
535 /* Throw away any cached frame information. */
536 flush_cached_frames ();
539 /* Function: push_arguments
540 Setup arguments for a call to the target. Arguments go in
541 order on the stack. */
544 mn10300_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
548 unsigned char struct_return
;
549 CORE_ADDR struct_addr
;
553 int stack_offset
= 0;
554 int regsused
= struct_return
? 1 : 0;
556 /* This should be a nop, but align the stack just in case something
557 went wrong. Stacks are four byte aligned on the mn10300. */
560 /* Now make space on the stack for the args.
562 XXX This doesn't appear to handle pass-by-invisible reference
564 for (argnum
= 0; argnum
< nargs
; argnum
++)
566 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3;
568 while (regsused
< 2 && arg_length
> 0)
576 /* Allocate stack space. */
579 regsused
= struct_return
? 1 : 0;
580 /* Push all arguments onto the stack. */
581 for (argnum
= 0; argnum
< nargs
; argnum
++)
586 /* XXX Check this. What about UNIONS? */
587 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
588 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
590 /* XXX Wrong, we want a pointer to this argument. */
591 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
592 val
= (char *)VALUE_CONTENTS (*args
);
596 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
597 val
= (char *)VALUE_CONTENTS (*args
);
600 while (regsused
< 2 && len
> 0)
602 write_register (regsused
, extract_unsigned_integer (val
, 4));
610 write_memory (sp
+ stack_offset
, val
, 4);
619 /* Make space for the flushback area. */
624 /* Function: push_return_address (pc)
625 Set up the return address for the inferior function call.
626 Needed for targets where we don't actually execute a JSR/BSR instruction */
629 mn10300_push_return_address (pc
, sp
)
633 unsigned char buf
[4];
635 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
636 write_memory (sp
- 4, buf
, 4);
640 /* Function: store_struct_return (addr,sp)
641 Store the structure value return address for an inferior function
645 mn10300_store_struct_return (addr
, sp
)
649 /* The structure return address is passed as the first argument. */
650 write_register (0, addr
);
654 /* Function: frame_saved_pc
655 Find the caller of this frame. We do this by seeing if RP_REGNUM
656 is saved in the stack anywhere, otherwise we get it from the
657 registers. If the inner frame is a dummy frame, return its PC
658 instead of RP, because that's where "caller" of the dummy-frame
662 mn10300_frame_saved_pc (fi
)
663 struct frame_info
*fi
;
667 adjust
+= (fi
->fsr
.regs
[D2_REGNUM
] ? 4 : 0);
668 adjust
+= (fi
->fsr
.regs
[D3_REGNUM
] ? 4 : 0);
669 adjust
+= (fi
->fsr
.regs
[A2_REGNUM
] ? 4 : 0);
670 adjust
+= (fi
->fsr
.regs
[A3_REGNUM
] ? 4 : 0);
671 /* start-sanitize-am33 */
674 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+5] ? 4 : 0);
675 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+4] ? 4 : 0);
676 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+3] ? 4 : 0);
677 adjust
+= (fi
->fsr
.regs
[E0_REGNUM
+2] ? 4 : 0);
679 /* end-sanitize-am33 */
681 return (read_memory_integer (fi
->frame
+ adjust
, REGISTER_SIZE
));
685 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
689 struct frame_info
*frame
;
691 enum lval_type
*lval
;
693 generic_get_saved_register (raw_buffer
, optimized
, addrp
,
694 frame
, regnum
, lval
);
697 /* Function: init_extra_frame_info
698 Setup the frame's frame pointer, pc, and frame addresses for saved
699 registers. Most of the work is done in mn10300_analyze_prologue().
701 Note that when we are called for the last frame (currently active frame),
702 that fi->pc and fi->frame will already be setup. However, fi->frame will
703 be valid only if this routine uses FP. For previous frames, fi-frame will
704 always be correct. mn10300_analyze_prologue will fix fi->frame if
707 We can be called with the PC in the call dummy under two circumstances.
708 First, during normal backtracing, second, while figuring out the frame
709 pointer just prior to calling the target function (see run_stack_dummy). */
712 mn10300_init_extra_frame_info (fi
)
713 struct frame_info
*fi
;
716 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
718 memset (fi
->fsr
.regs
, '\000', sizeof fi
->fsr
.regs
);
722 mn10300_analyze_prologue (fi
, 0);
725 /* This can be made more generic later. */
727 set_machine_hook (filename
)
732 if (bfd_get_mach (exec_bfd
) == bfd_mach_mn10300
733 || bfd_get_mach (exec_bfd
) == 0)
735 for (i
= 0; i
< NUM_REGS
; i
++)
736 reg_names
[i
] = mn10300_generic_register_names
[i
];
739 /* start-sanitize-am33 */
741 if (bfd_get_mach (exec_bfd
) == bfd_mach_am33
)
743 for (i
= 0; i
< NUM_REGS
; i
++)
744 reg_names
[i
] = am33_register_names
[i
];
747 /* end-sanitize-am33 */
751 _initialize_mn10300_tdep ()
753 /* printf("_initialize_mn10300_tdep\n"); */
755 tm_print_insn
= print_insn_mn10300
;
757 specify_exec_file_hook (set_machine_hook
);