1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
3 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
4 Free Software Foundation, Inc.
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. */
24 #include "arch-utils.h"
28 #include "gdb_string.h"
29 #include "gdb_assert.h"
30 #include "gdbcore.h" /* for write_memory_unsigned_integer */
34 #include "frame-unwind.h"
35 #include "frame-base.h"
36 #include "trad-frame.h"
38 #include "dwarf2-frame.h"
41 #include "mn10300-tdep.h"
44 extern struct trad_frame_cache
*mn10300_frame_unwind_cache (struct frame_info
*,
47 /* Compute the alignment required by a type. */
50 mn10300_type_align (struct type
*type
)
54 switch (TYPE_CODE (type
))
65 return TYPE_LENGTH (type
);
67 case TYPE_CODE_COMPLEX
:
68 return TYPE_LENGTH (type
) / 2;
70 case TYPE_CODE_STRUCT
:
72 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
74 int falign
= mn10300_type_align (TYPE_FIELD_TYPE (type
, i
));
75 while (align
< falign
)
81 /* HACK! Structures containing arrays, even small ones, are not
82 elligible for returning in registers. */
85 case TYPE_CODE_TYPEDEF
:
86 return mn10300_type_align (check_typedef (type
));
89 internal_error (__FILE__
, __LINE__
, _("bad switch"));
93 /* Should call_function allocate stack space for a struct return? */
95 mn10300_use_struct_convention (struct type
*type
)
97 /* Structures bigger than a pair of words can't be returned in
99 if (TYPE_LENGTH (type
) > 8)
102 switch (TYPE_CODE (type
))
104 case TYPE_CODE_STRUCT
:
105 case TYPE_CODE_UNION
:
106 /* Structures with a single field are handled as the field
108 if (TYPE_NFIELDS (type
) == 1)
109 return mn10300_use_struct_convention (TYPE_FIELD_TYPE (type
, 0));
111 /* Structures with word or double-word size are passed in memory, as
112 long as they require at least word alignment. */
113 if (mn10300_type_align (type
) >= 4)
118 /* Arrays are addressable, so they're never returned in
119 registers. This condition can only hold when the array is
120 the only field of a struct or union. */
121 case TYPE_CODE_ARRAY
:
124 case TYPE_CODE_TYPEDEF
:
125 return mn10300_use_struct_convention (check_typedef (type
));
133 mn10300_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
134 struct regcache
*regcache
, const void *valbuf
)
136 int len
= TYPE_LENGTH (type
);
139 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
144 regsz
= register_size (gdbarch
, reg
);
147 regcache_raw_write_part (regcache
, reg
, 0, len
, valbuf
);
148 else if (len
<= 2 * regsz
)
150 regcache_raw_write (regcache
, reg
, valbuf
);
151 gdb_assert (regsz
== register_size (gdbarch
, reg
+ 1));
152 regcache_raw_write_part (regcache
, reg
+1, 0,
153 len
- regsz
, (char *) valbuf
+ regsz
);
156 internal_error (__FILE__
, __LINE__
,
157 _("Cannot store return value %d bytes long."), len
);
161 mn10300_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
162 struct regcache
*regcache
, void *valbuf
)
164 char buf
[MAX_REGISTER_SIZE
];
165 int len
= TYPE_LENGTH (type
);
168 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
173 regsz
= register_size (gdbarch
, reg
);
176 regcache_raw_read (regcache
, reg
, buf
);
177 memcpy (valbuf
, buf
, len
);
179 else if (len
<= 2 * regsz
)
181 regcache_raw_read (regcache
, reg
, buf
);
182 memcpy (valbuf
, buf
, regsz
);
183 gdb_assert (regsz
== register_size (gdbarch
, reg
+ 1));
184 regcache_raw_read (regcache
, reg
+ 1, buf
);
185 memcpy ((char *) valbuf
+ regsz
, buf
, len
- regsz
);
188 internal_error (__FILE__
, __LINE__
,
189 _("Cannot extract return value %d bytes long."), len
);
192 /* Determine, for architecture GDBARCH, how a return value of TYPE
193 should be returned. If it is supposed to be returned in registers,
194 and READBUF is non-zero, read the appropriate value from REGCACHE,
195 and copy it into READBUF. If WRITEBUF is non-zero, write the value
196 from WRITEBUF into REGCACHE. */
198 static enum return_value_convention
199 mn10300_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
200 struct regcache
*regcache
, gdb_byte
*readbuf
,
201 const gdb_byte
*writebuf
)
203 if (mn10300_use_struct_convention (type
))
204 return RETURN_VALUE_STRUCT_CONVENTION
;
207 mn10300_extract_return_value (gdbarch
, type
, regcache
, readbuf
);
209 mn10300_store_return_value (gdbarch
, type
, regcache
, writebuf
);
211 return RETURN_VALUE_REGISTER_CONVENTION
;
215 register_name (int reg
, char **regs
, long sizeof_regs
)
217 if (reg
< 0 || reg
>= sizeof_regs
/ sizeof (regs
[0]))
224 mn10300_generic_register_name (int reg
)
226 static char *regs
[] =
227 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
228 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
229 "", "", "", "", "", "", "", "",
230 "", "", "", "", "", "", "", "fp"
232 return register_name (reg
, regs
, sizeof regs
);
237 am33_register_name (int reg
)
239 static char *regs
[] =
240 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
241 "sp", "pc", "mdr", "psw", "lir", "lar", "",
242 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
243 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
245 return register_name (reg
, regs
, sizeof regs
);
250 mn10300_register_type (struct gdbarch
*gdbarch
, int reg
)
252 return builtin_type_int
;
256 mn10300_read_pc (ptid_t ptid
)
258 return read_register_pid (E_PC_REGNUM
, ptid
);
262 mn10300_write_pc (CORE_ADDR val
, ptid_t ptid
)
264 return write_register_pid (E_PC_REGNUM
, val
, ptid
);
267 /* The breakpoint instruction must be the same size as the smallest
268 instruction in the instruction set.
270 The Matsushita mn10x00 processors have single byte instructions
271 so we need a single byte breakpoint. Matsushita hasn't defined
272 one, so we defined it ourselves. */
274 const static unsigned char *
275 mn10300_breakpoint_from_pc (CORE_ADDR
*bp_addr
, int *bp_size
)
277 static char breakpoint
[] = {0xff};
285 * status -- actually frame type (SP, FP, or last frame)
286 * stack size -- offset to the next frame
288 * The former might ultimately be stored in the frame_base.
289 * Seems like there'd be a way to store the later too.
291 * Temporarily supply empty stub functions as place holders.
295 my_frame_is_in_sp (struct frame_info
*fi
, void **this_cache
)
297 struct trad_frame_cache
*cache
= mn10300_frame_unwind_cache (fi
, this_cache
);
298 trad_frame_set_this_base (cache
,
299 frame_unwind_register_unsigned (fi
,
304 my_frame_is_in_fp (struct frame_info
*fi
, void **this_cache
)
306 struct trad_frame_cache
*cache
= mn10300_frame_unwind_cache (fi
, this_cache
);
307 trad_frame_set_this_base (cache
,
308 frame_unwind_register_unsigned (fi
,
313 my_frame_is_last (struct frame_info
*fi
)
318 is_my_frame_in_sp (struct frame_info
*fi
)
324 is_my_frame_in_fp (struct frame_info
*fi
)
330 is_my_frame_last (struct frame_info
*fi
)
336 set_my_stack_size (struct frame_info
*fi
, CORE_ADDR size
)
341 /* Set offsets of registers saved by movm instruction.
342 This is a helper function for mn10300_analyze_prologue. */
345 set_movm_offsets (struct frame_info
*fi
,
349 struct trad_frame_cache
*cache
;
353 if (fi
== NULL
|| this_cache
== NULL
)
356 cache
= mn10300_frame_unwind_cache (fi
, this_cache
);
360 base
= trad_frame_get_this_base (cache
);
361 if (movm_args
& movm_other_bit
)
363 /* The `other' bit leaves a blank area of four bytes at the
364 beginning of its block of saved registers, making it 32 bytes
366 trad_frame_set_reg_addr (cache
, E_LAR_REGNUM
, base
+ offset
+ 4);
367 trad_frame_set_reg_addr (cache
, E_LIR_REGNUM
, base
+ offset
+ 8);
368 trad_frame_set_reg_addr (cache
, E_MDR_REGNUM
, base
+ offset
+ 12);
369 trad_frame_set_reg_addr (cache
, E_A0_REGNUM
+ 1, base
+ offset
+ 16);
370 trad_frame_set_reg_addr (cache
, E_A0_REGNUM
, base
+ offset
+ 20);
371 trad_frame_set_reg_addr (cache
, E_D0_REGNUM
+ 1, base
+ offset
+ 24);
372 trad_frame_set_reg_addr (cache
, E_D0_REGNUM
, base
+ offset
+ 28);
376 if (movm_args
& movm_a3_bit
)
378 trad_frame_set_reg_addr (cache
, E_A3_REGNUM
, base
+ offset
);
381 if (movm_args
& movm_a2_bit
)
383 trad_frame_set_reg_addr (cache
, E_A2_REGNUM
, base
+ offset
);
386 if (movm_args
& movm_d3_bit
)
388 trad_frame_set_reg_addr (cache
, E_D3_REGNUM
, base
+ offset
);
391 if (movm_args
& movm_d2_bit
)
393 trad_frame_set_reg_addr (cache
, E_D2_REGNUM
, base
+ offset
);
398 if (movm_args
& movm_exother_bit
)
400 trad_frame_set_reg_addr (cache
, E_MCVF_REGNUM
, base
+ offset
);
401 trad_frame_set_reg_addr (cache
, E_MCRL_REGNUM
, base
+ offset
+ 4);
402 trad_frame_set_reg_addr (cache
, E_MCRH_REGNUM
, base
+ offset
+ 8);
403 trad_frame_set_reg_addr (cache
, E_MDRQ_REGNUM
, base
+ offset
+ 12);
404 trad_frame_set_reg_addr (cache
, E_E1_REGNUM
, base
+ offset
+ 16);
405 trad_frame_set_reg_addr (cache
, E_E0_REGNUM
, base
+ offset
+ 20);
408 if (movm_args
& movm_exreg1_bit
)
410 trad_frame_set_reg_addr (cache
, E_E7_REGNUM
, base
+ offset
);
411 trad_frame_set_reg_addr (cache
, E_E6_REGNUM
, base
+ offset
+ 4);
412 trad_frame_set_reg_addr (cache
, E_E5_REGNUM
, base
+ offset
+ 8);
413 trad_frame_set_reg_addr (cache
, E_E4_REGNUM
, base
+ offset
+ 12);
416 if (movm_args
& movm_exreg0_bit
)
418 trad_frame_set_reg_addr (cache
, E_E3_REGNUM
, base
+ offset
);
419 trad_frame_set_reg_addr (cache
, E_E2_REGNUM
, base
+ offset
+ 4);
423 /* The last (or first) thing on the stack will be the PC. */
424 trad_frame_set_reg_addr (cache
, E_PC_REGNUM
, base
+ offset
);
425 /* Save the SP in the 'traditional' way.
426 This will be the same location where the PC is saved. */
427 trad_frame_set_reg_value (cache
, E_SP_REGNUM
, base
+ offset
);
430 /* The main purpose of this file is dealing with prologues to extract
431 information about stack frames and saved registers.
433 In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
434 function is pretty readable, and has a nice explanation of how the
435 prologue is generated. The prologues generated by that code will
436 have the following form (NOTE: the current code doesn't handle all
439 + If this is an old-style varargs function, then its arguments
440 need to be flushed back to the stack:
445 + If we use any of the callee-saved registers, save them now.
447 movm [some callee-saved registers],(sp)
449 + If we have any floating-point registers to save:
451 - Decrement the stack pointer to reserve space for the registers.
452 If the function doesn't need a frame pointer, we may combine
453 this with the adjustment that reserves space for the frame.
457 - Save the floating-point registers. We have two possible
460 . Save them at fixed offset from the SP:
462 fmov fsN,(OFFSETN,sp)
463 fmov fsM,(OFFSETM,sp)
466 Note that, if OFFSETN happens to be zero, you'll get the
467 different opcode: fmov fsN,(sp)
469 . Or, set a0 to the start of the save area, and then use
470 post-increment addressing to save the FP registers.
478 + If the function needs a frame pointer, we set it here.
482 + Now we reserve space for the stack frame proper. This could be
483 merged into the `add -SIZE, sp' instruction for FP saves up
484 above, unless we needed to set the frame pointer in the previous
485 step, or the frame is so large that allocating the whole thing at
486 once would put the FP register save slots out of reach of the
487 addressing mode (128 bytes).
491 One day we might keep the stack pointer constant, that won't
492 change the code for prologues, but it will make the frame
493 pointerless case much more common. */
495 /* Analyze the prologue to determine where registers are saved,
496 the end of the prologue, etc etc. Return the end of the prologue
499 We store into FI (if non-null) several tidbits of information:
501 * stack_size -- size of this stack frame. Note that if we stop in
502 certain parts of the prologue/epilogue we may claim the size of the
503 current frame is zero. This happens when the current frame has
504 not been allocated yet or has already been deallocated.
506 * fsr -- Addresses of registers saved in the stack by this frame.
508 * status -- A (relatively) generic status indicator. It's a bitmask
509 with the following bits:
511 MY_FRAME_IN_SP: The base of the current frame is actually in
512 the stack pointer. This can happen for frame pointerless
513 functions, or cases where we're stopped in the prologue/epilogue
514 itself. For these cases mn10300_analyze_prologue will need up
515 update fi->frame before returning or analyzing the register
518 MY_FRAME_IN_FP: The base of the current frame is in the
519 frame pointer register ($a3).
521 NO_MORE_FRAMES: Set this if the current frame is "start" or
522 if the first instruction looks like mov <imm>,sp. This tells
523 frame chain to not bother trying to unwind past this frame. */
526 mn10300_analyze_prologue (struct frame_info
*fi
,
530 CORE_ADDR func_addr
, func_end
, addr
, stop
;
533 unsigned char buf
[4];
534 int status
, movm_args
= 0;
537 /* Use the PC in the frame if it's provided to look up the
538 start of this function.
540 Note: kevinb/2003-07-16: We used to do the following here:
541 pc = (fi ? get_frame_pc (fi) : pc);
542 But this is (now) badly broken when called from analyze_dummy_frame().
546 pc
= (pc
? pc
: get_frame_pc (fi
));
547 /* At the start of a function our frame is in the stack pointer. */
548 my_frame_is_in_sp (fi
, this_cache
);
551 /* Find the start of this function. */
552 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
554 /* Do nothing if we couldn't find the start of this function
556 MVS: comment went on to say "or if we're stopped at the first
557 instruction in the prologue" -- but code doesn't reflect that,
558 and I don't want to do that anyway. */
564 /* If we're in start, then give up. */
565 if (strcmp (name
, "start") == 0)
568 my_frame_is_last (fi
);
573 /* Get the next two bytes into buf, we need two because rets is a two
574 byte insn and the first isn't enough to uniquely identify it. */
575 status
= deprecated_read_memory_nobpt (pc
, buf
, 2);
579 /* Note: kevinb/2003-07-16: We shouldn't be making these sorts of
580 changes to the frame in prologue examination code. */
581 /* If we're physically on an "rets" instruction, then our frame has
582 already been deallocated. Note this can also be true for retf
583 and ret if they specify a size of zero.
585 In this case fi->frame is bogus, we need to fix it. */
586 if (fi
&& buf
[0] == 0xf0 && buf
[1] == 0xfc)
588 if (get_next_frame (fi
) == NULL
)
589 deprecated_update_frame_base_hack (fi
, read_sp ());
590 return get_frame_pc (fi
);
593 /* Similarly if we're stopped on the first insn of a prologue as our
594 frame hasn't been allocated yet. */
595 if (fi
&& get_frame_pc (fi
) == func_addr
)
597 if (get_next_frame (fi
) == NULL
)
598 deprecated_update_frame_base_hack (fi
, read_sp ());
599 return get_frame_pc (fi
);
603 /* NOTE: from here on, we don't want to return without jumping to
607 /* Figure out where to stop scanning. */
608 stop
= fi
? pc
: func_end
;
610 /* Don't walk off the end of the function. */
611 stop
= stop
> func_end
? func_end
: stop
;
613 /* Start scanning on the first instruction of this function. */
616 /* Suck in two bytes. */
618 || (status
= deprecated_read_memory_nobpt (addr
, buf
, 2)) != 0)
619 goto finish_prologue
;
621 /* First see if this insn sets the stack pointer from a register; if
622 so, it's probably the initialization of the stack pointer in _start,
623 so mark this as the bottom-most frame. */
624 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
627 my_frame_is_last (fi
);
628 goto finish_prologue
;
631 /* Now look for movm [regs],sp, which saves the callee saved registers.
633 At this time we don't know if fi->frame is valid, so we only note
634 that we encountered a movm instruction. Later, we'll set the entries
635 in fsr.regs as needed. */
638 /* Extract the register list for the movm instruction. */
643 /* Quit now if we're beyond the stop point. */
645 goto finish_prologue
;
647 /* Get the next two bytes so the prologue scan can continue. */
648 status
= deprecated_read_memory_nobpt (addr
, buf
, 2);
650 goto finish_prologue
;
653 /* Now see if we set up a frame pointer via "mov sp,a3" */
658 /* The frame pointer is now valid. */
661 my_frame_is_in_fp (fi
, this_cache
);
664 /* Quit now if we're beyond the stop point. */
666 goto finish_prologue
;
668 /* Get two more bytes so scanning can continue. */
669 status
= deprecated_read_memory_nobpt (addr
, buf
, 2);
671 goto finish_prologue
;
674 /* Next we should allocate the local frame. No more prologue insns
675 are found after allocating the local frame.
677 Search for add imm8,sp (0xf8feXX)
678 or add imm16,sp (0xfafeXXXX)
679 or add imm32,sp (0xfcfeXXXXXXXX).
681 If none of the above was found, then this prologue has no
685 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
687 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
689 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
694 /* Suck in imm_size more bytes, they'll hold the size of the
696 status
= deprecated_read_memory_nobpt (addr
+ 2, buf
, imm_size
);
698 goto finish_prologue
;
700 /* Note the size of the stack in the frame info structure. */
701 stack_size
= extract_signed_integer (buf
, imm_size
);
703 set_my_stack_size (fi
, stack_size
);
705 /* We just consumed 2 + imm_size bytes. */
706 addr
+= 2 + imm_size
;
708 /* No more prologue insns follow, so begin preparation to return. */
709 goto finish_prologue
;
711 /* Do the essentials and get out of here. */
713 /* Note if/where callee saved registers were saved. */
715 set_movm_offsets (fi
, this_cache
, movm_args
);
719 /* Function: skip_prologue
720 Return the address of the first inst past the prologue of the function. */
723 mn10300_skip_prologue (CORE_ADDR pc
)
725 return mn10300_analyze_prologue (NULL
, NULL
, pc
);
728 /* Simple frame_unwind_cache.
729 This finds the "extra info" for the frame. */
730 struct trad_frame_cache
*
731 mn10300_frame_unwind_cache (struct frame_info
*next_frame
,
732 void **this_prologue_cache
)
734 struct trad_frame_cache
*cache
;
735 CORE_ADDR pc
, start
, end
;
737 if (*this_prologue_cache
)
738 return (*this_prologue_cache
);
740 cache
= trad_frame_cache_zalloc (next_frame
);
741 pc
= gdbarch_unwind_pc (current_gdbarch
, next_frame
);
742 mn10300_analyze_prologue (next_frame
, (void **) &cache
, pc
);
743 if (find_pc_partial_function (pc
, NULL
, &start
, &end
))
744 trad_frame_set_id (cache
,
745 frame_id_build (trad_frame_get_this_base (cache
),
748 trad_frame_set_id (cache
,
749 frame_id_build (trad_frame_get_this_base (cache
),
750 frame_func_unwind (next_frame
)));
752 (*this_prologue_cache
) = cache
;
756 /* Here is a dummy implementation. */
757 static struct frame_id
758 mn10300_unwind_dummy_id (struct gdbarch
*gdbarch
,
759 struct frame_info
*next_frame
)
761 return frame_id_build (frame_sp_unwind (next_frame
),
762 frame_pc_unwind (next_frame
));
765 /* Trad frame implementation. */
767 mn10300_frame_this_id (struct frame_info
*next_frame
,
768 void **this_prologue_cache
,
769 struct frame_id
*this_id
)
771 struct trad_frame_cache
*cache
=
772 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
774 trad_frame_get_id (cache
, this_id
);
778 mn10300_frame_prev_register (struct frame_info
*next_frame
,
779 void **this_prologue_cache
,
780 int regnum
, int *optimizedp
,
781 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
782 int *realnump
, void *bufferp
)
784 struct trad_frame_cache
*cache
=
785 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
787 trad_frame_get_register (cache
, next_frame
, regnum
, optimizedp
,
788 lvalp
, addrp
, realnump
, bufferp
);
790 trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum,
791 optimizedp, lvalp, addrp, realnump, bufferp);
795 static const struct frame_unwind mn10300_frame_unwind
= {
797 mn10300_frame_this_id
,
798 mn10300_frame_prev_register
802 mn10300_frame_base_address (struct frame_info
*next_frame
,
803 void **this_prologue_cache
)
805 struct trad_frame_cache
*cache
=
806 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
808 return trad_frame_get_this_base (cache
);
811 static const struct frame_unwind
*
812 mn10300_frame_sniffer (struct frame_info
*next_frame
)
814 return &mn10300_frame_unwind
;
817 static const struct frame_base mn10300_frame_base
= {
818 &mn10300_frame_unwind
,
819 mn10300_frame_base_address
,
820 mn10300_frame_base_address
,
821 mn10300_frame_base_address
825 mn10300_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
829 frame_unwind_unsigned_register (next_frame
, E_PC_REGNUM
, &pc
);
834 mn10300_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
838 frame_unwind_unsigned_register (next_frame
, E_SP_REGNUM
, &sp
);
843 mn10300_frame_unwind_init (struct gdbarch
*gdbarch
)
845 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
846 frame_unwind_append_sniffer (gdbarch
, mn10300_frame_sniffer
);
847 frame_base_set_default (gdbarch
, &mn10300_frame_base
);
848 set_gdbarch_unwind_dummy_id (gdbarch
, mn10300_unwind_dummy_id
);
849 set_gdbarch_unwind_pc (gdbarch
, mn10300_unwind_pc
);
850 set_gdbarch_unwind_sp (gdbarch
, mn10300_unwind_sp
);
853 /* Function: push_dummy_call
855 * Set up machine state for a target call, including
856 * function arguments, stack, return address, etc.
861 mn10300_push_dummy_call (struct gdbarch
*gdbarch
,
862 struct value
*target_func
,
863 struct regcache
*regcache
,
865 int nargs
, struct value
**args
,
868 CORE_ADDR struct_addr
)
870 const int push_size
= register_size (gdbarch
, E_PC_REGNUM
);
873 int stack_offset
= 0;
875 char *val
, valbuf
[MAX_REGISTER_SIZE
];
877 /* This should be a nop, but align the stack just in case something
878 went wrong. Stacks are four byte aligned on the mn10300. */
881 /* Now make space on the stack for the args.
883 XXX This doesn't appear to handle pass-by-invisible reference
885 regs_used
= struct_return
? 1 : 0;
886 for (len
= 0, argnum
= 0; argnum
< nargs
; argnum
++)
888 arg_len
= (TYPE_LENGTH (value_type (args
[argnum
])) + 3) & ~3;
889 while (regs_used
< 2 && arg_len
> 0)
892 arg_len
-= push_size
;
897 /* Allocate stack space. */
903 write_register (E_D0_REGNUM
, struct_addr
);
908 /* Push all arguments onto the stack. */
909 for (argnum
= 0; argnum
< nargs
; argnum
++)
911 /* FIXME what about structs? Unions? */
912 if (TYPE_CODE (value_type (*args
)) == TYPE_CODE_STRUCT
913 && TYPE_LENGTH (value_type (*args
)) > 8)
915 /* Change to pointer-to-type. */
917 store_unsigned_integer (valbuf
, push_size
,
918 VALUE_ADDRESS (*args
));
923 arg_len
= TYPE_LENGTH (value_type (*args
));
924 val
= (char *) value_contents (*args
);
927 while (regs_used
< 2 && arg_len
> 0)
929 write_register (regs_used
,
930 extract_unsigned_integer (val
, push_size
));
932 arg_len
-= push_size
;
938 write_memory (sp
+ stack_offset
, val
, push_size
);
939 arg_len
-= push_size
;
941 stack_offset
+= push_size
;
947 /* Make space for the flushback area. */
950 /* Push the return address that contains the magic breakpoint. */
952 write_memory_unsigned_integer (sp
, push_size
, bp_addr
);
954 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
959 static struct gdbarch
*
960 mn10300_gdbarch_init (struct gdbarch_info info
,
961 struct gdbarch_list
*arches
)
963 struct gdbarch
*gdbarch
;
964 struct gdbarch_tdep
*tdep
;
966 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
968 return arches
->gdbarch
;
970 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
971 gdbarch
= gdbarch_alloc (&info
, tdep
);
973 switch (info
.bfd_arch_info
->mach
)
976 case bfd_mach_mn10300
:
977 set_gdbarch_register_name (gdbarch
, mn10300_generic_register_name
);
981 set_gdbarch_register_name (gdbarch
, am33_register_name
);
985 internal_error (__FILE__
, __LINE__
,
986 _("mn10300_gdbarch_init: Unknown mn10300 variant"));
991 set_gdbarch_num_regs (gdbarch
, E_NUM_REGS
);
992 set_gdbarch_register_type (gdbarch
, mn10300_register_type
);
993 set_gdbarch_skip_prologue (gdbarch
, mn10300_skip_prologue
);
994 set_gdbarch_read_pc (gdbarch
, mn10300_read_pc
);
995 set_gdbarch_write_pc (gdbarch
, mn10300_write_pc
);
996 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
997 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
999 /* Stack unwinding. */
1000 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1002 set_gdbarch_breakpoint_from_pc (gdbarch
, mn10300_breakpoint_from_pc
);
1003 /* decr_pc_after_break? */
1005 set_gdbarch_print_insn (gdbarch
, print_insn_mn10300
);
1008 set_gdbarch_return_value (gdbarch
, mn10300_return_value
);
1010 /* Stage 3 -- get target calls working. */
1011 set_gdbarch_push_dummy_call (gdbarch
, mn10300_push_dummy_call
);
1012 /* set_gdbarch_return_value (store, extract) */
1015 mn10300_frame_unwind_init (gdbarch
);
1017 /* Hook in ABI-specific overrides, if they have been registered. */
1018 gdbarch_init_osabi (info
, gdbarch
);
1023 /* Dump out the mn10300 specific architecture information. */
1026 mn10300_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1028 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1029 fprintf_unfiltered (file
, "mn10300_dump_tdep: am33_mode = %d\n",
1034 _initialize_mn10300_tdep (void)
1036 gdbarch_register (bfd_arch_mn10300
, mn10300_gdbarch_init
, mn10300_dump_tdep
);