1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
3 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 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 deprecated_write_register_bytes (REGISTER_BYTE (4), valbuf
,
145 deprecated_write_register_bytes (REGISTER_BYTE (0), valbuf
,
149 static struct frame_info
*analyze_dummy_frame (CORE_ADDR
, CORE_ADDR
);
150 static struct frame_info
*
151 analyze_dummy_frame (CORE_ADDR pc
, CORE_ADDR frame
)
153 static struct frame_info
*dummy
= NULL
;
156 struct frame_extra_info
*extra_info
;
157 dummy
= deprecated_frame_xmalloc ();
158 dummy
->saved_regs
= xmalloc (SIZEOF_FRAME_SAVED_REGS
);
159 extra_info
= XMALLOC (struct frame_extra_info
);
160 deprecated_set_frame_extra_info_hack (dummy
, extra_info
);
162 deprecated_set_frame_next_hack (dummy
, NULL
);
163 deprecated_set_frame_prev_hack (dummy
, NULL
);
164 deprecated_update_frame_pc_hack (dummy
, pc
);
165 deprecated_update_frame_base_hack (dummy
, frame
);
166 get_frame_extra_info (dummy
)->status
= 0;
167 get_frame_extra_info (dummy
)->stack_size
= 0;
168 memset (get_frame_saved_regs (dummy
), '\000', SIZEOF_FRAME_SAVED_REGS
);
169 mn10300_analyze_prologue (dummy
, 0);
173 /* Values for frame_info.status */
175 #define MY_FRAME_IN_SP 0x1
176 #define MY_FRAME_IN_FP 0x2
177 #define NO_MORE_FRAMES 0x4
180 /* Should call_function allocate stack space for a struct return? */
182 mn10300_use_struct_convention (int gcc_p
, struct type
*type
)
184 return (TYPE_NFIELDS (type
) > 1 || TYPE_LENGTH (type
) > 8);
187 /* The breakpoint instruction must be the same size as the smallest
188 instruction in the instruction set.
190 The Matsushita mn10x00 processors have single byte instructions
191 so we need a single byte breakpoint. Matsushita hasn't defined
192 one, so we defined it ourselves. */
194 const static unsigned char *
195 mn10300_breakpoint_from_pc (CORE_ADDR
*bp_addr
, int *bp_size
)
197 static char breakpoint
[] =
204 /* Fix fi->frame if it's bogus at this point. This is a helper
205 function for mn10300_analyze_prologue. */
208 fix_frame_pointer (struct frame_info
*fi
, int stack_size
)
210 if (fi
&& get_next_frame (fi
) == NULL
)
212 if (get_frame_extra_info (fi
)->status
& MY_FRAME_IN_SP
)
213 deprecated_update_frame_base_hack (fi
, read_sp () - stack_size
);
214 else if (get_frame_extra_info (fi
)->status
& MY_FRAME_IN_FP
)
215 deprecated_update_frame_base_hack (fi
, read_register (A3_REGNUM
));
220 /* Set offsets of registers saved by movm instruction.
221 This is a helper function for mn10300_analyze_prologue. */
224 set_movm_offsets (struct frame_info
*fi
, int movm_args
)
228 if (fi
== NULL
|| movm_args
== 0)
231 if (movm_args
& movm_other_bit
)
233 /* The `other' bit leaves a blank area of four bytes at the
234 beginning of its block of saved registers, making it 32 bytes
236 get_frame_saved_regs (fi
)[LAR_REGNUM
] = get_frame_base (fi
) + offset
+ 4;
237 get_frame_saved_regs (fi
)[LIR_REGNUM
] = get_frame_base (fi
) + offset
+ 8;
238 get_frame_saved_regs (fi
)[MDR_REGNUM
] = get_frame_base (fi
) + offset
+ 12;
239 get_frame_saved_regs (fi
)[A0_REGNUM
+ 1] = get_frame_base (fi
) + offset
+ 16;
240 get_frame_saved_regs (fi
)[A0_REGNUM
] = get_frame_base (fi
) + offset
+ 20;
241 get_frame_saved_regs (fi
)[D0_REGNUM
+ 1] = get_frame_base (fi
) + offset
+ 24;
242 get_frame_saved_regs (fi
)[D0_REGNUM
] = get_frame_base (fi
) + offset
+ 28;
245 if (movm_args
& movm_a3_bit
)
247 get_frame_saved_regs (fi
)[A3_REGNUM
] = get_frame_base (fi
) + offset
;
250 if (movm_args
& movm_a2_bit
)
252 get_frame_saved_regs (fi
)[A2_REGNUM
] = get_frame_base (fi
) + offset
;
255 if (movm_args
& movm_d3_bit
)
257 get_frame_saved_regs (fi
)[D3_REGNUM
] = get_frame_base (fi
) + offset
;
260 if (movm_args
& movm_d2_bit
)
262 get_frame_saved_regs (fi
)[D2_REGNUM
] = get_frame_base (fi
) + offset
;
267 if (movm_args
& movm_exother_bit
)
269 get_frame_saved_regs (fi
)[MCVF_REGNUM
] = get_frame_base (fi
) + offset
;
270 get_frame_saved_regs (fi
)[MCRL_REGNUM
] = get_frame_base (fi
) + offset
+ 4;
271 get_frame_saved_regs (fi
)[MCRH_REGNUM
] = get_frame_base (fi
) + offset
+ 8;
272 get_frame_saved_regs (fi
)[MDRQ_REGNUM
] = get_frame_base (fi
) + offset
+ 12;
273 get_frame_saved_regs (fi
)[E0_REGNUM
+ 1] = get_frame_base (fi
) + offset
+ 16;
274 get_frame_saved_regs (fi
)[E0_REGNUM
+ 0] = get_frame_base (fi
) + offset
+ 20;
277 if (movm_args
& movm_exreg1_bit
)
279 get_frame_saved_regs (fi
)[E0_REGNUM
+ 7] = get_frame_base (fi
) + offset
;
280 get_frame_saved_regs (fi
)[E0_REGNUM
+ 6] = get_frame_base (fi
) + offset
+ 4;
281 get_frame_saved_regs (fi
)[E0_REGNUM
+ 5] = get_frame_base (fi
) + offset
+ 8;
282 get_frame_saved_regs (fi
)[E0_REGNUM
+ 4] = get_frame_base (fi
) + offset
+ 12;
285 if (movm_args
& movm_exreg0_bit
)
287 get_frame_saved_regs (fi
)[E0_REGNUM
+ 3] = get_frame_base (fi
) + offset
;
288 get_frame_saved_regs (fi
)[E0_REGNUM
+ 2] = get_frame_base (fi
) + offset
+ 4;
295 /* The main purpose of this file is dealing with prologues to extract
296 information about stack frames and saved registers.
298 In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
299 function is pretty readable, and has a nice explanation of how the
300 prologue is generated. The prologues generated by that code will
301 have the following form (NOTE: the current code doesn't handle all
304 + If this is an old-style varargs function, then its arguments
305 need to be flushed back to the stack:
310 + If we use any of the callee-saved registers, save them now.
312 movm [some callee-saved registers],(sp)
314 + If we have any floating-point registers to save:
316 - Decrement the stack pointer to reserve space for the registers.
317 If the function doesn't need a frame pointer, we may combine
318 this with the adjustment that reserves space for the frame.
322 - Save the floating-point registers. We have two possible
325 . Save them at fixed offset from the SP:
327 fmov fsN,(OFFSETN,sp)
328 fmov fsM,(OFFSETM,sp)
331 Note that, if OFFSETN happens to be zero, you'll get the
332 different opcode: fmov fsN,(sp)
334 . Or, set a0 to the start of the save area, and then use
335 post-increment addressing to save the FP registers.
343 + If the function needs a frame pointer, we set it here.
347 + Now we reserve space for the stack frame proper. This could be
348 merged into the `add -SIZE, sp' instruction for FP saves up
349 above, unless we needed to set the frame pointer in the previous
350 step, or the frame is so large that allocating the whole thing at
351 once would put the FP register save slots out of reach of the
352 addressing mode (128 bytes).
356 One day we might keep the stack pointer constant, that won't
357 change the code for prologues, but it will make the frame
358 pointerless case much more common. */
360 /* Analyze the prologue to determine where registers are saved,
361 the end of the prologue, etc etc. Return the end of the prologue
364 We store into FI (if non-null) several tidbits of information:
366 * stack_size -- size of this stack frame. Note that if we stop in
367 certain parts of the prologue/epilogue we may claim the size of the
368 current frame is zero. This happens when the current frame has
369 not been allocated yet or has already been deallocated.
371 * fsr -- Addresses of registers saved in the stack by this frame.
373 * status -- A (relatively) generic status indicator. It's a bitmask
374 with the following bits:
376 MY_FRAME_IN_SP: The base of the current frame is actually in
377 the stack pointer. This can happen for frame pointerless
378 functions, or cases where we're stopped in the prologue/epilogue
379 itself. For these cases mn10300_analyze_prologue will need up
380 update fi->frame before returning or analyzing the register
383 MY_FRAME_IN_FP: The base of the current frame is in the
384 frame pointer register ($a3).
386 NO_MORE_FRAMES: Set this if the current frame is "start" or
387 if the first instruction looks like mov <imm>,sp. This tells
388 frame chain to not bother trying to unwind past this frame. */
391 mn10300_analyze_prologue (struct frame_info
*fi
, CORE_ADDR pc
)
393 CORE_ADDR func_addr
, func_end
, addr
, stop
;
394 CORE_ADDR stack_size
;
396 unsigned char buf
[4];
397 int status
, movm_args
= 0;
400 /* Use the PC in the frame if it's provided to look up the
401 start of this function. */
402 pc
= (fi
? get_frame_pc (fi
) : pc
);
404 /* Find the start of this function. */
405 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
407 /* Do nothing if we couldn't find the start of this function or if we're
408 stopped at the first instruction in the prologue. */
414 /* If we're in start, then give up. */
415 if (strcmp (name
, "start") == 0)
418 get_frame_extra_info (fi
)->status
= NO_MORE_FRAMES
;
422 /* At the start of a function our frame is in the stack pointer. */
424 get_frame_extra_info (fi
)->status
= MY_FRAME_IN_SP
;
426 /* Get the next two bytes into buf, we need two because rets is a two
427 byte insn and the first isn't enough to uniquely identify it. */
428 status
= read_memory_nobpt (pc
, buf
, 2);
432 /* If we're physically on an "rets" instruction, then our frame has
433 already been deallocated. Note this can also be true for retf
434 and ret if they specify a size of zero.
436 In this case fi->frame is bogus, we need to fix it. */
437 if (fi
&& buf
[0] == 0xf0 && buf
[1] == 0xfc)
439 if (get_next_frame (fi
) == NULL
)
440 deprecated_update_frame_base_hack (fi
, read_sp ());
441 return get_frame_pc (fi
);
444 /* Similarly if we're stopped on the first insn of a prologue as our
445 frame hasn't been allocated yet. */
446 if (fi
&& get_frame_pc (fi
) == func_addr
)
448 if (get_next_frame (fi
) == NULL
)
449 deprecated_update_frame_base_hack (fi
, read_sp ());
450 return get_frame_pc (fi
);
453 /* Figure out where to stop scanning. */
454 stop
= fi
? get_frame_pc (fi
) : func_end
;
456 /* Don't walk off the end of the function. */
457 stop
= stop
> func_end
? func_end
: stop
;
459 /* Start scanning on the first instruction of this function. */
462 /* Suck in two bytes. */
463 status
= read_memory_nobpt (addr
, buf
, 2);
466 fix_frame_pointer (fi
, 0);
470 /* First see if this insn sets the stack pointer from a register; if
471 so, it's probably the initialization of the stack pointer in _start,
472 so mark this as the bottom-most frame. */
473 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
476 get_frame_extra_info (fi
)->status
= NO_MORE_FRAMES
;
480 /* Now look for movm [regs],sp, which saves the callee saved registers.
482 At this time we don't know if fi->frame is valid, so we only note
483 that we encountered a movm instruction. Later, we'll set the entries
484 in fsr.regs as needed. */
487 /* Extract the register list for the movm instruction. */
488 status
= read_memory_nobpt (addr
+ 1, buf
, 1);
493 /* Quit now if we're beyond the stop point. */
496 /* Fix fi->frame since it's bogus at this point. */
497 if (fi
&& get_next_frame (fi
) == NULL
)
498 deprecated_update_frame_base_hack (fi
, read_sp ());
500 /* Note if/where callee saved registers were saved. */
501 set_movm_offsets (fi
, movm_args
);
505 /* Get the next two bytes so the prologue scan can continue. */
506 status
= read_memory_nobpt (addr
, buf
, 2);
509 /* Fix fi->frame since it's bogus at this point. */
510 if (fi
&& get_next_frame (fi
) == NULL
)
511 deprecated_update_frame_base_hack (fi
, read_sp ());
513 /* Note if/where callee saved registers were saved. */
514 set_movm_offsets (fi
, movm_args
);
519 /* Now see if we set up a frame pointer via "mov sp,a3" */
524 /* The frame pointer is now valid. */
527 get_frame_extra_info (fi
)->status
|= MY_FRAME_IN_FP
;
528 get_frame_extra_info (fi
)->status
&= ~MY_FRAME_IN_SP
;
531 /* Quit now if we're beyond the stop point. */
534 /* Fix fi->frame if it's bogus at this point. */
535 fix_frame_pointer (fi
, 0);
537 /* Note if/where callee saved registers were saved. */
538 set_movm_offsets (fi
, movm_args
);
542 /* Get two more bytes so scanning can continue. */
543 status
= read_memory_nobpt (addr
, buf
, 2);
546 /* Fix fi->frame if it's bogus at this point. */
547 fix_frame_pointer (fi
, 0);
549 /* Note if/where callee saved registers were saved. */
550 set_movm_offsets (fi
, movm_args
);
555 /* Next we should allocate the local frame. No more prologue insns
556 are found after allocating the local frame.
558 Search for add imm8,sp (0xf8feXX)
559 or add imm16,sp (0xfafeXXXX)
560 or add imm32,sp (0xfcfeXXXXXXXX).
562 If none of the above was found, then this prologue has no
565 status
= read_memory_nobpt (addr
, buf
, 2);
568 /* Fix fi->frame if it's bogus at this point. */
569 fix_frame_pointer (fi
, 0);
571 /* Note if/where callee saved registers were saved. */
572 set_movm_offsets (fi
, movm_args
);
577 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
579 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
581 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
586 /* Suck in imm_size more bytes, they'll hold the size of the
588 status
= read_memory_nobpt (addr
+ 2, buf
, imm_size
);
591 /* Fix fi->frame if it's bogus at this point. */
592 fix_frame_pointer (fi
, 0);
594 /* Note if/where callee saved registers were saved. */
595 set_movm_offsets (fi
, movm_args
);
599 /* Note the size of the stack in the frame info structure. */
600 stack_size
= extract_signed_integer (buf
, imm_size
);
602 get_frame_extra_info (fi
)->stack_size
= stack_size
;
604 /* We just consumed 2 + imm_size bytes. */
605 addr
+= 2 + imm_size
;
607 /* No more prologue insns follow, so begin preparation to return. */
608 /* Fix fi->frame if it's bogus at this point. */
609 fix_frame_pointer (fi
, stack_size
);
611 /* Note if/where callee saved registers were saved. */
612 set_movm_offsets (fi
, movm_args
);
616 /* We never found an insn which allocates local stack space, regardless
617 this is the end of the prologue. */
618 /* Fix fi->frame if it's bogus at this point. */
619 fix_frame_pointer (fi
, 0);
621 /* Note if/where callee saved registers were saved. */
622 set_movm_offsets (fi
, movm_args
);
627 /* Function: saved_regs_size
628 Return the size in bytes of the register save area, based on the
629 saved_regs array in FI. */
631 saved_regs_size (struct frame_info
*fi
)
636 /* Reserve four bytes for every register saved. */
637 for (i
= 0; i
< NUM_REGS
; i
++)
638 if (get_frame_saved_regs (fi
)[i
])
641 /* If we saved LIR, then it's most likely we used a `movm'
642 instruction with the `other' bit set, in which case the SP is
643 decremented by an extra four bytes, "to simplify calculation
644 of the transfer area", according to the processor manual. */
645 if (get_frame_saved_regs (fi
)[LIR_REGNUM
])
652 /* Function: frame_chain
653 Figure out and return the caller's frame pointer given current
656 We don't handle dummy frames yet but we would probably just return the
657 stack pointer that was in use at the time the function call was made? */
660 mn10300_frame_chain (struct frame_info
*fi
)
662 struct frame_info
*dummy
;
663 /* Walk through the prologue to determine the stack size,
664 location of saved registers, end of the prologue, etc. */
665 if (get_frame_extra_info (fi
)->status
== 0)
666 mn10300_analyze_prologue (fi
, (CORE_ADDR
) 0);
668 /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
669 if (get_frame_extra_info (fi
)->status
& NO_MORE_FRAMES
)
672 /* Now that we've analyzed our prologue, determine the frame
673 pointer for our caller.
675 If our caller has a frame pointer, then we need to
676 find the entry value of $a3 to our function.
678 If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
679 location pointed to by fsr.regs[A3_REGNUM].
681 Else it's still in $a3.
683 If our caller does not have a frame pointer, then his
684 frame base is fi->frame + -caller's stack size. */
686 /* The easiest way to get that info is to analyze our caller's frame.
687 So we set up a dummy frame and call mn10300_analyze_prologue to
688 find stuff for us. */
689 dummy
= analyze_dummy_frame (FRAME_SAVED_PC (fi
), get_frame_base (fi
));
691 if (get_frame_extra_info (dummy
)->status
& MY_FRAME_IN_FP
)
693 /* Our caller has a frame pointer. So find the frame in $a3 or
695 if (get_frame_saved_regs (fi
)[A3_REGNUM
])
696 return (read_memory_integer (get_frame_saved_regs (fi
)[A3_REGNUM
], REGISTER_SIZE
));
698 return read_register (A3_REGNUM
);
702 int adjust
= saved_regs_size (fi
);
704 /* Our caller does not have a frame pointer. So his frame starts
705 at the base of our frame (fi->frame) + register save space
707 return get_frame_base (fi
) + adjust
+ -get_frame_extra_info (dummy
)->stack_size
;
711 /* Function: skip_prologue
712 Return the address of the first inst past the prologue of the function. */
715 mn10300_skip_prologue (CORE_ADDR pc
)
717 /* We used to check the debug symbols, but that can lose if
718 we have a null prologue. */
719 return mn10300_analyze_prologue (NULL
, pc
);
722 /* generic_pop_current_frame calls this function if the current
723 frame isn't a dummy frame. */
725 mn10300_pop_frame_regular (struct frame_info
*frame
)
729 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
731 /* Restore any saved registers. */
732 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
733 if (get_frame_saved_regs (frame
)[regnum
] != 0)
737 value
= read_memory_unsigned_integer (get_frame_saved_regs (frame
)[regnum
],
738 REGISTER_RAW_SIZE (regnum
));
739 write_register (regnum
, value
);
742 /* Actually cut back the stack. */
743 write_register (SP_REGNUM
, get_frame_base (frame
));
745 /* Don't we need to set the PC?!? XXX FIXME. */
748 /* Function: pop_frame
749 This routine gets called when either the user uses the `return'
750 command, or the call dummy breakpoint gets hit. */
752 mn10300_pop_frame (void)
754 /* This function checks for and handles generic dummy frames, and
755 calls back to our function for ordinary frames. */
756 generic_pop_current_frame (mn10300_pop_frame_regular
);
758 /* Throw away any cached frame information. */
759 flush_cached_frames ();
762 /* Function: push_arguments
763 Setup arguments for a call to the target. Arguments go in
764 order on the stack. */
767 mn10300_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
768 int struct_return
, CORE_ADDR struct_addr
)
772 int stack_offset
= 0;
773 int regsused
= struct_return
? 1 : 0;
775 /* This should be a nop, but align the stack just in case something
776 went wrong. Stacks are four byte aligned on the mn10300. */
779 /* Now make space on the stack for the args.
781 XXX This doesn't appear to handle pass-by-invisible reference
783 for (argnum
= 0; argnum
< nargs
; argnum
++)
785 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3;
787 while (regsused
< 2 && arg_length
> 0)
795 /* Allocate stack space. */
798 regsused
= struct_return
? 1 : 0;
799 /* Push all arguments onto the stack. */
800 for (argnum
= 0; argnum
< nargs
; argnum
++)
805 /* XXX Check this. What about UNIONS? */
806 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
807 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
809 /* XXX Wrong, we want a pointer to this argument. */
810 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
811 val
= (char *) VALUE_CONTENTS (*args
);
815 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
816 val
= (char *) VALUE_CONTENTS (*args
);
819 while (regsused
< 2 && len
> 0)
821 write_register (regsused
, extract_unsigned_integer (val
, 4));
829 write_memory (sp
+ stack_offset
, val
, 4);
838 /* Make space for the flushback area. */
843 /* Function: push_return_address (pc)
844 Set up the return address for the inferior function call.
845 Needed for targets where we don't actually execute a JSR/BSR instruction */
848 mn10300_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
850 unsigned char buf
[4];
852 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
853 write_memory (sp
- 4, buf
, 4);
857 /* Function: store_struct_return (addr,sp)
858 Store the structure value return address for an inferior function
862 mn10300_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
864 /* The structure return address is passed as the first argument. */
865 write_register (0, addr
);
868 /* Function: frame_saved_pc
869 Find the caller of this frame. We do this by seeing if RP_REGNUM
870 is saved in the stack anywhere, otherwise we get it from the
871 registers. If the inner frame is a dummy frame, return its PC
872 instead of RP, because that's where "caller" of the dummy-frame
876 mn10300_frame_saved_pc (struct frame_info
*fi
)
878 int adjust
= saved_regs_size (fi
);
880 return (read_memory_integer (get_frame_base (fi
) + adjust
, REGISTER_SIZE
));
883 /* Function: mn10300_init_extra_frame_info
884 Setup the frame's frame pointer, pc, and frame addresses for saved
885 registers. Most of the work is done in mn10300_analyze_prologue().
887 Note that when we are called for the last frame (currently active frame),
888 that get_frame_pc (fi) and fi->frame will already be setup. However, fi->frame will
889 be valid only if this routine uses FP. For previous frames, fi-frame will
890 always be correct. mn10300_analyze_prologue will fix fi->frame if
893 We can be called with the PC in the call dummy under two circumstances.
894 First, during normal backtracing, second, while figuring out the frame
895 pointer just prior to calling the target function (see run_stack_dummy). */
898 mn10300_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
900 if (get_next_frame (fi
))
901 deprecated_update_frame_pc_hack (fi
, FRAME_SAVED_PC (get_next_frame (fi
)));
903 frame_saved_regs_zalloc (fi
);
904 frame_extra_info_zalloc (fi
, sizeof (struct frame_extra_info
));
906 get_frame_extra_info (fi
)->status
= 0;
907 get_frame_extra_info (fi
)->stack_size
= 0;
909 mn10300_analyze_prologue (fi
, 0);
913 /* This function's job is handled by init_extra_frame_info. */
915 mn10300_frame_init_saved_regs (struct frame_info
*frame
)
920 /* Function: mn10300_virtual_frame_pointer
921 Return the register that the function uses for a frame pointer,
922 plus any necessary offset to be applied to the register before
923 any frame pointer offsets. */
926 mn10300_virtual_frame_pointer (CORE_ADDR pc
,
930 struct frame_info
*dummy
= analyze_dummy_frame (pc
, 0);
931 /* Set up a dummy frame_info, Analyze the prolog and fill in the
933 /* Results will tell us which type of frame it uses. */
934 if (get_frame_extra_info (dummy
)->status
& MY_FRAME_IN_SP
)
937 *offset
= -(get_frame_extra_info (dummy
)->stack_size
);
947 mn10300_reg_struct_has_addr (int gcc_p
, struct type
*type
)
949 return (TYPE_LENGTH (type
) > 8);
953 mn10300_register_virtual_type (int reg
)
955 return builtin_type_int
;
959 mn10300_register_byte (int reg
)
965 mn10300_register_virtual_size (int reg
)
971 mn10300_register_raw_size (int reg
)
976 /* If DWARF2 is a register number appearing in Dwarf2 debug info, then
977 mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
978 register number. Why don't Dwarf2 and GDB use the same numbering?
979 Who knows? But since people have object files lying around with
980 the existing Dwarf2 numbering, and other people have written stubs
981 to work with the existing GDB, neither of them can change. So we
982 just have to cope. */
984 mn10300_dwarf2_reg_to_regnum (int dwarf2
)
986 /* This table is supposed to be shaped like the REGISTER_NAMES
987 initializer in gcc/config/mn10300/mn10300.h. Registers which
988 appear in GCC's numbering, but have no counterpart in GDB's
989 world, are marked with a -1. */
990 static int dwarf2_to_gdb
[] = {
991 0, 1, 2, 3, 4, 5, 6, 7, -1, 8,
992 15, 16, 17, 18, 19, 20, 21, 22
997 || dwarf2
>= (sizeof (dwarf2_to_gdb
) / sizeof (dwarf2_to_gdb
[0]))
998 || dwarf2_to_gdb
[dwarf2
] == -1)
999 internal_error (__FILE__
, __LINE__
,
1000 "bogus register number in debug info: %d", dwarf2
);
1002 return dwarf2_to_gdb
[dwarf2
];
1006 mn10300_print_register (const char *name
, int regnum
, int reg_width
)
1008 char *raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
1011 printf_filtered ("%*s: ", reg_width
, name
);
1013 printf_filtered ("%s: ", name
);
1016 if (!frame_register_read (deprecated_selected_frame
, regnum
, raw_buffer
))
1018 printf_filtered ("[invalid]");
1024 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
1026 for (byte
= REGISTER_RAW_SIZE (regnum
) - REGISTER_VIRTUAL_SIZE (regnum
);
1027 byte
< REGISTER_RAW_SIZE (regnum
);
1029 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
1033 for (byte
= REGISTER_VIRTUAL_SIZE (regnum
) - 1;
1036 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
1042 mn10300_do_registers_info (int regnum
, int fpregs
)
1046 const char *name
= REGISTER_NAME (regnum
);
1047 if (name
== NULL
|| name
[0] == '\0')
1048 error ("Not a valid register for the current processor type");
1049 mn10300_print_register (name
, regnum
, 0);
1050 printf_filtered ("\n");
1054 /* print registers in an array 4x8 */
1057 const int nr_in_row
= 4;
1058 const int reg_width
= 4;
1059 for (r
= 0; r
< NUM_REGS
; r
+= nr_in_row
)
1064 for (c
= r
; c
< r
+ nr_in_row
; c
++)
1066 const char *name
= REGISTER_NAME (c
);
1067 if (name
!= NULL
&& *name
!= '\0')
1072 printf_filtered (" ");
1075 mn10300_print_register (name
, c
, reg_width
);
1076 printf_filtered (" ");
1080 padding
+= (reg_width
+ 2 + 8 + 1);
1084 printf_filtered ("\n");
1089 /* Dump out the mn10300 speciic architecture information. */
1092 mn10300_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1094 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1095 fprintf_unfiltered (file
, "mn10300_dump_tdep: am33_mode = %d\n",
1099 static struct gdbarch
*
1100 mn10300_gdbarch_init (struct gdbarch_info info
,
1101 struct gdbarch_list
*arches
)
1103 static LONGEST mn10300_call_dummy_words
[] = { 0 };
1104 struct gdbarch
*gdbarch
;
1105 struct gdbarch_tdep
*tdep
= NULL
;
1107 gdbarch_register_name_ftype
*register_name
;
1111 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1113 return arches
->gdbarch
;
1114 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1115 gdbarch
= gdbarch_alloc (&info
, tdep
);
1117 if (info
.bfd_arch_info
!= NULL
1118 && info
.bfd_arch_info
->arch
== bfd_arch_mn10300
)
1119 mach
= info
.bfd_arch_info
->mach
;
1125 case bfd_mach_mn10300
:
1127 register_name
= mn10300_generic_register_name
;
1132 register_name
= am33_register_name
;
1136 internal_error (__FILE__
, __LINE__
,
1137 "mn10300_gdbarch_init: Unknown mn10300 variant");
1138 return NULL
; /* keep GCC happy. */
1142 set_gdbarch_num_regs (gdbarch
, num_regs
);
1143 set_gdbarch_register_name (gdbarch
, register_name
);
1144 set_gdbarch_register_size (gdbarch
, 4);
1145 set_gdbarch_register_bytes (gdbarch
,
1146 num_regs
* gdbarch_register_size (gdbarch
));
1147 set_gdbarch_max_register_raw_size (gdbarch
, 4);
1148 set_gdbarch_register_raw_size (gdbarch
, mn10300_register_raw_size
);
1149 set_gdbarch_register_byte (gdbarch
, mn10300_register_byte
);
1150 set_gdbarch_max_register_virtual_size (gdbarch
, 4);
1151 set_gdbarch_register_virtual_size (gdbarch
, mn10300_register_virtual_size
);
1152 set_gdbarch_register_virtual_type (gdbarch
, mn10300_register_virtual_type
);
1153 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, mn10300_dwarf2_reg_to_regnum
);
1154 set_gdbarch_deprecated_do_registers_info (gdbarch
, mn10300_do_registers_info
);
1155 set_gdbarch_sp_regnum (gdbarch
, 8);
1156 set_gdbarch_pc_regnum (gdbarch
, 9);
1157 set_gdbarch_fp_regnum (gdbarch
, 31);
1158 set_gdbarch_virtual_frame_pointer (gdbarch
, mn10300_virtual_frame_pointer
);
1161 set_gdbarch_breakpoint_from_pc (gdbarch
, mn10300_breakpoint_from_pc
);
1162 set_gdbarch_function_start_offset (gdbarch
, 0);
1163 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
1165 /* Stack unwinding. */
1166 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1167 set_gdbarch_saved_pc_after_call (gdbarch
, mn10300_saved_pc_after_call
);
1168 set_gdbarch_init_extra_frame_info (gdbarch
, mn10300_init_extra_frame_info
);
1169 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_noop
);
1170 set_gdbarch_frame_init_saved_regs (gdbarch
, mn10300_frame_init_saved_regs
);
1171 set_gdbarch_frame_chain (gdbarch
, mn10300_frame_chain
);
1172 set_gdbarch_frame_saved_pc (gdbarch
, mn10300_frame_saved_pc
);
1173 set_gdbarch_deprecated_extract_return_value (gdbarch
, mn10300_extract_return_value
);
1174 set_gdbarch_deprecated_extract_struct_value_address
1175 (gdbarch
, mn10300_extract_struct_value_address
);
1176 set_gdbarch_deprecated_store_return_value (gdbarch
, mn10300_store_return_value
);
1177 set_gdbarch_store_struct_return (gdbarch
, mn10300_store_struct_return
);
1178 set_gdbarch_pop_frame (gdbarch
, mn10300_pop_frame
);
1179 set_gdbarch_skip_prologue (gdbarch
, mn10300_skip_prologue
);
1180 set_gdbarch_frame_args_skip (gdbarch
, 0);
1181 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1182 /* That's right, we're using the stack pointer as our frame pointer. */
1183 set_gdbarch_read_fp (gdbarch
, generic_target_read_sp
);
1185 /* Calling functions in the inferior from GDB. */
1186 set_gdbarch_call_dummy_p (gdbarch
, 1);
1187 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1188 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1189 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1190 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
1191 set_gdbarch_call_dummy_words (gdbarch
, mn10300_call_dummy_words
);
1192 set_gdbarch_sizeof_call_dummy_words (gdbarch
,
1193 sizeof (mn10300_call_dummy_words
));
1194 set_gdbarch_call_dummy_length (gdbarch
, 0);
1195 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1196 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1197 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
1198 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1199 set_gdbarch_push_arguments (gdbarch
, mn10300_push_arguments
);
1200 set_gdbarch_reg_struct_has_addr (gdbarch
, mn10300_reg_struct_has_addr
);
1201 set_gdbarch_push_return_address (gdbarch
, mn10300_push_return_address
);
1202 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1203 set_gdbarch_use_struct_convention (gdbarch
, mn10300_use_struct_convention
);
1205 tdep
->am33_mode
= am33_mode
;
1211 _initialize_mn10300_tdep (void)
1213 /* printf("_initialize_mn10300_tdep\n"); */
1215 tm_print_insn
= print_insn_mn10300
;
1217 register_gdbarch_init (bfd_arch_mn10300
, mn10300_gdbarch_init
);