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"
47 #define MDRQ_REGNUM 14
49 #define MCRH_REGNUM 26
50 #define MCRL_REGNUM 27
51 #define MCVF_REGNUM 28
53 enum movm_register_bits
{
54 movm_exother_bit
= 0x01,
55 movm_exreg1_bit
= 0x02,
56 movm_exreg0_bit
= 0x04,
57 movm_other_bit
= 0x08,
64 extern void _initialize_mn10300_tdep (void);
65 static CORE_ADDR
mn10300_analyze_prologue (struct frame_info
*fi
,
68 /* mn10300 private data */
72 #define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode)
75 /* Additional info used by the frame */
77 struct frame_extra_info
85 register_name (int reg
, char **regs
, long sizeof_regs
)
87 if (reg
< 0 || reg
>= sizeof_regs
/ sizeof (regs
[0]))
94 mn10300_generic_register_name (int reg
)
97 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
98 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
99 "", "", "", "", "", "", "", "",
100 "", "", "", "", "", "", "", "fp"
102 return register_name (reg
, regs
, sizeof regs
);
107 am33_register_name (int reg
)
109 static char *regs
[] =
110 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
111 "sp", "pc", "mdr", "psw", "lir", "lar", "",
112 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
113 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
115 return register_name (reg
, regs
, sizeof regs
);
119 mn10300_saved_pc_after_call (struct frame_info
*fi
)
121 return read_memory_integer (read_register (SP_REGNUM
), 4);
125 mn10300_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
127 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
128 memcpy (valbuf
, regbuf
+ DEPRECATED_REGISTER_BYTE (4), TYPE_LENGTH (type
));
130 memcpy (valbuf
, regbuf
+ DEPRECATED_REGISTER_BYTE (0), TYPE_LENGTH (type
));
134 mn10300_extract_struct_value_address (char *regbuf
)
136 return extract_unsigned_integer (regbuf
+ DEPRECATED_REGISTER_BYTE (4),
137 DEPRECATED_REGISTER_RAW_SIZE (4));
141 mn10300_store_return_value (struct type
*type
, char *valbuf
)
143 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
144 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (4), valbuf
,
147 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (0), valbuf
,
151 static struct frame_info
*analyze_dummy_frame (CORE_ADDR
, CORE_ADDR
);
152 static struct frame_info
*
153 analyze_dummy_frame (CORE_ADDR pc
, CORE_ADDR frame
)
155 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
156 struct frame_info
*dummy
157 = deprecated_frame_xmalloc_with_cleanup (SIZEOF_FRAME_SAVED_REGS
,
158 sizeof (struct frame_extra_info
));
159 deprecated_update_frame_pc_hack (dummy
, pc
);
160 deprecated_update_frame_base_hack (dummy
, frame
);
161 get_frame_extra_info (dummy
)->status
= 0;
162 get_frame_extra_info (dummy
)->stack_size
= 0;
163 mn10300_analyze_prologue (dummy
, pc
);
164 do_cleanups (old_chain
);
168 /* Values for frame_info.status */
170 #define MY_FRAME_IN_SP 0x1
171 #define MY_FRAME_IN_FP 0x2
172 #define NO_MORE_FRAMES 0x4
175 /* Should call_function allocate stack space for a struct return? */
177 mn10300_use_struct_convention (int gcc_p
, struct type
*type
)
179 return (TYPE_NFIELDS (type
) > 1 || TYPE_LENGTH (type
) > 8);
182 /* The breakpoint instruction must be the same size as the smallest
183 instruction in the instruction set.
185 The Matsushita mn10x00 processors have single byte instructions
186 so we need a single byte breakpoint. Matsushita hasn't defined
187 one, so we defined it ourselves. */
189 const static unsigned char *
190 mn10300_breakpoint_from_pc (CORE_ADDR
*bp_addr
, int *bp_size
)
192 static char breakpoint
[] =
199 /* Fix fi->frame if it's bogus at this point. This is a helper
200 function for mn10300_analyze_prologue. */
203 fix_frame_pointer (struct frame_info
*fi
, int stack_size
)
205 if (fi
&& get_next_frame (fi
) == NULL
)
207 if (get_frame_extra_info (fi
)->status
& MY_FRAME_IN_SP
)
208 deprecated_update_frame_base_hack (fi
, read_sp () - stack_size
);
209 else if (get_frame_extra_info (fi
)->status
& MY_FRAME_IN_FP
)
210 deprecated_update_frame_base_hack (fi
, read_register (A3_REGNUM
));
215 /* Set offsets of registers saved by movm instruction.
216 This is a helper function for mn10300_analyze_prologue. */
219 set_movm_offsets (struct frame_info
*fi
, int movm_args
)
223 if (fi
== NULL
|| movm_args
== 0)
226 if (movm_args
& movm_other_bit
)
228 /* The `other' bit leaves a blank area of four bytes at the
229 beginning of its block of saved registers, making it 32 bytes
231 deprecated_get_frame_saved_regs (fi
)[LAR_REGNUM
] = get_frame_base (fi
) + offset
+ 4;
232 deprecated_get_frame_saved_regs (fi
)[LIR_REGNUM
] = get_frame_base (fi
) + offset
+ 8;
233 deprecated_get_frame_saved_regs (fi
)[MDR_REGNUM
] = get_frame_base (fi
) + offset
+ 12;
234 deprecated_get_frame_saved_regs (fi
)[A0_REGNUM
+ 1] = get_frame_base (fi
) + offset
+ 16;
235 deprecated_get_frame_saved_regs (fi
)[A0_REGNUM
] = get_frame_base (fi
) + offset
+ 20;
236 deprecated_get_frame_saved_regs (fi
)[D0_REGNUM
+ 1] = get_frame_base (fi
) + offset
+ 24;
237 deprecated_get_frame_saved_regs (fi
)[D0_REGNUM
] = get_frame_base (fi
) + offset
+ 28;
240 if (movm_args
& movm_a3_bit
)
242 deprecated_get_frame_saved_regs (fi
)[A3_REGNUM
] = get_frame_base (fi
) + offset
;
245 if (movm_args
& movm_a2_bit
)
247 deprecated_get_frame_saved_regs (fi
)[A2_REGNUM
] = get_frame_base (fi
) + offset
;
250 if (movm_args
& movm_d3_bit
)
252 deprecated_get_frame_saved_regs (fi
)[D3_REGNUM
] = get_frame_base (fi
) + offset
;
255 if (movm_args
& movm_d2_bit
)
257 deprecated_get_frame_saved_regs (fi
)[D2_REGNUM
] = get_frame_base (fi
) + offset
;
262 if (movm_args
& movm_exother_bit
)
264 deprecated_get_frame_saved_regs (fi
)[MCVF_REGNUM
] = get_frame_base (fi
) + offset
;
265 deprecated_get_frame_saved_regs (fi
)[MCRL_REGNUM
] = get_frame_base (fi
) + offset
+ 4;
266 deprecated_get_frame_saved_regs (fi
)[MCRH_REGNUM
] = get_frame_base (fi
) + offset
+ 8;
267 deprecated_get_frame_saved_regs (fi
)[MDRQ_REGNUM
] = get_frame_base (fi
) + offset
+ 12;
268 deprecated_get_frame_saved_regs (fi
)[E0_REGNUM
+ 1] = get_frame_base (fi
) + offset
+ 16;
269 deprecated_get_frame_saved_regs (fi
)[E0_REGNUM
+ 0] = get_frame_base (fi
) + offset
+ 20;
272 if (movm_args
& movm_exreg1_bit
)
274 deprecated_get_frame_saved_regs (fi
)[E0_REGNUM
+ 7] = get_frame_base (fi
) + offset
;
275 deprecated_get_frame_saved_regs (fi
)[E0_REGNUM
+ 6] = get_frame_base (fi
) + offset
+ 4;
276 deprecated_get_frame_saved_regs (fi
)[E0_REGNUM
+ 5] = get_frame_base (fi
) + offset
+ 8;
277 deprecated_get_frame_saved_regs (fi
)[E0_REGNUM
+ 4] = get_frame_base (fi
) + offset
+ 12;
280 if (movm_args
& movm_exreg0_bit
)
282 deprecated_get_frame_saved_regs (fi
)[E0_REGNUM
+ 3] = get_frame_base (fi
) + offset
;
283 deprecated_get_frame_saved_regs (fi
)[E0_REGNUM
+ 2] = get_frame_base (fi
) + offset
+ 4;
290 /* The main purpose of this file is dealing with prologues to extract
291 information about stack frames and saved registers.
293 In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
294 function is pretty readable, and has a nice explanation of how the
295 prologue is generated. The prologues generated by that code will
296 have the following form (NOTE: the current code doesn't handle all
299 + If this is an old-style varargs function, then its arguments
300 need to be flushed back to the stack:
305 + If we use any of the callee-saved registers, save them now.
307 movm [some callee-saved registers],(sp)
309 + If we have any floating-point registers to save:
311 - Decrement the stack pointer to reserve space for the registers.
312 If the function doesn't need a frame pointer, we may combine
313 this with the adjustment that reserves space for the frame.
317 - Save the floating-point registers. We have two possible
320 . Save them at fixed offset from the SP:
322 fmov fsN,(OFFSETN,sp)
323 fmov fsM,(OFFSETM,sp)
326 Note that, if OFFSETN happens to be zero, you'll get the
327 different opcode: fmov fsN,(sp)
329 . Or, set a0 to the start of the save area, and then use
330 post-increment addressing to save the FP registers.
338 + If the function needs a frame pointer, we set it here.
342 + Now we reserve space for the stack frame proper. This could be
343 merged into the `add -SIZE, sp' instruction for FP saves up
344 above, unless we needed to set the frame pointer in the previous
345 step, or the frame is so large that allocating the whole thing at
346 once would put the FP register save slots out of reach of the
347 addressing mode (128 bytes).
351 One day we might keep the stack pointer constant, that won't
352 change the code for prologues, but it will make the frame
353 pointerless case much more common. */
355 /* Analyze the prologue to determine where registers are saved,
356 the end of the prologue, etc etc. Return the end of the prologue
359 We store into FI (if non-null) several tidbits of information:
361 * stack_size -- size of this stack frame. Note that if we stop in
362 certain parts of the prologue/epilogue we may claim the size of the
363 current frame is zero. This happens when the current frame has
364 not been allocated yet or has already been deallocated.
366 * fsr -- Addresses of registers saved in the stack by this frame.
368 * status -- A (relatively) generic status indicator. It's a bitmask
369 with the following bits:
371 MY_FRAME_IN_SP: The base of the current frame is actually in
372 the stack pointer. This can happen for frame pointerless
373 functions, or cases where we're stopped in the prologue/epilogue
374 itself. For these cases mn10300_analyze_prologue will need up
375 update fi->frame before returning or analyzing the register
378 MY_FRAME_IN_FP: The base of the current frame is in the
379 frame pointer register ($a3).
381 NO_MORE_FRAMES: Set this if the current frame is "start" or
382 if the first instruction looks like mov <imm>,sp. This tells
383 frame chain to not bother trying to unwind past this frame. */
386 mn10300_analyze_prologue (struct frame_info
*fi
, CORE_ADDR pc
)
388 CORE_ADDR func_addr
, func_end
, addr
, stop
;
389 CORE_ADDR stack_size
;
391 unsigned char buf
[4];
392 int status
, movm_args
= 0;
395 /* Use the PC in the frame if it's provided to look up the
396 start of this function.
398 Note: kevinb/2003-07-16: We used to do the following here:
399 pc = (fi ? get_frame_pc (fi) : pc);
400 But this is (now) badly broken when called from analyze_dummy_frame().
402 pc
= (pc
? pc
: get_frame_pc (fi
));
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);
433 /* Note: kevinb/2003-07-16: We shouldn't be making these sorts of
434 changes to the frame in prologue examination code. */
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
);
457 /* Figure out where to stop scanning. */
458 stop
= fi
? pc
: func_end
;
460 /* Don't walk off the end of the function. */
461 stop
= stop
> func_end
? func_end
: stop
;
463 /* Start scanning on the first instruction of this function. */
466 /* Suck in two bytes. */
467 status
= read_memory_nobpt (addr
, buf
, 2);
470 fix_frame_pointer (fi
, 0);
474 /* First see if this insn sets the stack pointer from a register; if
475 so, it's probably the initialization of the stack pointer in _start,
476 so mark this as the bottom-most frame. */
477 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
480 get_frame_extra_info (fi
)->status
= NO_MORE_FRAMES
;
484 /* Now look for movm [regs],sp, which saves the callee saved registers.
486 At this time we don't know if fi->frame is valid, so we only note
487 that we encountered a movm instruction. Later, we'll set the entries
488 in fsr.regs as needed. */
491 /* Extract the register list for the movm instruction. */
492 status
= read_memory_nobpt (addr
+ 1, buf
, 1);
497 /* Quit now if we're beyond the stop point. */
500 /* Fix fi->frame since it's bogus at this point. */
501 if (fi
&& get_next_frame (fi
) == NULL
)
502 deprecated_update_frame_base_hack (fi
, read_sp ());
504 /* Note if/where callee saved registers were saved. */
505 set_movm_offsets (fi
, movm_args
);
509 /* Get the next two bytes so the prologue scan can continue. */
510 status
= read_memory_nobpt (addr
, buf
, 2);
513 /* Fix fi->frame since it's bogus at this point. */
514 if (fi
&& get_next_frame (fi
) == NULL
)
515 deprecated_update_frame_base_hack (fi
, read_sp ());
517 /* Note if/where callee saved registers were saved. */
518 set_movm_offsets (fi
, movm_args
);
523 /* Now see if we set up a frame pointer via "mov sp,a3" */
528 /* The frame pointer is now valid. */
531 get_frame_extra_info (fi
)->status
|= MY_FRAME_IN_FP
;
532 get_frame_extra_info (fi
)->status
&= ~MY_FRAME_IN_SP
;
535 /* Quit now if we're beyond the stop point. */
538 /* Fix fi->frame if it's bogus at this point. */
539 fix_frame_pointer (fi
, 0);
541 /* Note if/where callee saved registers were saved. */
542 set_movm_offsets (fi
, movm_args
);
546 /* Get two more bytes so scanning can continue. */
547 status
= read_memory_nobpt (addr
, buf
, 2);
550 /* Fix fi->frame if it's bogus at this point. */
551 fix_frame_pointer (fi
, 0);
553 /* Note if/where callee saved registers were saved. */
554 set_movm_offsets (fi
, movm_args
);
559 /* Next we should allocate the local frame. No more prologue insns
560 are found after allocating the local frame.
562 Search for add imm8,sp (0xf8feXX)
563 or add imm16,sp (0xfafeXXXX)
564 or add imm32,sp (0xfcfeXXXXXXXX).
566 If none of the above was found, then this prologue has no
569 status
= read_memory_nobpt (addr
, buf
, 2);
572 /* Fix fi->frame if it's bogus at this point. */
573 fix_frame_pointer (fi
, 0);
575 /* Note if/where callee saved registers were saved. */
576 set_movm_offsets (fi
, movm_args
);
581 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
583 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
585 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
590 /* Suck in imm_size more bytes, they'll hold the size of the
592 status
= read_memory_nobpt (addr
+ 2, buf
, imm_size
);
595 /* Fix fi->frame if it's bogus at this point. */
596 fix_frame_pointer (fi
, 0);
598 /* Note if/where callee saved registers were saved. */
599 set_movm_offsets (fi
, movm_args
);
603 /* Note the size of the stack in the frame info structure. */
604 stack_size
= extract_signed_integer (buf
, imm_size
);
606 get_frame_extra_info (fi
)->stack_size
= stack_size
;
608 /* We just consumed 2 + imm_size bytes. */
609 addr
+= 2 + imm_size
;
611 /* No more prologue insns follow, so begin preparation to return. */
612 /* Fix fi->frame if it's bogus at this point. */
613 fix_frame_pointer (fi
, stack_size
);
615 /* Note if/where callee saved registers were saved. */
616 set_movm_offsets (fi
, movm_args
);
620 /* We never found an insn which allocates local stack space, regardless
621 this is the end of the prologue. */
622 /* Fix fi->frame if it's bogus at this point. */
623 fix_frame_pointer (fi
, 0);
625 /* Note if/where callee saved registers were saved. */
626 set_movm_offsets (fi
, movm_args
);
631 /* Function: saved_regs_size
632 Return the size in bytes of the register save area, based on the
633 saved_regs array in FI. */
635 saved_regs_size (struct frame_info
*fi
)
640 /* Reserve four bytes for every register saved. */
641 for (i
= 0; i
< NUM_REGS
; i
++)
642 if (deprecated_get_frame_saved_regs (fi
)[i
])
645 /* If we saved LIR, then it's most likely we used a `movm'
646 instruction with the `other' bit set, in which case the SP is
647 decremented by an extra four bytes, "to simplify calculation
648 of the transfer area", according to the processor manual. */
649 if (deprecated_get_frame_saved_regs (fi
)[LIR_REGNUM
])
656 /* Function: frame_chain
657 Figure out and return the caller's frame pointer given current
660 We don't handle dummy frames yet but we would probably just return the
661 stack pointer that was in use at the time the function call was made? */
664 mn10300_frame_chain (struct frame_info
*fi
)
666 struct frame_info
*dummy
;
667 /* Walk through the prologue to determine the stack size,
668 location of saved registers, end of the prologue, etc. */
669 if (get_frame_extra_info (fi
)->status
== 0)
670 mn10300_analyze_prologue (fi
, (CORE_ADDR
) 0);
672 /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
673 if (get_frame_extra_info (fi
)->status
& NO_MORE_FRAMES
)
676 /* Now that we've analyzed our prologue, determine the frame
677 pointer for our caller.
679 If our caller has a frame pointer, then we need to
680 find the entry value of $a3 to our function.
682 If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
683 location pointed to by fsr.regs[A3_REGNUM].
685 Else it's still in $a3.
687 If our caller does not have a frame pointer, then his
688 frame base is fi->frame + -caller's stack size. */
690 /* The easiest way to get that info is to analyze our caller's frame.
691 So we set up a dummy frame and call mn10300_analyze_prologue to
692 find stuff for us. */
693 dummy
= analyze_dummy_frame (DEPRECATED_FRAME_SAVED_PC (fi
), get_frame_base (fi
));
695 if (get_frame_extra_info (dummy
)->status
& MY_FRAME_IN_FP
)
697 /* Our caller has a frame pointer. So find the frame in $a3 or
699 if (deprecated_get_frame_saved_regs (fi
)[A3_REGNUM
])
700 return (read_memory_integer (deprecated_get_frame_saved_regs (fi
)[A3_REGNUM
],
701 DEPRECATED_REGISTER_SIZE
));
703 return read_register (A3_REGNUM
);
707 int adjust
= saved_regs_size (fi
);
709 /* Our caller does not have a frame pointer. So his frame starts
710 at the base of our frame (fi->frame) + register save space
712 return get_frame_base (fi
) + adjust
+ -get_frame_extra_info (dummy
)->stack_size
;
716 /* Function: skip_prologue
717 Return the address of the first inst past the prologue of the function. */
720 mn10300_skip_prologue (CORE_ADDR pc
)
722 /* We used to check the debug symbols, but that can lose if
723 we have a null prologue. */
724 return mn10300_analyze_prologue (NULL
, pc
);
727 /* generic_pop_current_frame calls this function if the current
728 frame isn't a dummy frame. */
730 mn10300_pop_frame_regular (struct frame_info
*frame
)
734 write_register (PC_REGNUM
, DEPRECATED_FRAME_SAVED_PC (frame
));
736 /* Restore any saved registers. */
737 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
738 if (deprecated_get_frame_saved_regs (frame
)[regnum
] != 0)
742 value
= read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame
)[regnum
],
743 DEPRECATED_REGISTER_RAW_SIZE (regnum
));
744 write_register (regnum
, value
);
747 /* Actually cut back the stack. */
748 write_register (SP_REGNUM
, get_frame_base (frame
));
750 /* Don't we need to set the PC?!? XXX FIXME. */
753 /* Function: pop_frame
754 This routine gets called when either the user uses the `return'
755 command, or the call dummy breakpoint gets hit. */
757 mn10300_pop_frame (void)
759 /* This function checks for and handles generic dummy frames, and
760 calls back to our function for ordinary frames. */
761 generic_pop_current_frame (mn10300_pop_frame_regular
);
763 /* Throw away any cached frame information. */
764 flush_cached_frames ();
767 /* Function: push_arguments
768 Setup arguments for a call to the target. Arguments go in
769 order on the stack. */
772 mn10300_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
773 int struct_return
, CORE_ADDR struct_addr
)
777 int stack_offset
= 0;
778 int regsused
= struct_return
? 1 : 0;
780 /* This should be a nop, but align the stack just in case something
781 went wrong. Stacks are four byte aligned on the mn10300. */
784 /* Now make space on the stack for the args.
786 XXX This doesn't appear to handle pass-by-invisible reference
788 for (argnum
= 0; argnum
< nargs
; argnum
++)
790 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3;
792 while (regsused
< 2 && arg_length
> 0)
800 /* Allocate stack space. */
803 regsused
= struct_return
? 1 : 0;
804 /* Push all arguments onto the stack. */
805 for (argnum
= 0; argnum
< nargs
; argnum
++)
810 /* XXX Check this. What about UNIONS? */
811 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
812 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
814 /* XXX Wrong, we want a pointer to this argument. */
815 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
816 val
= (char *) VALUE_CONTENTS (*args
);
820 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
821 val
= (char *) VALUE_CONTENTS (*args
);
824 while (regsused
< 2 && len
> 0)
826 write_register (regsused
, extract_unsigned_integer (val
, 4));
834 write_memory (sp
+ stack_offset
, val
, 4);
843 /* Make space for the flushback area. */
848 /* Function: push_return_address (pc)
849 Set up the return address for the inferior function call.
850 Needed for targets where we don't actually execute a JSR/BSR instruction */
853 mn10300_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
855 unsigned char buf
[4];
857 store_unsigned_integer (buf
, 4, entry_point_address ());
858 write_memory (sp
- 4, buf
, 4);
862 /* Function: store_struct_return (addr,sp)
863 Store the structure value return address for an inferior function
867 mn10300_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
869 /* The structure return address is passed as the first argument. */
870 write_register (0, addr
);
873 /* Function: frame_saved_pc
874 Find the caller of this frame. We do this by seeing if RP_REGNUM
875 is saved in the stack anywhere, otherwise we get it from the
876 registers. If the inner frame is a dummy frame, return its PC
877 instead of RP, because that's where "caller" of the dummy-frame
881 mn10300_frame_saved_pc (struct frame_info
*fi
)
883 int adjust
= saved_regs_size (fi
);
885 return (read_memory_integer (get_frame_base (fi
) + adjust
,
886 DEPRECATED_REGISTER_SIZE
));
889 /* Function: mn10300_init_extra_frame_info
890 Setup the frame's frame pointer, pc, and frame addresses for saved
891 registers. Most of the work is done in mn10300_analyze_prologue().
893 Note that when we are called for the last frame (currently active frame),
894 that get_frame_pc (fi) and fi->frame will already be setup. However, fi->frame will
895 be valid only if this routine uses FP. For previous frames, fi-frame will
896 always be correct. mn10300_analyze_prologue will fix fi->frame if
899 We can be called with the PC in the call dummy under two
900 circumstances. First, during normal backtracing, second, while
901 figuring out the frame pointer just prior to calling the target
902 function (see call_function_by_hand). */
905 mn10300_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
907 if (get_next_frame (fi
))
908 deprecated_update_frame_pc_hack (fi
, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi
)));
910 frame_saved_regs_zalloc (fi
);
911 frame_extra_info_zalloc (fi
, sizeof (struct frame_extra_info
));
913 get_frame_extra_info (fi
)->status
= 0;
914 get_frame_extra_info (fi
)->stack_size
= 0;
916 mn10300_analyze_prologue (fi
, 0);
920 /* This function's job is handled by init_extra_frame_info. */
922 mn10300_frame_init_saved_regs (struct frame_info
*frame
)
927 /* Function: mn10300_virtual_frame_pointer
928 Return the register that the function uses for a frame pointer,
929 plus any necessary offset to be applied to the register before
930 any frame pointer offsets. */
933 mn10300_virtual_frame_pointer (CORE_ADDR pc
,
937 struct frame_info
*dummy
= analyze_dummy_frame (pc
, 0);
938 /* Set up a dummy frame_info, Analyze the prolog and fill in the
940 /* Results will tell us which type of frame it uses. */
941 if (get_frame_extra_info (dummy
)->status
& MY_FRAME_IN_SP
)
944 *offset
= -(get_frame_extra_info (dummy
)->stack_size
);
954 mn10300_reg_struct_has_addr (int gcc_p
, struct type
*type
)
956 return (TYPE_LENGTH (type
) > 8);
960 mn10300_register_virtual_type (int reg
)
962 return builtin_type_int
;
966 mn10300_register_byte (int reg
)
972 mn10300_register_virtual_size (int reg
)
978 mn10300_register_raw_size (int reg
)
983 /* If DWARF2 is a register number appearing in Dwarf2 debug info, then
984 mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
985 register number. Why don't Dwarf2 and GDB use the same numbering?
986 Who knows? But since people have object files lying around with
987 the existing Dwarf2 numbering, and other people have written stubs
988 to work with the existing GDB, neither of them can change. So we
989 just have to cope. */
991 mn10300_dwarf2_reg_to_regnum (int dwarf2
)
993 /* This table is supposed to be shaped like the REGISTER_NAMES
994 initializer in gcc/config/mn10300/mn10300.h. Registers which
995 appear in GCC's numbering, but have no counterpart in GDB's
996 world, are marked with a -1. */
997 static int dwarf2_to_gdb
[] = {
998 0, 1, 2, 3, 4, 5, 6, 7, -1, 8,
999 15, 16, 17, 18, 19, 20, 21, 22
1004 || dwarf2
>= (sizeof (dwarf2_to_gdb
) / sizeof (dwarf2_to_gdb
[0]))
1005 || dwarf2_to_gdb
[dwarf2
] == -1)
1006 internal_error (__FILE__
, __LINE__
,
1007 "bogus register number in debug info: %d", dwarf2
);
1009 return dwarf2_to_gdb
[dwarf2
];
1013 mn10300_print_register (const char *name
, int regnum
, int reg_width
)
1015 char raw_buffer
[MAX_REGISTER_SIZE
];
1018 printf_filtered ("%*s: ", reg_width
, name
);
1020 printf_filtered ("%s: ", name
);
1023 if (!frame_register_read (deprecated_selected_frame
, regnum
, raw_buffer
))
1025 printf_filtered ("[invalid]");
1031 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
1033 for (byte
= DEPRECATED_REGISTER_RAW_SIZE (regnum
) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum
);
1034 byte
< DEPRECATED_REGISTER_RAW_SIZE (regnum
);
1036 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
1040 for (byte
= DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum
) - 1;
1043 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
1049 mn10300_do_registers_info (int regnum
, int fpregs
)
1053 const char *name
= REGISTER_NAME (regnum
);
1054 if (name
== NULL
|| name
[0] == '\0')
1055 error ("Not a valid register for the current processor type");
1056 mn10300_print_register (name
, regnum
, 0);
1057 printf_filtered ("\n");
1061 /* print registers in an array 4x8 */
1064 const int nr_in_row
= 4;
1065 const int reg_width
= 4;
1066 for (r
= 0; r
< NUM_REGS
; r
+= nr_in_row
)
1071 for (c
= r
; c
< r
+ nr_in_row
; c
++)
1073 const char *name
= REGISTER_NAME (c
);
1074 if (name
!= NULL
&& *name
!= '\0')
1079 printf_filtered (" ");
1082 mn10300_print_register (name
, c
, reg_width
);
1083 printf_filtered (" ");
1087 padding
+= (reg_width
+ 2 + 8 + 1);
1091 printf_filtered ("\n");
1097 mn10300_read_fp (void)
1099 /* That's right, we're using the stack pointer as our frame pointer. */
1100 gdb_assert (SP_REGNUM
>= 0);
1101 return read_register (SP_REGNUM
);
1104 /* Dump out the mn10300 speciic architecture information. */
1107 mn10300_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1109 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1110 fprintf_unfiltered (file
, "mn10300_dump_tdep: am33_mode = %d\n",
1114 static struct gdbarch
*
1115 mn10300_gdbarch_init (struct gdbarch_info info
,
1116 struct gdbarch_list
*arches
)
1118 static LONGEST mn10300_call_dummy_words
[] = { 0 };
1119 struct gdbarch
*gdbarch
;
1120 struct gdbarch_tdep
*tdep
= NULL
;
1122 gdbarch_register_name_ftype
*register_name
;
1126 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1128 return arches
->gdbarch
;
1129 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1130 gdbarch
= gdbarch_alloc (&info
, tdep
);
1132 if (info
.bfd_arch_info
!= NULL
1133 && info
.bfd_arch_info
->arch
== bfd_arch_mn10300
)
1134 mach
= info
.bfd_arch_info
->mach
;
1140 case bfd_mach_mn10300
:
1142 register_name
= mn10300_generic_register_name
;
1147 register_name
= am33_register_name
;
1151 internal_error (__FILE__
, __LINE__
,
1152 "mn10300_gdbarch_init: Unknown mn10300 variant");
1153 return NULL
; /* keep GCC happy. */
1157 set_gdbarch_num_regs (gdbarch
, num_regs
);
1158 set_gdbarch_register_name (gdbarch
, register_name
);
1159 set_gdbarch_deprecated_register_size (gdbarch
, 4);
1160 set_gdbarch_deprecated_register_bytes (gdbarch
, num_regs
* gdbarch_deprecated_register_size (gdbarch
));
1161 set_gdbarch_deprecated_max_register_raw_size (gdbarch
, 4);
1162 set_gdbarch_deprecated_register_raw_size (gdbarch
, mn10300_register_raw_size
);
1163 set_gdbarch_deprecated_register_byte (gdbarch
, mn10300_register_byte
);
1164 set_gdbarch_deprecated_max_register_virtual_size (gdbarch
, 4);
1165 set_gdbarch_deprecated_register_virtual_size (gdbarch
, mn10300_register_virtual_size
);
1166 set_gdbarch_deprecated_register_virtual_type (gdbarch
, mn10300_register_virtual_type
);
1167 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, mn10300_dwarf2_reg_to_regnum
);
1168 set_gdbarch_deprecated_do_registers_info (gdbarch
, mn10300_do_registers_info
);
1169 set_gdbarch_sp_regnum (gdbarch
, 8);
1170 set_gdbarch_pc_regnum (gdbarch
, 9);
1171 set_gdbarch_deprecated_fp_regnum (gdbarch
, 31);
1172 set_gdbarch_virtual_frame_pointer (gdbarch
, mn10300_virtual_frame_pointer
);
1175 set_gdbarch_breakpoint_from_pc (gdbarch
, mn10300_breakpoint_from_pc
);
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_frame_init_saved_regs (gdbarch
, mn10300_frame_init_saved_regs
);
1183 set_gdbarch_deprecated_frame_chain (gdbarch
, mn10300_frame_chain
);
1184 set_gdbarch_deprecated_frame_saved_pc (gdbarch
, mn10300_frame_saved_pc
);
1185 set_gdbarch_deprecated_extract_return_value (gdbarch
, mn10300_extract_return_value
);
1186 set_gdbarch_deprecated_extract_struct_value_address
1187 (gdbarch
, mn10300_extract_struct_value_address
);
1188 set_gdbarch_deprecated_store_return_value (gdbarch
, mn10300_store_return_value
);
1189 set_gdbarch_deprecated_store_struct_return (gdbarch
, mn10300_store_struct_return
);
1190 set_gdbarch_deprecated_pop_frame (gdbarch
, mn10300_pop_frame
);
1191 set_gdbarch_skip_prologue (gdbarch
, mn10300_skip_prologue
);
1192 set_gdbarch_frame_args_skip (gdbarch
, 0);
1193 /* That's right, we're using the stack pointer as our frame pointer. */
1194 set_gdbarch_deprecated_target_read_fp (gdbarch
, mn10300_read_fp
);
1196 /* Calling functions in the inferior from GDB. */
1197 set_gdbarch_deprecated_call_dummy_words (gdbarch
, mn10300_call_dummy_words
);
1198 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof (mn10300_call_dummy_words
));
1199 set_gdbarch_deprecated_pc_in_call_dummy (gdbarch
, deprecated_pc_in_call_dummy_at_entry_point
);
1200 set_gdbarch_deprecated_push_arguments (gdbarch
, mn10300_push_arguments
);
1201 set_gdbarch_deprecated_reg_struct_has_addr
1202 (gdbarch
, mn10300_reg_struct_has_addr
);
1203 set_gdbarch_deprecated_push_return_address (gdbarch
, mn10300_push_return_address
);
1204 set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1205 set_gdbarch_use_struct_convention (gdbarch
, mn10300_use_struct_convention
);
1207 tdep
->am33_mode
= am33_mode
;
1209 /* Should be using push_dummy_call. */
1210 set_gdbarch_deprecated_dummy_write_sp (gdbarch
, deprecated_write_sp
);
1212 set_gdbarch_print_insn (gdbarch
, print_insn_mn10300
);
1218 _initialize_mn10300_tdep (void)
1220 /* printf("_initialize_mn10300_tdep\n"); */
1222 register_gdbarch_init (bfd_arch_mn10300
, mn10300_gdbarch_init
);