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"
34 #include "gdb_assert.h"
46 #define MDRQ_REGNUM 14
48 #define MCRH_REGNUM 26
49 #define MCRL_REGNUM 27
50 #define MCVF_REGNUM 28
52 enum movm_register_bits
{
53 movm_exother_bit
= 0x01,
54 movm_exreg1_bit
= 0x02,
55 movm_exreg0_bit
= 0x04,
56 movm_other_bit
= 0x08,
63 extern void _initialize_mn10300_tdep (void);
64 static CORE_ADDR
mn10300_analyze_prologue (struct frame_info
*fi
,
67 /* mn10300 private data */
71 #define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode)
74 /* Additional info used by the frame */
76 struct frame_extra_info
84 register_name (int reg
, char **regs
, long sizeof_regs
)
86 if (reg
< 0 || reg
>= sizeof_regs
/ sizeof (regs
[0]))
93 mn10300_generic_register_name (int reg
)
96 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
97 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
98 "", "", "", "", "", "", "", "",
99 "", "", "", "", "", "", "", "fp"
101 return register_name (reg
, regs
, sizeof regs
);
106 am33_register_name (int reg
)
108 static char *regs
[] =
109 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
110 "sp", "pc", "mdr", "psw", "lir", "lar", "",
111 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
112 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
114 return register_name (reg
, regs
, sizeof regs
);
118 mn10300_saved_pc_after_call (struct frame_info
*fi
)
120 return read_memory_integer (read_register (SP_REGNUM
), 4);
124 mn10300_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
126 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
127 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (4), TYPE_LENGTH (type
));
129 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), TYPE_LENGTH (type
));
133 mn10300_extract_struct_value_address (char *regbuf
)
135 return extract_unsigned_integer (regbuf
+ REGISTER_BYTE (4),
136 REGISTER_RAW_SIZE (4));
140 mn10300_store_return_value (struct type
*type
, char *valbuf
)
142 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
143 deprecated_write_register_bytes (REGISTER_BYTE (4), valbuf
,
146 deprecated_write_register_bytes (REGISTER_BYTE (0), valbuf
,
150 static struct frame_info
*analyze_dummy_frame (CORE_ADDR
, CORE_ADDR
);
151 static struct frame_info
*
152 analyze_dummy_frame (CORE_ADDR pc
, CORE_ADDR frame
)
154 static struct frame_info
*dummy
= NULL
;
157 struct frame_extra_info
*extra_info
;
158 CORE_ADDR
*saved_regs
;
159 dummy
= deprecated_frame_xmalloc ();
160 saved_regs
= xmalloc (SIZEOF_FRAME_SAVED_REGS
);
161 deprecated_set_frame_saved_regs_hack (dummy
, saved_regs
);
162 extra_info
= XMALLOC (struct frame_extra_info
);
163 deprecated_set_frame_extra_info_hack (dummy
, extra_info
);
165 deprecated_set_frame_next_hack (dummy
, NULL
);
166 deprecated_set_frame_prev_hack (dummy
, NULL
);
167 deprecated_update_frame_pc_hack (dummy
, pc
);
168 deprecated_update_frame_base_hack (dummy
, frame
);
169 get_frame_extra_info (dummy
)->status
= 0;
170 get_frame_extra_info (dummy
)->stack_size
= 0;
171 memset (get_frame_saved_regs (dummy
), '\000', SIZEOF_FRAME_SAVED_REGS
);
172 mn10300_analyze_prologue (dummy
, 0);
176 /* Values for frame_info.status */
178 #define MY_FRAME_IN_SP 0x1
179 #define MY_FRAME_IN_FP 0x2
180 #define NO_MORE_FRAMES 0x4
183 /* Should call_function allocate stack space for a struct return? */
185 mn10300_use_struct_convention (int gcc_p
, struct type
*type
)
187 return (TYPE_NFIELDS (type
) > 1 || TYPE_LENGTH (type
) > 8);
190 /* The breakpoint instruction must be the same size as the smallest
191 instruction in the instruction set.
193 The Matsushita mn10x00 processors have single byte instructions
194 so we need a single byte breakpoint. Matsushita hasn't defined
195 one, so we defined it ourselves. */
197 const static unsigned char *
198 mn10300_breakpoint_from_pc (CORE_ADDR
*bp_addr
, int *bp_size
)
200 static char breakpoint
[] =
207 /* Fix fi->frame if it's bogus at this point. This is a helper
208 function for mn10300_analyze_prologue. */
211 fix_frame_pointer (struct frame_info
*fi
, int stack_size
)
213 if (fi
&& get_next_frame (fi
) == NULL
)
215 if (get_frame_extra_info (fi
)->status
& MY_FRAME_IN_SP
)
216 deprecated_update_frame_base_hack (fi
, read_sp () - stack_size
);
217 else if (get_frame_extra_info (fi
)->status
& MY_FRAME_IN_FP
)
218 deprecated_update_frame_base_hack (fi
, read_register (A3_REGNUM
));
223 /* Set offsets of registers saved by movm instruction.
224 This is a helper function for mn10300_analyze_prologue. */
227 set_movm_offsets (struct frame_info
*fi
, int movm_args
)
231 if (fi
== NULL
|| movm_args
== 0)
234 if (movm_args
& movm_other_bit
)
236 /* The `other' bit leaves a blank area of four bytes at the
237 beginning of its block of saved registers, making it 32 bytes
239 get_frame_saved_regs (fi
)[LAR_REGNUM
] = get_frame_base (fi
) + offset
+ 4;
240 get_frame_saved_regs (fi
)[LIR_REGNUM
] = get_frame_base (fi
) + offset
+ 8;
241 get_frame_saved_regs (fi
)[MDR_REGNUM
] = get_frame_base (fi
) + offset
+ 12;
242 get_frame_saved_regs (fi
)[A0_REGNUM
+ 1] = get_frame_base (fi
) + offset
+ 16;
243 get_frame_saved_regs (fi
)[A0_REGNUM
] = get_frame_base (fi
) + offset
+ 20;
244 get_frame_saved_regs (fi
)[D0_REGNUM
+ 1] = get_frame_base (fi
) + offset
+ 24;
245 get_frame_saved_regs (fi
)[D0_REGNUM
] = get_frame_base (fi
) + offset
+ 28;
248 if (movm_args
& movm_a3_bit
)
250 get_frame_saved_regs (fi
)[A3_REGNUM
] = get_frame_base (fi
) + offset
;
253 if (movm_args
& movm_a2_bit
)
255 get_frame_saved_regs (fi
)[A2_REGNUM
] = get_frame_base (fi
) + offset
;
258 if (movm_args
& movm_d3_bit
)
260 get_frame_saved_regs (fi
)[D3_REGNUM
] = get_frame_base (fi
) + offset
;
263 if (movm_args
& movm_d2_bit
)
265 get_frame_saved_regs (fi
)[D2_REGNUM
] = get_frame_base (fi
) + offset
;
270 if (movm_args
& movm_exother_bit
)
272 get_frame_saved_regs (fi
)[MCVF_REGNUM
] = get_frame_base (fi
) + offset
;
273 get_frame_saved_regs (fi
)[MCRL_REGNUM
] = get_frame_base (fi
) + offset
+ 4;
274 get_frame_saved_regs (fi
)[MCRH_REGNUM
] = get_frame_base (fi
) + offset
+ 8;
275 get_frame_saved_regs (fi
)[MDRQ_REGNUM
] = get_frame_base (fi
) + offset
+ 12;
276 get_frame_saved_regs (fi
)[E0_REGNUM
+ 1] = get_frame_base (fi
) + offset
+ 16;
277 get_frame_saved_regs (fi
)[E0_REGNUM
+ 0] = get_frame_base (fi
) + offset
+ 20;
280 if (movm_args
& movm_exreg1_bit
)
282 get_frame_saved_regs (fi
)[E0_REGNUM
+ 7] = get_frame_base (fi
) + offset
;
283 get_frame_saved_regs (fi
)[E0_REGNUM
+ 6] = get_frame_base (fi
) + offset
+ 4;
284 get_frame_saved_regs (fi
)[E0_REGNUM
+ 5] = get_frame_base (fi
) + offset
+ 8;
285 get_frame_saved_regs (fi
)[E0_REGNUM
+ 4] = get_frame_base (fi
) + offset
+ 12;
288 if (movm_args
& movm_exreg0_bit
)
290 get_frame_saved_regs (fi
)[E0_REGNUM
+ 3] = get_frame_base (fi
) + offset
;
291 get_frame_saved_regs (fi
)[E0_REGNUM
+ 2] = get_frame_base (fi
) + offset
+ 4;
298 /* The main purpose of this file is dealing with prologues to extract
299 information about stack frames and saved registers.
301 In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
302 function is pretty readable, and has a nice explanation of how the
303 prologue is generated. The prologues generated by that code will
304 have the following form (NOTE: the current code doesn't handle all
307 + If this is an old-style varargs function, then its arguments
308 need to be flushed back to the stack:
313 + If we use any of the callee-saved registers, save them now.
315 movm [some callee-saved registers],(sp)
317 + If we have any floating-point registers to save:
319 - Decrement the stack pointer to reserve space for the registers.
320 If the function doesn't need a frame pointer, we may combine
321 this with the adjustment that reserves space for the frame.
325 - Save the floating-point registers. We have two possible
328 . Save them at fixed offset from the SP:
330 fmov fsN,(OFFSETN,sp)
331 fmov fsM,(OFFSETM,sp)
334 Note that, if OFFSETN happens to be zero, you'll get the
335 different opcode: fmov fsN,(sp)
337 . Or, set a0 to the start of the save area, and then use
338 post-increment addressing to save the FP registers.
346 + If the function needs a frame pointer, we set it here.
350 + Now we reserve space for the stack frame proper. This could be
351 merged into the `add -SIZE, sp' instruction for FP saves up
352 above, unless we needed to set the frame pointer in the previous
353 step, or the frame is so large that allocating the whole thing at
354 once would put the FP register save slots out of reach of the
355 addressing mode (128 bytes).
359 One day we might keep the stack pointer constant, that won't
360 change the code for prologues, but it will make the frame
361 pointerless case much more common. */
363 /* Analyze the prologue to determine where registers are saved,
364 the end of the prologue, etc etc. Return the end of the prologue
367 We store into FI (if non-null) several tidbits of information:
369 * stack_size -- size of this stack frame. Note that if we stop in
370 certain parts of the prologue/epilogue we may claim the size of the
371 current frame is zero. This happens when the current frame has
372 not been allocated yet or has already been deallocated.
374 * fsr -- Addresses of registers saved in the stack by this frame.
376 * status -- A (relatively) generic status indicator. It's a bitmask
377 with the following bits:
379 MY_FRAME_IN_SP: The base of the current frame is actually in
380 the stack pointer. This can happen for frame pointerless
381 functions, or cases where we're stopped in the prologue/epilogue
382 itself. For these cases mn10300_analyze_prologue will need up
383 update fi->frame before returning or analyzing the register
386 MY_FRAME_IN_FP: The base of the current frame is in the
387 frame pointer register ($a3).
389 NO_MORE_FRAMES: Set this if the current frame is "start" or
390 if the first instruction looks like mov <imm>,sp. This tells
391 frame chain to not bother trying to unwind past this frame. */
394 mn10300_analyze_prologue (struct frame_info
*fi
, CORE_ADDR pc
)
396 CORE_ADDR func_addr
, func_end
, addr
, stop
;
397 CORE_ADDR stack_size
;
399 unsigned char buf
[4];
400 int status
, movm_args
= 0;
403 /* Use the PC in the frame if it's provided to look up the
404 start of this function. */
405 pc
= (fi
? get_frame_pc (fi
) : pc
);
407 /* Find the start of this function. */
408 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
410 /* Do nothing if we couldn't find the start of this function or if we're
411 stopped at the first instruction in the prologue. */
417 /* If we're in start, then give up. */
418 if (strcmp (name
, "start") == 0)
421 get_frame_extra_info (fi
)->status
= NO_MORE_FRAMES
;
425 /* At the start of a function our frame is in the stack pointer. */
427 get_frame_extra_info (fi
)->status
= MY_FRAME_IN_SP
;
429 /* Get the next two bytes into buf, we need two because rets is a two
430 byte insn and the first isn't enough to uniquely identify it. */
431 status
= read_memory_nobpt (pc
, buf
, 2);
435 /* If we're physically on an "rets" instruction, then our frame has
436 already been deallocated. Note this can also be true for retf
437 and ret if they specify a size of zero.
439 In this case fi->frame is bogus, we need to fix it. */
440 if (fi
&& buf
[0] == 0xf0 && buf
[1] == 0xfc)
442 if (get_next_frame (fi
) == NULL
)
443 deprecated_update_frame_base_hack (fi
, read_sp ());
444 return get_frame_pc (fi
);
447 /* Similarly if we're stopped on the first insn of a prologue as our
448 frame hasn't been allocated yet. */
449 if (fi
&& get_frame_pc (fi
) == func_addr
)
451 if (get_next_frame (fi
) == NULL
)
452 deprecated_update_frame_base_hack (fi
, read_sp ());
453 return get_frame_pc (fi
);
456 /* Figure out where to stop scanning. */
457 stop
= fi
? get_frame_pc (fi
) : func_end
;
459 /* Don't walk off the end of the function. */
460 stop
= stop
> func_end
? func_end
: stop
;
462 /* Start scanning on the first instruction of this function. */
465 /* Suck in two bytes. */
466 status
= read_memory_nobpt (addr
, buf
, 2);
469 fix_frame_pointer (fi
, 0);
473 /* First see if this insn sets the stack pointer from a register; if
474 so, it's probably the initialization of the stack pointer in _start,
475 so mark this as the bottom-most frame. */
476 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
479 get_frame_extra_info (fi
)->status
= NO_MORE_FRAMES
;
483 /* Now look for movm [regs],sp, which saves the callee saved registers.
485 At this time we don't know if fi->frame is valid, so we only note
486 that we encountered a movm instruction. Later, we'll set the entries
487 in fsr.regs as needed. */
490 /* Extract the register list for the movm instruction. */
491 status
= read_memory_nobpt (addr
+ 1, buf
, 1);
496 /* Quit now if we're beyond the stop point. */
499 /* Fix fi->frame since it's bogus at this point. */
500 if (fi
&& get_next_frame (fi
) == NULL
)
501 deprecated_update_frame_base_hack (fi
, read_sp ());
503 /* Note if/where callee saved registers were saved. */
504 set_movm_offsets (fi
, movm_args
);
508 /* Get the next two bytes so the prologue scan can continue. */
509 status
= read_memory_nobpt (addr
, buf
, 2);
512 /* Fix fi->frame since it's bogus at this point. */
513 if (fi
&& get_next_frame (fi
) == NULL
)
514 deprecated_update_frame_base_hack (fi
, read_sp ());
516 /* Note if/where callee saved registers were saved. */
517 set_movm_offsets (fi
, movm_args
);
522 /* Now see if we set up a frame pointer via "mov sp,a3" */
527 /* The frame pointer is now valid. */
530 get_frame_extra_info (fi
)->status
|= MY_FRAME_IN_FP
;
531 get_frame_extra_info (fi
)->status
&= ~MY_FRAME_IN_SP
;
534 /* Quit now if we're beyond the stop point. */
537 /* Fix fi->frame if it's bogus at this point. */
538 fix_frame_pointer (fi
, 0);
540 /* Note if/where callee saved registers were saved. */
541 set_movm_offsets (fi
, movm_args
);
545 /* Get two more bytes so scanning can continue. */
546 status
= read_memory_nobpt (addr
, buf
, 2);
549 /* Fix fi->frame if it's bogus at this point. */
550 fix_frame_pointer (fi
, 0);
552 /* Note if/where callee saved registers were saved. */
553 set_movm_offsets (fi
, movm_args
);
558 /* Next we should allocate the local frame. No more prologue insns
559 are found after allocating the local frame.
561 Search for add imm8,sp (0xf8feXX)
562 or add imm16,sp (0xfafeXXXX)
563 or add imm32,sp (0xfcfeXXXXXXXX).
565 If none of the above was found, then this prologue has no
568 status
= read_memory_nobpt (addr
, buf
, 2);
571 /* Fix fi->frame if it's bogus at this point. */
572 fix_frame_pointer (fi
, 0);
574 /* Note if/where callee saved registers were saved. */
575 set_movm_offsets (fi
, movm_args
);
580 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
582 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
584 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
589 /* Suck in imm_size more bytes, they'll hold the size of the
591 status
= read_memory_nobpt (addr
+ 2, buf
, imm_size
);
594 /* Fix fi->frame if it's bogus at this point. */
595 fix_frame_pointer (fi
, 0);
597 /* Note if/where callee saved registers were saved. */
598 set_movm_offsets (fi
, movm_args
);
602 /* Note the size of the stack in the frame info structure. */
603 stack_size
= extract_signed_integer (buf
, imm_size
);
605 get_frame_extra_info (fi
)->stack_size
= stack_size
;
607 /* We just consumed 2 + imm_size bytes. */
608 addr
+= 2 + imm_size
;
610 /* No more prologue insns follow, so begin preparation to return. */
611 /* Fix fi->frame if it's bogus at this point. */
612 fix_frame_pointer (fi
, stack_size
);
614 /* Note if/where callee saved registers were saved. */
615 set_movm_offsets (fi
, movm_args
);
619 /* We never found an insn which allocates local stack space, regardless
620 this is the end of the prologue. */
621 /* Fix fi->frame if it's bogus at this point. */
622 fix_frame_pointer (fi
, 0);
624 /* Note if/where callee saved registers were saved. */
625 set_movm_offsets (fi
, movm_args
);
630 /* Function: saved_regs_size
631 Return the size in bytes of the register save area, based on the
632 saved_regs array in FI. */
634 saved_regs_size (struct frame_info
*fi
)
639 /* Reserve four bytes for every register saved. */
640 for (i
= 0; i
< NUM_REGS
; i
++)
641 if (get_frame_saved_regs (fi
)[i
])
644 /* If we saved LIR, then it's most likely we used a `movm'
645 instruction with the `other' bit set, in which case the SP is
646 decremented by an extra four bytes, "to simplify calculation
647 of the transfer area", according to the processor manual. */
648 if (get_frame_saved_regs (fi
)[LIR_REGNUM
])
655 /* Function: frame_chain
656 Figure out and return the caller's frame pointer given current
659 We don't handle dummy frames yet but we would probably just return the
660 stack pointer that was in use at the time the function call was made? */
663 mn10300_frame_chain (struct frame_info
*fi
)
665 struct frame_info
*dummy
;
666 /* Walk through the prologue to determine the stack size,
667 location of saved registers, end of the prologue, etc. */
668 if (get_frame_extra_info (fi
)->status
== 0)
669 mn10300_analyze_prologue (fi
, (CORE_ADDR
) 0);
671 /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
672 if (get_frame_extra_info (fi
)->status
& NO_MORE_FRAMES
)
675 /* Now that we've analyzed our prologue, determine the frame
676 pointer for our caller.
678 If our caller has a frame pointer, then we need to
679 find the entry value of $a3 to our function.
681 If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
682 location pointed to by fsr.regs[A3_REGNUM].
684 Else it's still in $a3.
686 If our caller does not have a frame pointer, then his
687 frame base is fi->frame + -caller's stack size. */
689 /* The easiest way to get that info is to analyze our caller's frame.
690 So we set up a dummy frame and call mn10300_analyze_prologue to
691 find stuff for us. */
692 dummy
= analyze_dummy_frame (DEPRECATED_FRAME_SAVED_PC (fi
), get_frame_base (fi
));
694 if (get_frame_extra_info (dummy
)->status
& MY_FRAME_IN_FP
)
696 /* Our caller has a frame pointer. So find the frame in $a3 or
698 if (get_frame_saved_regs (fi
)[A3_REGNUM
])
699 return (read_memory_integer (get_frame_saved_regs (fi
)[A3_REGNUM
],
700 DEPRECATED_REGISTER_SIZE
));
702 return read_register (A3_REGNUM
);
706 int adjust
= saved_regs_size (fi
);
708 /* Our caller does not have a frame pointer. So his frame starts
709 at the base of our frame (fi->frame) + register save space
711 return get_frame_base (fi
) + adjust
+ -get_frame_extra_info (dummy
)->stack_size
;
715 /* Function: skip_prologue
716 Return the address of the first inst past the prologue of the function. */
719 mn10300_skip_prologue (CORE_ADDR pc
)
721 /* We used to check the debug symbols, but that can lose if
722 we have a null prologue. */
723 return mn10300_analyze_prologue (NULL
, pc
);
726 /* generic_pop_current_frame calls this function if the current
727 frame isn't a dummy frame. */
729 mn10300_pop_frame_regular (struct frame_info
*frame
)
733 write_register (PC_REGNUM
, DEPRECATED_FRAME_SAVED_PC (frame
));
735 /* Restore any saved registers. */
736 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
737 if (get_frame_saved_regs (frame
)[regnum
] != 0)
741 value
= read_memory_unsigned_integer (get_frame_saved_regs (frame
)[regnum
],
742 REGISTER_RAW_SIZE (regnum
));
743 write_register (regnum
, value
);
746 /* Actually cut back the stack. */
747 write_register (SP_REGNUM
, get_frame_base (frame
));
749 /* Don't we need to set the PC?!? XXX FIXME. */
752 /* Function: pop_frame
753 This routine gets called when either the user uses the `return'
754 command, or the call dummy breakpoint gets hit. */
756 mn10300_pop_frame (void)
758 /* This function checks for and handles generic dummy frames, and
759 calls back to our function for ordinary frames. */
760 generic_pop_current_frame (mn10300_pop_frame_regular
);
762 /* Throw away any cached frame information. */
763 flush_cached_frames ();
766 /* Function: push_arguments
767 Setup arguments for a call to the target. Arguments go in
768 order on the stack. */
771 mn10300_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
772 int struct_return
, CORE_ADDR struct_addr
)
776 int stack_offset
= 0;
777 int regsused
= struct_return
? 1 : 0;
779 /* This should be a nop, but align the stack just in case something
780 went wrong. Stacks are four byte aligned on the mn10300. */
783 /* Now make space on the stack for the args.
785 XXX This doesn't appear to handle pass-by-invisible reference
787 for (argnum
= 0; argnum
< nargs
; argnum
++)
789 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3;
791 while (regsused
< 2 && arg_length
> 0)
799 /* Allocate stack space. */
802 regsused
= struct_return
? 1 : 0;
803 /* Push all arguments onto the stack. */
804 for (argnum
= 0; argnum
< nargs
; argnum
++)
809 /* XXX Check this. What about UNIONS? */
810 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
811 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
813 /* XXX Wrong, we want a pointer to this argument. */
814 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
815 val
= (char *) VALUE_CONTENTS (*args
);
819 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
820 val
= (char *) VALUE_CONTENTS (*args
);
823 while (regsused
< 2 && len
> 0)
825 write_register (regsused
, extract_unsigned_integer (val
, 4));
833 write_memory (sp
+ stack_offset
, val
, 4);
842 /* Make space for the flushback area. */
847 /* Function: push_return_address (pc)
848 Set up the return address for the inferior function call.
849 Needed for targets where we don't actually execute a JSR/BSR instruction */
852 mn10300_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
854 unsigned char buf
[4];
856 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
857 write_memory (sp
- 4, buf
, 4);
861 /* Function: store_struct_return (addr,sp)
862 Store the structure value return address for an inferior function
866 mn10300_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
868 /* The structure return address is passed as the first argument. */
869 write_register (0, addr
);
872 /* Function: frame_saved_pc
873 Find the caller of this frame. We do this by seeing if RP_REGNUM
874 is saved in the stack anywhere, otherwise we get it from the
875 registers. If the inner frame is a dummy frame, return its PC
876 instead of RP, because that's where "caller" of the dummy-frame
880 mn10300_frame_saved_pc (struct frame_info
*fi
)
882 int adjust
= saved_regs_size (fi
);
884 return (read_memory_integer (get_frame_base (fi
) + adjust
,
885 DEPRECATED_REGISTER_SIZE
));
888 /* Function: mn10300_init_extra_frame_info
889 Setup the frame's frame pointer, pc, and frame addresses for saved
890 registers. Most of the work is done in mn10300_analyze_prologue().
892 Note that when we are called for the last frame (currently active frame),
893 that get_frame_pc (fi) and fi->frame will already be setup. However, fi->frame will
894 be valid only if this routine uses FP. For previous frames, fi-frame will
895 always be correct. mn10300_analyze_prologue will fix fi->frame if
898 We can be called with the PC in the call dummy under two
899 circumstances. First, during normal backtracing, second, while
900 figuring out the frame pointer just prior to calling the target
901 function (see call_function_by_hand). */
904 mn10300_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
906 if (get_next_frame (fi
))
907 deprecated_update_frame_pc_hack (fi
, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi
)));
909 frame_saved_regs_zalloc (fi
);
910 frame_extra_info_zalloc (fi
, sizeof (struct frame_extra_info
));
912 get_frame_extra_info (fi
)->status
= 0;
913 get_frame_extra_info (fi
)->stack_size
= 0;
915 mn10300_analyze_prologue (fi
, 0);
919 /* This function's job is handled by init_extra_frame_info. */
921 mn10300_frame_init_saved_regs (struct frame_info
*frame
)
926 /* Function: mn10300_virtual_frame_pointer
927 Return the register that the function uses for a frame pointer,
928 plus any necessary offset to be applied to the register before
929 any frame pointer offsets. */
932 mn10300_virtual_frame_pointer (CORE_ADDR pc
,
936 struct frame_info
*dummy
= analyze_dummy_frame (pc
, 0);
937 /* Set up a dummy frame_info, Analyze the prolog and fill in the
939 /* Results will tell us which type of frame it uses. */
940 if (get_frame_extra_info (dummy
)->status
& MY_FRAME_IN_SP
)
943 *offset
= -(get_frame_extra_info (dummy
)->stack_size
);
953 mn10300_reg_struct_has_addr (int gcc_p
, struct type
*type
)
955 return (TYPE_LENGTH (type
) > 8);
959 mn10300_register_virtual_type (int reg
)
961 return builtin_type_int
;
965 mn10300_register_byte (int reg
)
971 mn10300_register_virtual_size (int reg
)
977 mn10300_register_raw_size (int reg
)
982 /* If DWARF2 is a register number appearing in Dwarf2 debug info, then
983 mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
984 register number. Why don't Dwarf2 and GDB use the same numbering?
985 Who knows? But since people have object files lying around with
986 the existing Dwarf2 numbering, and other people have written stubs
987 to work with the existing GDB, neither of them can change. So we
988 just have to cope. */
990 mn10300_dwarf2_reg_to_regnum (int dwarf2
)
992 /* This table is supposed to be shaped like the REGISTER_NAMES
993 initializer in gcc/config/mn10300/mn10300.h. Registers which
994 appear in GCC's numbering, but have no counterpart in GDB's
995 world, are marked with a -1. */
996 static int dwarf2_to_gdb
[] = {
997 0, 1, 2, 3, 4, 5, 6, 7, -1, 8,
998 15, 16, 17, 18, 19, 20, 21, 22
1003 || dwarf2
>= (sizeof (dwarf2_to_gdb
) / sizeof (dwarf2_to_gdb
[0]))
1004 || dwarf2_to_gdb
[dwarf2
] == -1)
1005 internal_error (__FILE__
, __LINE__
,
1006 "bogus register number in debug info: %d", dwarf2
);
1008 return dwarf2_to_gdb
[dwarf2
];
1012 mn10300_print_register (const char *name
, int regnum
, int reg_width
)
1014 char raw_buffer
[MAX_REGISTER_SIZE
];
1017 printf_filtered ("%*s: ", reg_width
, name
);
1019 printf_filtered ("%s: ", name
);
1022 if (!frame_register_read (deprecated_selected_frame
, regnum
, raw_buffer
))
1024 printf_filtered ("[invalid]");
1030 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
1032 for (byte
= REGISTER_RAW_SIZE (regnum
) - REGISTER_VIRTUAL_SIZE (regnum
);
1033 byte
< REGISTER_RAW_SIZE (regnum
);
1035 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
1039 for (byte
= REGISTER_VIRTUAL_SIZE (regnum
) - 1;
1042 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
1048 mn10300_do_registers_info (int regnum
, int fpregs
)
1052 const char *name
= REGISTER_NAME (regnum
);
1053 if (name
== NULL
|| name
[0] == '\0')
1054 error ("Not a valid register for the current processor type");
1055 mn10300_print_register (name
, regnum
, 0);
1056 printf_filtered ("\n");
1060 /* print registers in an array 4x8 */
1063 const int nr_in_row
= 4;
1064 const int reg_width
= 4;
1065 for (r
= 0; r
< NUM_REGS
; r
+= nr_in_row
)
1070 for (c
= r
; c
< r
+ nr_in_row
; c
++)
1072 const char *name
= REGISTER_NAME (c
);
1073 if (name
!= NULL
&& *name
!= '\0')
1078 printf_filtered (" ");
1081 mn10300_print_register (name
, c
, reg_width
);
1082 printf_filtered (" ");
1086 padding
+= (reg_width
+ 2 + 8 + 1);
1090 printf_filtered ("\n");
1096 mn10300_read_fp (void)
1098 /* That's right, we're using the stack pointer as our frame pointer. */
1099 gdb_assert (SP_REGNUM
>= 0);
1100 return read_register (SP_REGNUM
);
1103 /* Dump out the mn10300 speciic architecture information. */
1106 mn10300_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1108 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1109 fprintf_unfiltered (file
, "mn10300_dump_tdep: am33_mode = %d\n",
1113 static struct gdbarch
*
1114 mn10300_gdbarch_init (struct gdbarch_info info
,
1115 struct gdbarch_list
*arches
)
1117 static LONGEST mn10300_call_dummy_words
[] = { 0 };
1118 struct gdbarch
*gdbarch
;
1119 struct gdbarch_tdep
*tdep
= NULL
;
1121 gdbarch_register_name_ftype
*register_name
;
1125 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1127 return arches
->gdbarch
;
1128 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1129 gdbarch
= gdbarch_alloc (&info
, tdep
);
1131 if (info
.bfd_arch_info
!= NULL
1132 && info
.bfd_arch_info
->arch
== bfd_arch_mn10300
)
1133 mach
= info
.bfd_arch_info
->mach
;
1139 case bfd_mach_mn10300
:
1141 register_name
= mn10300_generic_register_name
;
1146 register_name
= am33_register_name
;
1150 internal_error (__FILE__
, __LINE__
,
1151 "mn10300_gdbarch_init: Unknown mn10300 variant");
1152 return NULL
; /* keep GCC happy. */
1156 set_gdbarch_num_regs (gdbarch
, num_regs
);
1157 set_gdbarch_register_name (gdbarch
, register_name
);
1158 set_gdbarch_deprecated_register_size (gdbarch
, 4);
1159 set_gdbarch_deprecated_register_bytes (gdbarch
, num_regs
* gdbarch_deprecated_register_size (gdbarch
));
1160 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, 4);
1161 set_gdbarch_register_raw_size (gdbarch
, mn10300_register_raw_size
);
1162 set_gdbarch_register_byte (gdbarch
, mn10300_register_byte
);
1163 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, 4);
1164 set_gdbarch_register_virtual_size (gdbarch
, mn10300_register_virtual_size
);
1165 set_gdbarch_register_virtual_type (gdbarch
, mn10300_register_virtual_type
);
1166 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, mn10300_dwarf2_reg_to_regnum
);
1167 set_gdbarch_deprecated_do_registers_info (gdbarch
, mn10300_do_registers_info
);
1168 set_gdbarch_sp_regnum (gdbarch
, 8);
1169 set_gdbarch_pc_regnum (gdbarch
, 9);
1170 set_gdbarch_deprecated_fp_regnum (gdbarch
, 31);
1171 set_gdbarch_virtual_frame_pointer (gdbarch
, mn10300_virtual_frame_pointer
);
1174 set_gdbarch_breakpoint_from_pc (gdbarch
, mn10300_breakpoint_from_pc
);
1175 set_gdbarch_function_start_offset (gdbarch
, 0);
1176 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
1178 /* Stack unwinding. */
1179 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1180 set_gdbarch_deprecated_saved_pc_after_call (gdbarch
, mn10300_saved_pc_after_call
);
1181 set_gdbarch_deprecated_init_extra_frame_info (gdbarch
, mn10300_init_extra_frame_info
);
1182 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_noop
);
1183 set_gdbarch_deprecated_frame_init_saved_regs (gdbarch
, mn10300_frame_init_saved_regs
);
1184 set_gdbarch_deprecated_frame_chain (gdbarch
, mn10300_frame_chain
);
1185 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, mn10300_frame_saved_pc
);
1186 set_gdbarch_deprecated_extract_return_value (gdbarch
, mn10300_extract_return_value
);
1187 set_gdbarch_deprecated_extract_struct_value_address
1188 (gdbarch
, mn10300_extract_struct_value_address
);
1189 set_gdbarch_deprecated_store_return_value (gdbarch
, mn10300_store_return_value
);
1190 set_gdbarch_deprecated_store_struct_return (gdbarch
, mn10300_store_struct_return
);
1191 set_gdbarch_deprecated_pop_frame (gdbarch
, mn10300_pop_frame
);
1192 set_gdbarch_skip_prologue (gdbarch
, mn10300_skip_prologue
);
1193 set_gdbarch_frame_args_skip (gdbarch
, 0);
1194 set_gdbarch_frame_num_args (gdbarch
, frame_num_args_unknown
);
1195 /* That's right, we're using the stack pointer as our frame pointer. */
1196 set_gdbarch_deprecated_target_read_fp (gdbarch
, mn10300_read_fp
);
1198 /* Calling functions in the inferior from GDB. */
1199 set_gdbarch_deprecated_call_dummy_words (gdbarch
, mn10300_call_dummy_words
);
1200 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof (mn10300_call_dummy_words
));
1201 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
1202 set_gdbarch_deprecated_push_arguments (gdbarch
, mn10300_push_arguments
);
1203 set_gdbarch_reg_struct_has_addr (gdbarch
, mn10300_reg_struct_has_addr
);
1204 set_gdbarch_deprecated_push_return_address (gdbarch
, mn10300_push_return_address
);
1205 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1206 set_gdbarch_use_struct_convention (gdbarch
, mn10300_use_struct_convention
);
1208 tdep
->am33_mode
= am33_mode
;
1210 /* Should be using push_dummy_call. */
1211 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, generic_target_write_sp
);
1217 _initialize_mn10300_tdep (void)
1219 /* printf("_initialize_mn10300_tdep\n"); */
1221 deprecated_tm_print_insn
= print_insn_mn10300
;
1223 register_gdbarch_init (bfd_arch_mn10300
, mn10300_gdbarch_init
);