1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
29 #include "gdb_string.h"
33 #include "arch-utils.h"
45 #define MDRQ_REGNUM 14
47 #define MCRH_REGNUM 26
48 #define MCRL_REGNUM 27
49 #define MCVF_REGNUM 28
51 enum movm_register_bits
{
52 movm_exother_bit
= 0x01,
53 movm_exreg1_bit
= 0x02,
54 movm_exreg0_bit
= 0x04,
55 movm_other_bit
= 0x08,
62 extern void _initialize_mn10300_tdep (void);
63 static CORE_ADDR
mn10300_analyze_prologue (struct frame_info
*fi
,
66 /* mn10300 private data */
70 #define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode)
73 /* Additional info used by the frame */
75 struct frame_extra_info
83 register_name (int reg
, char **regs
, long sizeof_regs
)
85 if (reg
< 0 || reg
>= sizeof_regs
/ sizeof (regs
[0]))
92 mn10300_generic_register_name (int reg
)
95 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
96 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
97 "", "", "", "", "", "", "", "",
98 "", "", "", "", "", "", "", "fp"
100 return register_name (reg
, regs
, sizeof regs
);
105 am33_register_name (int reg
)
107 static char *regs
[] =
108 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
109 "sp", "pc", "mdr", "psw", "lir", "lar", "",
110 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
111 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
113 return register_name (reg
, regs
, sizeof regs
);
117 mn10300_saved_pc_after_call (struct frame_info
*fi
)
119 return read_memory_integer (read_register (SP_REGNUM
), 4);
123 mn10300_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
125 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
126 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (4), TYPE_LENGTH (type
));
128 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), TYPE_LENGTH (type
));
132 mn10300_extract_struct_value_address (char *regbuf
)
134 return extract_address (regbuf
+ REGISTER_BYTE (4),
135 REGISTER_RAW_SIZE (4));
139 mn10300_store_return_value (struct type
*type
, char *valbuf
)
141 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
142 write_register_bytes (REGISTER_BYTE (4), valbuf
, TYPE_LENGTH (type
));
144 write_register_bytes (REGISTER_BYTE (0), valbuf
, TYPE_LENGTH (type
));
147 static struct frame_info
*analyze_dummy_frame (CORE_ADDR
, CORE_ADDR
);
148 static struct frame_info
*
149 analyze_dummy_frame (CORE_ADDR pc
, CORE_ADDR frame
)
151 static struct frame_info
*dummy
= NULL
;
154 dummy
= xmalloc (sizeof (struct frame_info
));
155 dummy
->saved_regs
= xmalloc (SIZEOF_FRAME_SAVED_REGS
);
156 dummy
->extra_info
= xmalloc (sizeof (struct frame_extra_info
));
161 dummy
->frame
= frame
;
162 dummy
->extra_info
->status
= 0;
163 dummy
->extra_info
->stack_size
= 0;
164 memset (dummy
->saved_regs
, '\000', SIZEOF_FRAME_SAVED_REGS
);
165 mn10300_analyze_prologue (dummy
, 0);
169 /* Values for frame_info.status */
171 #define MY_FRAME_IN_SP 0x1
172 #define MY_FRAME_IN_FP 0x2
173 #define NO_MORE_FRAMES 0x4
176 /* Should call_function allocate stack space for a struct return? */
178 mn10300_use_struct_convention (int gcc_p
, struct type
*type
)
180 return (TYPE_NFIELDS (type
) > 1 || TYPE_LENGTH (type
) > 8);
183 /* The breakpoint instruction must be the same size as the smallest
184 instruction in the instruction set.
186 The Matsushita mn10x00 processors have single byte instructions
187 so we need a single byte breakpoint. Matsushita hasn't defined
188 one, so we defined it ourselves. */
190 static unsigned char *
191 mn10300_breakpoint_from_pc (CORE_ADDR
*bp_addr
, int *bp_size
)
193 static char breakpoint
[] =
200 /* Fix fi->frame if it's bogus at this point. This is a helper
201 function for mn10300_analyze_prologue. */
204 fix_frame_pointer (struct frame_info
*fi
, int stack_size
)
206 if (fi
&& fi
->next
== NULL
)
208 if (fi
->extra_info
->status
& MY_FRAME_IN_SP
)
209 fi
->frame
= read_sp () - stack_size
;
210 else if (fi
->extra_info
->status
& MY_FRAME_IN_FP
)
211 fi
->frame
= read_register (A3_REGNUM
);
216 /* Set offsets of registers saved by movm instruction.
217 This is a helper function for mn10300_analyze_prologue. */
220 set_movm_offsets (struct frame_info
*fi
, int movm_args
)
224 if (fi
== NULL
|| movm_args
== 0)
227 if (movm_args
& movm_other_bit
)
229 /* The `other' bit leaves a blank area of four bytes at the
230 beginning of its block of saved registers, making it 32 bytes
232 fi
->saved_regs
[LAR_REGNUM
] = fi
->frame
+ offset
+ 4;
233 fi
->saved_regs
[LIR_REGNUM
] = fi
->frame
+ offset
+ 8;
234 fi
->saved_regs
[MDR_REGNUM
] = fi
->frame
+ offset
+ 12;
235 fi
->saved_regs
[A0_REGNUM
+ 1] = fi
->frame
+ offset
+ 16;
236 fi
->saved_regs
[A0_REGNUM
] = fi
->frame
+ offset
+ 20;
237 fi
->saved_regs
[D0_REGNUM
+ 1] = fi
->frame
+ offset
+ 24;
238 fi
->saved_regs
[D0_REGNUM
] = fi
->frame
+ offset
+ 28;
241 if (movm_args
& movm_a3_bit
)
243 fi
->saved_regs
[A3_REGNUM
] = fi
->frame
+ offset
;
246 if (movm_args
& movm_a2_bit
)
248 fi
->saved_regs
[A2_REGNUM
] = fi
->frame
+ offset
;
251 if (movm_args
& movm_d3_bit
)
253 fi
->saved_regs
[D3_REGNUM
] = fi
->frame
+ offset
;
256 if (movm_args
& movm_d2_bit
)
258 fi
->saved_regs
[D2_REGNUM
] = fi
->frame
+ offset
;
263 if (movm_args
& movm_exother_bit
)
265 fi
->saved_regs
[MCVF_REGNUM
] = fi
->frame
+ offset
;
266 fi
->saved_regs
[MCRL_REGNUM
] = fi
->frame
+ offset
+ 4;
267 fi
->saved_regs
[MCRH_REGNUM
] = fi
->frame
+ offset
+ 8;
268 fi
->saved_regs
[MDRQ_REGNUM
] = fi
->frame
+ offset
+ 12;
269 fi
->saved_regs
[E0_REGNUM
+ 1] = fi
->frame
+ offset
+ 16;
270 fi
->saved_regs
[E0_REGNUM
+ 0] = fi
->frame
+ offset
+ 20;
273 if (movm_args
& movm_exreg1_bit
)
275 fi
->saved_regs
[E0_REGNUM
+ 7] = fi
->frame
+ offset
;
276 fi
->saved_regs
[E0_REGNUM
+ 6] = fi
->frame
+ offset
+ 4;
277 fi
->saved_regs
[E0_REGNUM
+ 5] = fi
->frame
+ offset
+ 8;
278 fi
->saved_regs
[E0_REGNUM
+ 4] = fi
->frame
+ offset
+ 12;
281 if (movm_args
& movm_exreg0_bit
)
283 fi
->saved_regs
[E0_REGNUM
+ 3] = fi
->frame
+ offset
;
284 fi
->saved_regs
[E0_REGNUM
+ 2] = fi
->frame
+ offset
+ 4;
291 /* The main purpose of this file is dealing with prologues to extract
292 information about stack frames and saved registers.
294 For reference here's how prologues look on the mn10300:
297 movm [d2,d3,a2,a3],sp
301 Without frame pointer:
302 movm [d2,d3,a2,a3],sp (if needed)
305 One day we might keep the stack pointer constant, that won't
306 change the code for prologues, but it will make the frame
307 pointerless case much more common. */
309 /* Analyze the prologue to determine where registers are saved,
310 the end of the prologue, etc etc. Return the end of the prologue
313 We store into FI (if non-null) several tidbits of information:
315 * stack_size -- size of this stack frame. Note that if we stop in
316 certain parts of the prologue/epilogue we may claim the size of the
317 current frame is zero. This happens when the current frame has
318 not been allocated yet or has already been deallocated.
320 * fsr -- Addresses of registers saved in the stack by this frame.
322 * status -- A (relatively) generic status indicator. It's a bitmask
323 with the following bits:
325 MY_FRAME_IN_SP: The base of the current frame is actually in
326 the stack pointer. This can happen for frame pointerless
327 functions, or cases where we're stopped in the prologue/epilogue
328 itself. For these cases mn10300_analyze_prologue will need up
329 update fi->frame before returning or analyzing the register
332 MY_FRAME_IN_FP: The base of the current frame is in the
333 frame pointer register ($a2).
335 NO_MORE_FRAMES: Set this if the current frame is "start" or
336 if the first instruction looks like mov <imm>,sp. This tells
337 frame chain to not bother trying to unwind past this frame. */
340 mn10300_analyze_prologue (struct frame_info
*fi
, CORE_ADDR pc
)
342 CORE_ADDR func_addr
, func_end
, addr
, stop
;
343 CORE_ADDR stack_size
;
345 unsigned char buf
[4];
346 int status
, movm_args
= 0;
349 /* Use the PC in the frame if it's provided to look up the
350 start of this function. */
351 pc
= (fi
? fi
->pc
: pc
);
353 /* Find the start of this function. */
354 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
356 /* Do nothing if we couldn't find the start of this function or if we're
357 stopped at the first instruction in the prologue. */
363 /* If we're in start, then give up. */
364 if (strcmp (name
, "start") == 0)
367 fi
->extra_info
->status
= NO_MORE_FRAMES
;
371 /* At the start of a function our frame is in the stack pointer. */
373 fi
->extra_info
->status
= MY_FRAME_IN_SP
;
375 /* Get the next two bytes into buf, we need two because rets is a two
376 byte insn and the first isn't enough to uniquely identify it. */
377 status
= read_memory_nobpt (pc
, buf
, 2);
381 /* If we're physically on an "rets" instruction, then our frame has
382 already been deallocated. Note this can also be true for retf
383 and ret if they specify a size of zero.
385 In this case fi->frame is bogus, we need to fix it. */
386 if (fi
&& buf
[0] == 0xf0 && buf
[1] == 0xfc)
388 if (fi
->next
== NULL
)
389 fi
->frame
= read_sp ();
393 /* Similarly if we're stopped on the first insn of a prologue as our
394 frame hasn't been allocated yet. */
395 if (fi
&& fi
->pc
== func_addr
)
397 if (fi
->next
== NULL
)
398 fi
->frame
= read_sp ();
402 /* Figure out where to stop scanning. */
403 stop
= fi
? fi
->pc
: func_end
;
405 /* Don't walk off the end of the function. */
406 stop
= stop
> func_end
? func_end
: stop
;
408 /* Start scanning on the first instruction of this function. */
411 /* Suck in two bytes. */
412 status
= read_memory_nobpt (addr
, buf
, 2);
415 fix_frame_pointer (fi
, 0);
419 /* First see if this insn sets the stack pointer; if so, it's something
420 we won't understand, so quit now. */
421 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
424 fi
->extra_info
->status
= NO_MORE_FRAMES
;
428 /* Now look for movm [regs],sp, which saves the callee saved registers.
430 At this time we don't know if fi->frame is valid, so we only note
431 that we encountered a movm instruction. Later, we'll set the entries
432 in fsr.regs as needed. */
435 /* Extract the register list for the movm instruction. */
436 status
= read_memory_nobpt (addr
+ 1, buf
, 1);
441 /* Quit now if we're beyond the stop point. */
444 /* Fix fi->frame since it's bogus at this point. */
445 if (fi
&& fi
->next
== NULL
)
446 fi
->frame
= read_sp ();
448 /* Note if/where callee saved registers were saved. */
449 set_movm_offsets (fi
, movm_args
);
453 /* Get the next two bytes so the prologue scan can continue. */
454 status
= read_memory_nobpt (addr
, buf
, 2);
457 /* Fix fi->frame since it's bogus at this point. */
458 if (fi
&& fi
->next
== NULL
)
459 fi
->frame
= read_sp ();
461 /* Note if/where callee saved registers were saved. */
462 set_movm_offsets (fi
, movm_args
);
467 /* Now see if we set up a frame pointer via "mov sp,a3" */
472 /* The frame pointer is now valid. */
475 fi
->extra_info
->status
|= MY_FRAME_IN_FP
;
476 fi
->extra_info
->status
&= ~MY_FRAME_IN_SP
;
479 /* Quit now if we're beyond the stop point. */
482 /* Fix fi->frame if it's bogus at this point. */
483 fix_frame_pointer (fi
, 0);
485 /* Note if/where callee saved registers were saved. */
486 set_movm_offsets (fi
, movm_args
);
490 /* Get two more bytes so scanning can continue. */
491 status
= read_memory_nobpt (addr
, buf
, 2);
494 /* Fix fi->frame if it's bogus at this point. */
495 fix_frame_pointer (fi
, 0);
497 /* Note if/where callee saved registers were saved. */
498 set_movm_offsets (fi
, movm_args
);
503 /* Next we should allocate the local frame. No more prologue insns
504 are found after allocating the local frame.
506 Search for add imm8,sp (0xf8feXX)
507 or add imm16,sp (0xfafeXXXX)
508 or add imm32,sp (0xfcfeXXXXXXXX).
510 If none of the above was found, then this prologue has no
513 status
= read_memory_nobpt (addr
, buf
, 2);
516 /* Fix fi->frame if it's bogus at this point. */
517 fix_frame_pointer (fi
, 0);
519 /* Note if/where callee saved registers were saved. */
520 set_movm_offsets (fi
, movm_args
);
525 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
527 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
529 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
534 /* Suck in imm_size more bytes, they'll hold the size of the
536 status
= read_memory_nobpt (addr
+ 2, buf
, imm_size
);
539 /* Fix fi->frame if it's bogus at this point. */
540 fix_frame_pointer (fi
, 0);
542 /* Note if/where callee saved registers were saved. */
543 set_movm_offsets (fi
, movm_args
);
547 /* Note the size of the stack in the frame info structure. */
548 stack_size
= extract_signed_integer (buf
, imm_size
);
550 fi
->extra_info
->stack_size
= stack_size
;
552 /* We just consumed 2 + imm_size bytes. */
553 addr
+= 2 + imm_size
;
555 /* No more prologue insns follow, so begin preparation to return. */
556 /* Fix fi->frame if it's bogus at this point. */
557 fix_frame_pointer (fi
, stack_size
);
559 /* Note if/where callee saved registers were saved. */
560 set_movm_offsets (fi
, movm_args
);
564 /* We never found an insn which allocates local stack space, regardless
565 this is the end of the prologue. */
566 /* Fix fi->frame if it's bogus at this point. */
567 fix_frame_pointer (fi
, 0);
569 /* Note if/where callee saved registers were saved. */
570 set_movm_offsets (fi
, movm_args
);
575 /* Function: saved_regs_size
576 Return the size in bytes of the register save area, based on the
577 saved_regs array in FI. */
579 saved_regs_size (struct frame_info
*fi
)
584 /* Reserve four bytes for every register saved. */
585 for (i
= 0; i
< NUM_REGS
; i
++)
586 if (fi
->saved_regs
[i
])
589 /* If we saved LIR, then it's most likely we used a `movm'
590 instruction with the `other' bit set, in which case the SP is
591 decremented by an extra four bytes, "to simplify calculation
592 of the transfer area", according to the processor manual. */
593 if (fi
->saved_regs
[LIR_REGNUM
])
600 /* Function: frame_chain
601 Figure out and return the caller's frame pointer given current
604 We don't handle dummy frames yet but we would probably just return the
605 stack pointer that was in use at the time the function call was made? */
608 mn10300_frame_chain (struct frame_info
*fi
)
610 struct frame_info
*dummy
;
611 /* Walk through the prologue to determine the stack size,
612 location of saved registers, end of the prologue, etc. */
613 if (fi
->extra_info
->status
== 0)
614 mn10300_analyze_prologue (fi
, (CORE_ADDR
) 0);
616 /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
617 if (fi
->extra_info
->status
& NO_MORE_FRAMES
)
620 /* Now that we've analyzed our prologue, determine the frame
621 pointer for our caller.
623 If our caller has a frame pointer, then we need to
624 find the entry value of $a3 to our function.
626 If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
627 location pointed to by fsr.regs[A3_REGNUM].
629 Else it's still in $a3.
631 If our caller does not have a frame pointer, then his
632 frame base is fi->frame + -caller's stack size. */
634 /* The easiest way to get that info is to analyze our caller's frame.
635 So we set up a dummy frame and call mn10300_analyze_prologue to
636 find stuff for us. */
637 dummy
= analyze_dummy_frame (FRAME_SAVED_PC (fi
), fi
->frame
);
639 if (dummy
->extra_info
->status
& MY_FRAME_IN_FP
)
641 /* Our caller has a frame pointer. So find the frame in $a3 or
643 if (fi
->saved_regs
[A3_REGNUM
])
644 return (read_memory_integer (fi
->saved_regs
[A3_REGNUM
], REGISTER_SIZE
));
646 return read_register (A3_REGNUM
);
650 int adjust
= saved_regs_size (fi
);
652 /* Our caller does not have a frame pointer. So his frame starts
653 at the base of our frame (fi->frame) + register save space
655 return fi
->frame
+ adjust
+ -dummy
->extra_info
->stack_size
;
659 /* Function: skip_prologue
660 Return the address of the first inst past the prologue of the function. */
663 mn10300_skip_prologue (CORE_ADDR pc
)
665 /* We used to check the debug symbols, but that can lose if
666 we have a null prologue. */
667 return mn10300_analyze_prologue (NULL
, pc
);
670 /* generic_pop_current_frame calls this function if the current
671 frame isn't a dummy frame. */
673 mn10300_pop_frame_regular (struct frame_info
*frame
)
677 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
679 /* Restore any saved registers. */
680 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
681 if (frame
->saved_regs
[regnum
] != 0)
685 value
= read_memory_unsigned_integer (frame
->saved_regs
[regnum
],
686 REGISTER_RAW_SIZE (regnum
));
687 write_register (regnum
, value
);
690 /* Actually cut back the stack. */
691 write_register (SP_REGNUM
, FRAME_FP (frame
));
693 /* Don't we need to set the PC?!? XXX FIXME. */
696 /* Function: pop_frame
697 This routine gets called when either the user uses the `return'
698 command, or the call dummy breakpoint gets hit. */
700 mn10300_pop_frame (void)
702 /* This function checks for and handles generic dummy frames, and
703 calls back to our function for ordinary frames. */
704 generic_pop_current_frame (mn10300_pop_frame_regular
);
706 /* Throw away any cached frame information. */
707 flush_cached_frames ();
710 /* Function: push_arguments
711 Setup arguments for a call to the target. Arguments go in
712 order on the stack. */
715 mn10300_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
716 int struct_return
, CORE_ADDR struct_addr
)
720 int stack_offset
= 0;
721 int regsused
= struct_return
? 1 : 0;
723 /* This should be a nop, but align the stack just in case something
724 went wrong. Stacks are four byte aligned on the mn10300. */
727 /* Now make space on the stack for the args.
729 XXX This doesn't appear to handle pass-by-invisible reference
731 for (argnum
= 0; argnum
< nargs
; argnum
++)
733 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3;
735 while (regsused
< 2 && arg_length
> 0)
743 /* Allocate stack space. */
746 regsused
= struct_return
? 1 : 0;
747 /* Push all arguments onto the stack. */
748 for (argnum
= 0; argnum
< nargs
; argnum
++)
753 /* XXX Check this. What about UNIONS? */
754 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
755 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
757 /* XXX Wrong, we want a pointer to this argument. */
758 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
759 val
= (char *) VALUE_CONTENTS (*args
);
763 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
764 val
= (char *) VALUE_CONTENTS (*args
);
767 while (regsused
< 2 && len
> 0)
769 write_register (regsused
, extract_unsigned_integer (val
, 4));
777 write_memory (sp
+ stack_offset
, val
, 4);
786 /* Make space for the flushback area. */
791 /* Function: push_return_address (pc)
792 Set up the return address for the inferior function call.
793 Needed for targets where we don't actually execute a JSR/BSR instruction */
796 mn10300_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
798 unsigned char buf
[4];
800 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
801 write_memory (sp
- 4, buf
, 4);
805 /* Function: store_struct_return (addr,sp)
806 Store the structure value return address for an inferior function
810 mn10300_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
812 /* The structure return address is passed as the first argument. */
813 write_register (0, addr
);
816 /* Function: frame_saved_pc
817 Find the caller of this frame. We do this by seeing if RP_REGNUM
818 is saved in the stack anywhere, otherwise we get it from the
819 registers. If the inner frame is a dummy frame, return its PC
820 instead of RP, because that's where "caller" of the dummy-frame
824 mn10300_frame_saved_pc (struct frame_info
*fi
)
826 int adjust
= saved_regs_size (fi
);
828 return (read_memory_integer (fi
->frame
+ adjust
, REGISTER_SIZE
));
831 /* Function: mn10300_init_extra_frame_info
832 Setup the frame's frame pointer, pc, and frame addresses for saved
833 registers. Most of the work is done in mn10300_analyze_prologue().
835 Note that when we are called for the last frame (currently active frame),
836 that fi->pc and fi->frame will already be setup. However, fi->frame will
837 be valid only if this routine uses FP. For previous frames, fi-frame will
838 always be correct. mn10300_analyze_prologue will fix fi->frame if
841 We can be called with the PC in the call dummy under two circumstances.
842 First, during normal backtracing, second, while figuring out the frame
843 pointer just prior to calling the target function (see run_stack_dummy). */
846 mn10300_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
849 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
851 frame_saved_regs_zalloc (fi
);
852 fi
->extra_info
= (struct frame_extra_info
*)
853 frame_obstack_alloc (sizeof (struct frame_extra_info
));
855 fi
->extra_info
->status
= 0;
856 fi
->extra_info
->stack_size
= 0;
858 mn10300_analyze_prologue (fi
, 0);
862 /* This function's job is handled by init_extra_frame_info. */
864 mn10300_frame_init_saved_regs (struct frame_info
*frame
)
869 /* Function: mn10300_virtual_frame_pointer
870 Return the register that the function uses for a frame pointer,
871 plus any necessary offset to be applied to the register before
872 any frame pointer offsets. */
875 mn10300_virtual_frame_pointer (CORE_ADDR pc
,
879 struct frame_info
*dummy
= analyze_dummy_frame (pc
, 0);
880 /* Set up a dummy frame_info, Analyze the prolog and fill in the
882 /* Results will tell us which type of frame it uses. */
883 if (dummy
->extra_info
->status
& MY_FRAME_IN_SP
)
886 *offset
= -(dummy
->extra_info
->stack_size
);
896 mn10300_reg_struct_has_addr (int gcc_p
, struct type
*type
)
898 return (TYPE_LENGTH (type
) > 8);
902 mn10300_register_virtual_type (int reg
)
904 return builtin_type_int
;
908 mn10300_register_byte (int reg
)
914 mn10300_register_virtual_size (int reg
)
920 mn10300_register_raw_size (int reg
)
925 /* If DWARF2 is a register number appearing in Dwarf2 debug info, then
926 mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
927 register number. Why don't Dwarf2 and GDB use the same numbering?
928 Who knows? But since people have object files lying around with
929 the existing Dwarf2 numbering, and other people have written stubs
930 to work with the existing GDB, neither of them can change. So we
931 just have to cope. */
933 mn10300_dwarf2_reg_to_regnum (int dwarf2
)
935 /* This table is supposed to be shaped like the REGISTER_NAMES
936 initializer in gcc/config/mn10300/mn10300.h. Registers which
937 appear in GCC's numbering, but have no counterpart in GDB's
938 world, are marked with a -1. */
939 static int dwarf2_to_gdb
[] = {
940 0, 1, 2, 3, 4, 5, 6, 7, -1, 8,
941 15, 16, 17, 18, 19, 20, 21, 22
946 || dwarf2
>= (sizeof (dwarf2_to_gdb
) / sizeof (dwarf2_to_gdb
[0]))
947 || dwarf2_to_gdb
[dwarf2
] == -1)
948 internal_error (__FILE__
, __LINE__
,
949 "bogus register number in debug info: %d", dwarf2
);
951 return dwarf2_to_gdb
[dwarf2
];
955 mn10300_print_register (const char *name
, int regnum
, int reg_width
)
957 char *raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
960 printf_filtered ("%*s: ", reg_width
, name
);
962 printf_filtered ("%s: ", name
);
965 if (read_relative_register_raw_bytes (regnum
, raw_buffer
))
967 printf_filtered ("[invalid]");
973 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
975 for (byte
= REGISTER_RAW_SIZE (regnum
) - REGISTER_VIRTUAL_SIZE (regnum
);
976 byte
< REGISTER_RAW_SIZE (regnum
);
978 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
982 for (byte
= REGISTER_VIRTUAL_SIZE (regnum
) - 1;
985 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
991 mn10300_do_registers_info (int regnum
, int fpregs
)
995 const char *name
= REGISTER_NAME (regnum
);
996 if (name
== NULL
|| name
[0] == '\0')
997 error ("Not a valid register for the current processor type");
998 mn10300_print_register (name
, regnum
, 0);
999 printf_filtered ("\n");
1003 /* print registers in an array 4x8 */
1006 const int nr_in_row
= 4;
1007 const int reg_width
= 4;
1008 for (r
= 0; r
< NUM_REGS
; r
+= nr_in_row
)
1013 for (c
= r
; c
< r
+ nr_in_row
; c
++)
1015 const char *name
= REGISTER_NAME (c
);
1016 if (name
!= NULL
&& *name
!= '\0')
1021 printf_filtered (" ");
1024 mn10300_print_register (name
, c
, reg_width
);
1025 printf_filtered (" ");
1029 padding
+= (reg_width
+ 2 + 8 + 1);
1033 printf_filtered ("\n");
1038 /* Dump out the mn10300 speciic architecture information. */
1041 mn10300_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1043 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1044 fprintf_unfiltered (file
, "mn10300_dump_tdep: am33_mode = %d\n",
1048 static struct gdbarch
*
1049 mn10300_gdbarch_init (struct gdbarch_info info
,
1050 struct gdbarch_list
*arches
)
1052 static LONGEST mn10300_call_dummy_words
[] = { 0 };
1053 struct gdbarch
*gdbarch
;
1054 struct gdbarch_tdep
*tdep
= NULL
;
1056 gdbarch_register_name_ftype
*register_name
;
1060 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1062 return arches
->gdbarch
;
1063 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1064 gdbarch
= gdbarch_alloc (&info
, tdep
);
1066 if (info
.bfd_arch_info
!= NULL
1067 && info
.bfd_arch_info
->arch
== bfd_arch_mn10300
)
1068 mach
= info
.bfd_arch_info
->mach
;
1074 case bfd_mach_mn10300
:
1076 register_name
= mn10300_generic_register_name
;
1081 register_name
= am33_register_name
;
1085 internal_error (__FILE__
, __LINE__
,
1086 "mn10300_gdbarch_init: Unknown mn10300 variant");
1087 return NULL
; /* keep GCC happy. */
1091 set_gdbarch_num_regs (gdbarch
, num_regs
);
1092 set_gdbarch_register_name (gdbarch
, register_name
);
1093 set_gdbarch_register_size (gdbarch
, 4);
1094 set_gdbarch_register_bytes (gdbarch
,
1095 num_regs
* gdbarch_register_size (gdbarch
));
1096 set_gdbarch_max_register_raw_size (gdbarch
, 4);
1097 set_gdbarch_register_raw_size (gdbarch
, mn10300_register_raw_size
);
1098 set_gdbarch_register_byte (gdbarch
, mn10300_register_byte
);
1099 set_gdbarch_max_register_virtual_size (gdbarch
, 4);
1100 set_gdbarch_register_virtual_size (gdbarch
, mn10300_register_virtual_size
);
1101 set_gdbarch_register_virtual_type (gdbarch
, mn10300_register_virtual_type
);
1102 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, mn10300_dwarf2_reg_to_regnum
);
1103 set_gdbarch_do_registers_info (gdbarch
, mn10300_do_registers_info
);
1104 set_gdbarch_sp_regnum (gdbarch
, 8);
1105 set_gdbarch_pc_regnum (gdbarch
, 9);
1106 set_gdbarch_fp_regnum (gdbarch
, 31);
1107 set_gdbarch_virtual_frame_pointer (gdbarch
, mn10300_virtual_frame_pointer
);
1110 set_gdbarch_breakpoint_from_pc (gdbarch
, mn10300_breakpoint_from_pc
);
1111 set_gdbarch_function_start_offset (gdbarch
, 0);
1112 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
1114 /* Stack unwinding. */
1115 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1116 set_gdbarch_frame_chain_valid (gdbarch
, generic_file_frame_chain_valid
);
1117 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1118 set_gdbarch_frame_chain_valid (gdbarch
, generic_file_frame_chain_valid
);
1119 set_gdbarch_saved_pc_after_call (gdbarch
, mn10300_saved_pc_after_call
);
1120 set_gdbarch_init_extra_frame_info (gdbarch
, mn10300_init_extra_frame_info
);
1121 set_gdbarch_init_frame_pc (gdbarch
, init_frame_pc_noop
);
1122 set_gdbarch_frame_init_saved_regs (gdbarch
, mn10300_frame_init_saved_regs
);
1123 set_gdbarch_frame_chain (gdbarch
, mn10300_frame_chain
);
1124 set_gdbarch_frame_saved_pc (gdbarch
, mn10300_frame_saved_pc
);
1125 set_gdbarch_extract_return_value (gdbarch
, mn10300_extract_return_value
);
1126 set_gdbarch_extract_struct_value_address
1127 (gdbarch
, mn10300_extract_struct_value_address
);
1128 set_gdbarch_store_return_value (gdbarch
, mn10300_store_return_value
);
1129 set_gdbarch_store_struct_return (gdbarch
, mn10300_store_struct_return
);
1130 set_gdbarch_pop_frame (gdbarch
, mn10300_pop_frame
);
1131 set_gdbarch_skip_prologue (gdbarch
, mn10300_skip_prologue
);
1132 set_gdbarch_frame_args_skip (gdbarch
, 0);
1133 set_gdbarch_frame_args_address (gdbarch
, default_frame_address
);
1134 set_gdbarch_frame_locals_address (gdbarch
, default_frame_address
);
1135 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1136 /* That's right, we're using the stack pointer as our frame pointer. */
1137 set_gdbarch_read_fp (gdbarch
, generic_target_read_sp
);
1139 /* Calling functions in the inferior from GDB. */
1140 set_gdbarch_call_dummy_p (gdbarch
, 1);
1141 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1142 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1143 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1144 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1145 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
1146 set_gdbarch_call_dummy_words (gdbarch
, mn10300_call_dummy_words
);
1147 set_gdbarch_sizeof_call_dummy_words (gdbarch
,
1148 sizeof (mn10300_call_dummy_words
));
1149 set_gdbarch_call_dummy_length (gdbarch
, 0);
1150 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1151 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1152 set_gdbarch_pc_in_call_dummy (gdbarch
, pc_in_call_dummy_at_entry_point
);
1153 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
1154 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1155 set_gdbarch_push_arguments (gdbarch
, mn10300_push_arguments
);
1156 set_gdbarch_reg_struct_has_addr (gdbarch
, mn10300_reg_struct_has_addr
);
1157 set_gdbarch_push_return_address (gdbarch
, mn10300_push_return_address
);
1158 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1159 set_gdbarch_use_struct_convention (gdbarch
, mn10300_use_struct_convention
);
1161 tdep
->am33_mode
= am33_mode
;
1167 _initialize_mn10300_tdep (void)
1169 /* printf("_initialize_mn10300_tdep\n"); */
1171 tm_print_insn
= print_insn_mn10300
;
1173 register_gdbarch_init (bfd_arch_mn10300
, mn10300_gdbarch_init
);