1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
3 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
4 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 /* MVS note this is deprecated. */
94 /* Should call_function allocate stack space for a struct return? */
97 mn10300_use_struct_convention (int gcc_p
, struct type
*type
)
99 /* Structures bigger than a pair of words can't be returned in
101 if (TYPE_LENGTH (type
) > 8)
104 switch (TYPE_CODE (type
))
106 case TYPE_CODE_STRUCT
:
107 case TYPE_CODE_UNION
:
108 /* Structures with a single field are handled as the field
110 if (TYPE_NFIELDS (type
) == 1)
111 return mn10300_use_struct_convention (gcc_p
,
112 TYPE_FIELD_TYPE (type
, 0));
114 /* Structures with word or double-word size are passed in memory, as
115 long as they require at least word alignment. */
116 if (mn10300_type_align (type
) >= 4)
121 /* Arrays are addressable, so they're never returned in
122 registers. This condition can only hold when the array is
123 the only field of a struct or union. */
124 case TYPE_CODE_ARRAY
:
127 case TYPE_CODE_TYPEDEF
:
128 return mn10300_use_struct_convention (gcc_p
, check_typedef (type
));
135 /* MVS note this is deprecated. */
137 mn10300_store_return_value (struct type
*type
,
138 struct regcache
*regcache
, const void *valbuf
)
140 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
141 int len
= TYPE_LENGTH (type
);
144 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
149 regsz
= register_size (gdbarch
, reg
);
152 regcache_raw_write_part (regcache
, reg
, 0, len
, valbuf
);
153 else if (len
<= 2 * regsz
)
155 regcache_raw_write (regcache
, reg
, valbuf
);
156 gdb_assert (regsz
== register_size (gdbarch
, reg
+ 1));
157 regcache_raw_write_part (regcache
, reg
+1, 0,
158 len
- regsz
, (char *) valbuf
+ regsz
);
161 internal_error (__FILE__
, __LINE__
,
162 _("Cannot store return value %d bytes long."), len
);
165 /* MVS note deprecated. */
167 mn10300_extract_return_value (struct type
*type
,
168 struct regcache
*regcache
, void *valbuf
)
170 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
171 char buf
[MAX_REGISTER_SIZE
];
172 int len
= TYPE_LENGTH (type
);
175 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
180 regsz
= register_size (gdbarch
, reg
);
183 regcache_raw_read (regcache
, reg
, buf
);
184 memcpy (valbuf
, buf
, len
);
186 else if (len
<= 2 * regsz
)
188 regcache_raw_read (regcache
, reg
, buf
);
189 memcpy (valbuf
, buf
, regsz
);
190 gdb_assert (regsz
== register_size (gdbarch
, reg
+ 1));
191 regcache_raw_read (regcache
, reg
+ 1, buf
);
192 memcpy ((char *) valbuf
+ regsz
, buf
, len
- regsz
);
195 internal_error (__FILE__
, __LINE__
,
196 _("Cannot extract return value %d bytes long."), len
);
200 register_name (int reg
, char **regs
, long sizeof_regs
)
202 if (reg
< 0 || reg
>= sizeof_regs
/ sizeof (regs
[0]))
209 mn10300_generic_register_name (int reg
)
211 static char *regs
[] =
212 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
213 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
214 "", "", "", "", "", "", "", "",
215 "", "", "", "", "", "", "", "fp"
217 return register_name (reg
, regs
, sizeof regs
);
222 am33_register_name (int reg
)
224 static char *regs
[] =
225 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
226 "sp", "pc", "mdr", "psw", "lir", "lar", "",
227 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
228 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
230 return register_name (reg
, regs
, sizeof regs
);
235 mn10300_register_type (struct gdbarch
*gdbarch
, int reg
)
237 return builtin_type_int
;
241 mn10300_read_pc (ptid_t ptid
)
243 return read_register_pid (E_PC_REGNUM
, ptid
);
247 mn10300_write_pc (CORE_ADDR val
, ptid_t ptid
)
249 return write_register_pid (E_PC_REGNUM
, val
, ptid
);
252 /* The breakpoint instruction must be the same size as the smallest
253 instruction in the instruction set.
255 The Matsushita mn10x00 processors have single byte instructions
256 so we need a single byte breakpoint. Matsushita hasn't defined
257 one, so we defined it ourselves. */
259 const static unsigned char *
260 mn10300_breakpoint_from_pc (CORE_ADDR
*bp_addr
, int *bp_size
)
262 static char breakpoint
[] = {0xff};
270 * status -- actually frame type (SP, FP, or last frame)
271 * stack size -- offset to the next frame
273 * The former might ultimately be stored in the frame_base.
274 * Seems like there'd be a way to store the later too.
276 * Temporarily supply empty stub functions as place holders.
280 my_frame_is_in_sp (struct frame_info
*fi
, void **this_cache
)
282 struct trad_frame_cache
*cache
= mn10300_frame_unwind_cache (fi
, this_cache
);
283 trad_frame_set_this_base (cache
,
284 frame_unwind_register_unsigned (fi
,
289 my_frame_is_in_fp (struct frame_info
*fi
, void **this_cache
)
291 struct trad_frame_cache
*cache
= mn10300_frame_unwind_cache (fi
, this_cache
);
292 trad_frame_set_this_base (cache
,
293 frame_unwind_register_unsigned (fi
,
298 my_frame_is_last (struct frame_info
*fi
)
303 is_my_frame_in_sp (struct frame_info
*fi
)
309 is_my_frame_in_fp (struct frame_info
*fi
)
315 is_my_frame_last (struct frame_info
*fi
)
321 set_my_stack_size (struct frame_info
*fi
, CORE_ADDR size
)
326 /* Set offsets of registers saved by movm instruction.
327 This is a helper function for mn10300_analyze_prologue. */
330 set_movm_offsets (struct frame_info
*fi
,
334 struct trad_frame_cache
*cache
;
338 if (fi
== NULL
|| this_cache
== NULL
)
341 cache
= mn10300_frame_unwind_cache (fi
, this_cache
);
345 base
= trad_frame_get_this_base (cache
);
346 if (movm_args
& movm_other_bit
)
348 /* The `other' bit leaves a blank area of four bytes at the
349 beginning of its block of saved registers, making it 32 bytes
351 trad_frame_set_reg_addr (cache
, E_LAR_REGNUM
, base
+ offset
+ 4);
352 trad_frame_set_reg_addr (cache
, E_LIR_REGNUM
, base
+ offset
+ 8);
353 trad_frame_set_reg_addr (cache
, E_MDR_REGNUM
, base
+ offset
+ 12);
354 trad_frame_set_reg_addr (cache
, E_A0_REGNUM
+ 1, base
+ offset
+ 16);
355 trad_frame_set_reg_addr (cache
, E_A0_REGNUM
, base
+ offset
+ 20);
356 trad_frame_set_reg_addr (cache
, E_D0_REGNUM
+ 1, base
+ offset
+ 24);
357 trad_frame_set_reg_addr (cache
, E_D0_REGNUM
, base
+ offset
+ 28);
361 if (movm_args
& movm_a3_bit
)
363 trad_frame_set_reg_addr (cache
, E_A3_REGNUM
, base
+ offset
);
366 if (movm_args
& movm_a2_bit
)
368 trad_frame_set_reg_addr (cache
, E_A2_REGNUM
, base
+ offset
);
371 if (movm_args
& movm_d3_bit
)
373 trad_frame_set_reg_addr (cache
, E_D3_REGNUM
, base
+ offset
);
376 if (movm_args
& movm_d2_bit
)
378 trad_frame_set_reg_addr (cache
, E_D2_REGNUM
, base
+ offset
);
383 if (movm_args
& movm_exother_bit
)
385 trad_frame_set_reg_addr (cache
, E_MCVF_REGNUM
, base
+ offset
);
386 trad_frame_set_reg_addr (cache
, E_MCRL_REGNUM
, base
+ offset
+ 4);
387 trad_frame_set_reg_addr (cache
, E_MCRH_REGNUM
, base
+ offset
+ 8);
388 trad_frame_set_reg_addr (cache
, E_MDRQ_REGNUM
, base
+ offset
+ 12);
389 trad_frame_set_reg_addr (cache
, E_E1_REGNUM
, base
+ offset
+ 16);
390 trad_frame_set_reg_addr (cache
, E_E0_REGNUM
, base
+ offset
+ 20);
393 if (movm_args
& movm_exreg1_bit
)
395 trad_frame_set_reg_addr (cache
, E_E7_REGNUM
, base
+ offset
);
396 trad_frame_set_reg_addr (cache
, E_E6_REGNUM
, base
+ offset
+ 4);
397 trad_frame_set_reg_addr (cache
, E_E5_REGNUM
, base
+ offset
+ 8);
398 trad_frame_set_reg_addr (cache
, E_E4_REGNUM
, base
+ offset
+ 12);
401 if (movm_args
& movm_exreg0_bit
)
403 trad_frame_set_reg_addr (cache
, E_E3_REGNUM
, base
+ offset
);
404 trad_frame_set_reg_addr (cache
, E_E2_REGNUM
, base
+ offset
+ 4);
408 /* The last (or first) thing on the stack will be the PC. */
409 trad_frame_set_reg_addr (cache
, E_PC_REGNUM
, base
+ offset
);
410 /* Save the SP in the 'traditional' way.
411 This will be the same location where the PC is saved. */
412 trad_frame_set_reg_value (cache
, E_SP_REGNUM
, base
+ offset
);
415 /* The main purpose of this file is dealing with prologues to extract
416 information about stack frames and saved registers.
418 In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
419 function is pretty readable, and has a nice explanation of how the
420 prologue is generated. The prologues generated by that code will
421 have the following form (NOTE: the current code doesn't handle all
424 + If this is an old-style varargs function, then its arguments
425 need to be flushed back to the stack:
430 + If we use any of the callee-saved registers, save them now.
432 movm [some callee-saved registers],(sp)
434 + If we have any floating-point registers to save:
436 - Decrement the stack pointer to reserve space for the registers.
437 If the function doesn't need a frame pointer, we may combine
438 this with the adjustment that reserves space for the frame.
442 - Save the floating-point registers. We have two possible
445 . Save them at fixed offset from the SP:
447 fmov fsN,(OFFSETN,sp)
448 fmov fsM,(OFFSETM,sp)
451 Note that, if OFFSETN happens to be zero, you'll get the
452 different opcode: fmov fsN,(sp)
454 . Or, set a0 to the start of the save area, and then use
455 post-increment addressing to save the FP registers.
463 + If the function needs a frame pointer, we set it here.
467 + Now we reserve space for the stack frame proper. This could be
468 merged into the `add -SIZE, sp' instruction for FP saves up
469 above, unless we needed to set the frame pointer in the previous
470 step, or the frame is so large that allocating the whole thing at
471 once would put the FP register save slots out of reach of the
472 addressing mode (128 bytes).
476 One day we might keep the stack pointer constant, that won't
477 change the code for prologues, but it will make the frame
478 pointerless case much more common. */
480 /* Analyze the prologue to determine where registers are saved,
481 the end of the prologue, etc etc. Return the end of the prologue
484 We store into FI (if non-null) several tidbits of information:
486 * stack_size -- size of this stack frame. Note that if we stop in
487 certain parts of the prologue/epilogue we may claim the size of the
488 current frame is zero. This happens when the current frame has
489 not been allocated yet or has already been deallocated.
491 * fsr -- Addresses of registers saved in the stack by this frame.
493 * status -- A (relatively) generic status indicator. It's a bitmask
494 with the following bits:
496 MY_FRAME_IN_SP: The base of the current frame is actually in
497 the stack pointer. This can happen for frame pointerless
498 functions, or cases where we're stopped in the prologue/epilogue
499 itself. For these cases mn10300_analyze_prologue will need up
500 update fi->frame before returning or analyzing the register
503 MY_FRAME_IN_FP: The base of the current frame is in the
504 frame pointer register ($a3).
506 NO_MORE_FRAMES: Set this if the current frame is "start" or
507 if the first instruction looks like mov <imm>,sp. This tells
508 frame chain to not bother trying to unwind past this frame. */
511 mn10300_analyze_prologue (struct frame_info
*fi
,
515 CORE_ADDR func_addr
, func_end
, addr
, stop
;
518 unsigned char buf
[4];
519 int status
, movm_args
= 0;
522 /* Use the PC in the frame if it's provided to look up the
523 start of this function.
525 Note: kevinb/2003-07-16: We used to do the following here:
526 pc = (fi ? get_frame_pc (fi) : pc);
527 But this is (now) badly broken when called from analyze_dummy_frame().
531 pc
= (pc
? pc
: get_frame_pc (fi
));
532 /* At the start of a function our frame is in the stack pointer. */
533 my_frame_is_in_sp (fi
, this_cache
);
536 /* Find the start of this function. */
537 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
539 /* Do nothing if we couldn't find the start of this function
541 MVS: comment went on to say "or if we're stopped at the first
542 instruction in the prologue" -- but code doesn't reflect that,
543 and I don't want to do that anyway. */
549 /* If we're in start, then give up. */
550 if (strcmp (name
, "start") == 0)
553 my_frame_is_last (fi
);
558 /* Get the next two bytes into buf, we need two because rets is a two
559 byte insn and the first isn't enough to uniquely identify it. */
560 status
= deprecated_read_memory_nobpt (pc
, buf
, 2);
564 /* Note: kevinb/2003-07-16: We shouldn't be making these sorts of
565 changes to the frame in prologue examination code. */
566 /* If we're physically on an "rets" instruction, then our frame has
567 already been deallocated. Note this can also be true for retf
568 and ret if they specify a size of zero.
570 In this case fi->frame is bogus, we need to fix it. */
571 if (fi
&& buf
[0] == 0xf0 && buf
[1] == 0xfc)
573 if (get_next_frame (fi
) == NULL
)
574 deprecated_update_frame_base_hack (fi
, read_sp ());
575 return get_frame_pc (fi
);
578 /* Similarly if we're stopped on the first insn of a prologue as our
579 frame hasn't been allocated yet. */
580 if (fi
&& get_frame_pc (fi
) == func_addr
)
582 if (get_next_frame (fi
) == NULL
)
583 deprecated_update_frame_base_hack (fi
, read_sp ());
584 return get_frame_pc (fi
);
588 /* NOTE: from here on, we don't want to return without jumping to
592 /* Figure out where to stop scanning. */
593 stop
= fi
? pc
: func_end
;
595 /* Don't walk off the end of the function. */
596 stop
= stop
> func_end
? func_end
: stop
;
598 /* Start scanning on the first instruction of this function. */
601 /* Suck in two bytes. */
603 || (status
= deprecated_read_memory_nobpt (addr
, buf
, 2)) != 0)
604 goto finish_prologue
;
606 /* First see if this insn sets the stack pointer from a register; if
607 so, it's probably the initialization of the stack pointer in _start,
608 so mark this as the bottom-most frame. */
609 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
612 my_frame_is_last (fi
);
613 goto finish_prologue
;
616 /* Now look for movm [regs],sp, which saves the callee saved registers.
618 At this time we don't know if fi->frame is valid, so we only note
619 that we encountered a movm instruction. Later, we'll set the entries
620 in fsr.regs as needed. */
623 /* Extract the register list for the movm instruction. */
628 /* Quit now if we're beyond the stop point. */
630 goto finish_prologue
;
632 /* Get the next two bytes so the prologue scan can continue. */
633 status
= deprecated_read_memory_nobpt (addr
, buf
, 2);
635 goto finish_prologue
;
638 /* Now see if we set up a frame pointer via "mov sp,a3" */
643 /* The frame pointer is now valid. */
646 my_frame_is_in_fp (fi
, this_cache
);
649 /* Quit now if we're beyond the stop point. */
651 goto finish_prologue
;
653 /* Get two more bytes so scanning can continue. */
654 status
= deprecated_read_memory_nobpt (addr
, buf
, 2);
656 goto finish_prologue
;
659 /* Next we should allocate the local frame. No more prologue insns
660 are found after allocating the local frame.
662 Search for add imm8,sp (0xf8feXX)
663 or add imm16,sp (0xfafeXXXX)
664 or add imm32,sp (0xfcfeXXXXXXXX).
666 If none of the above was found, then this prologue has no
670 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
672 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
674 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
679 /* Suck in imm_size more bytes, they'll hold the size of the
681 status
= deprecated_read_memory_nobpt (addr
+ 2, buf
, imm_size
);
683 goto finish_prologue
;
685 /* Note the size of the stack in the frame info structure. */
686 stack_size
= extract_signed_integer (buf
, imm_size
);
688 set_my_stack_size (fi
, stack_size
);
690 /* We just consumed 2 + imm_size bytes. */
691 addr
+= 2 + imm_size
;
693 /* No more prologue insns follow, so begin preparation to return. */
694 goto finish_prologue
;
696 /* Do the essentials and get out of here. */
698 /* Note if/where callee saved registers were saved. */
700 set_movm_offsets (fi
, this_cache
, movm_args
);
704 /* Function: skip_prologue
705 Return the address of the first inst past the prologue of the function. */
708 mn10300_skip_prologue (CORE_ADDR pc
)
710 return mn10300_analyze_prologue (NULL
, NULL
, pc
);
713 /* Simple frame_unwind_cache.
714 This finds the "extra info" for the frame. */
715 struct trad_frame_cache
*
716 mn10300_frame_unwind_cache (struct frame_info
*next_frame
,
717 void **this_prologue_cache
)
719 struct trad_frame_cache
*cache
;
720 CORE_ADDR pc
, start
, end
;
722 if (*this_prologue_cache
)
723 return (*this_prologue_cache
);
725 cache
= trad_frame_cache_zalloc (next_frame
);
726 pc
= gdbarch_unwind_pc (current_gdbarch
, next_frame
);
727 mn10300_analyze_prologue (next_frame
, (void **) &cache
, pc
);
728 if (find_pc_partial_function (pc
, NULL
, &start
, &end
))
729 trad_frame_set_id (cache
,
730 frame_id_build (trad_frame_get_this_base (cache
),
733 trad_frame_set_id (cache
,
734 frame_id_build (trad_frame_get_this_base (cache
),
735 frame_func_unwind (next_frame
)));
737 (*this_prologue_cache
) = cache
;
741 /* Here is a dummy implementation. */
742 static struct frame_id
743 mn10300_unwind_dummy_id (struct gdbarch
*gdbarch
,
744 struct frame_info
*next_frame
)
746 return frame_id_build (frame_sp_unwind (next_frame
),
747 frame_pc_unwind (next_frame
));
750 /* Trad frame implementation. */
752 mn10300_frame_this_id (struct frame_info
*next_frame
,
753 void **this_prologue_cache
,
754 struct frame_id
*this_id
)
756 struct trad_frame_cache
*cache
=
757 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
759 trad_frame_get_id (cache
, this_id
);
763 mn10300_frame_prev_register (struct frame_info
*next_frame
,
764 void **this_prologue_cache
,
765 int regnum
, int *optimizedp
,
766 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
767 int *realnump
, void *bufferp
)
769 struct trad_frame_cache
*cache
=
770 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
772 trad_frame_get_register (cache
, next_frame
, regnum
, optimizedp
,
773 lvalp
, addrp
, realnump
, bufferp
);
775 trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum,
776 optimizedp, lvalp, addrp, realnump, bufferp);
780 static const struct frame_unwind mn10300_frame_unwind
= {
782 mn10300_frame_this_id
,
783 mn10300_frame_prev_register
787 mn10300_frame_base_address (struct frame_info
*next_frame
,
788 void **this_prologue_cache
)
790 struct trad_frame_cache
*cache
=
791 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
793 return trad_frame_get_this_base (cache
);
796 static const struct frame_unwind
*
797 mn10300_frame_sniffer (struct frame_info
*next_frame
)
799 return &mn10300_frame_unwind
;
802 static const struct frame_base mn10300_frame_base
= {
803 &mn10300_frame_unwind
,
804 mn10300_frame_base_address
,
805 mn10300_frame_base_address
,
806 mn10300_frame_base_address
810 mn10300_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
814 frame_unwind_unsigned_register (next_frame
, E_PC_REGNUM
, &pc
);
819 mn10300_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
823 frame_unwind_unsigned_register (next_frame
, E_SP_REGNUM
, &sp
);
828 mn10300_frame_unwind_init (struct gdbarch
*gdbarch
)
830 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
831 frame_unwind_append_sniffer (gdbarch
, mn10300_frame_sniffer
);
832 frame_base_set_default (gdbarch
, &mn10300_frame_base
);
833 set_gdbarch_unwind_dummy_id (gdbarch
, mn10300_unwind_dummy_id
);
834 set_gdbarch_unwind_pc (gdbarch
, mn10300_unwind_pc
);
835 set_gdbarch_unwind_sp (gdbarch
, mn10300_unwind_sp
);
838 /* Function: push_dummy_call
840 * Set up machine state for a target call, including
841 * function arguments, stack, return address, etc.
846 mn10300_push_dummy_call (struct gdbarch
*gdbarch
,
847 struct value
*target_func
,
848 struct regcache
*regcache
,
850 int nargs
, struct value
**args
,
853 CORE_ADDR struct_addr
)
855 const int push_size
= register_size (gdbarch
, E_PC_REGNUM
);
858 int stack_offset
= 0;
860 char *val
, valbuf
[MAX_REGISTER_SIZE
];
862 /* This should be a nop, but align the stack just in case something
863 went wrong. Stacks are four byte aligned on the mn10300. */
866 /* Now make space on the stack for the args.
868 XXX This doesn't appear to handle pass-by-invisible reference
870 regs_used
= struct_return
? 1 : 0;
871 for (len
= 0, argnum
= 0; argnum
< nargs
; argnum
++)
873 arg_len
= (TYPE_LENGTH (value_type (args
[argnum
])) + 3) & ~3;
874 while (regs_used
< 2 && arg_len
> 0)
877 arg_len
-= push_size
;
882 /* Allocate stack space. */
888 write_register (E_D0_REGNUM
, struct_addr
);
893 /* Push all arguments onto the stack. */
894 for (argnum
= 0; argnum
< nargs
; argnum
++)
896 /* FIXME what about structs? Unions? */
897 if (TYPE_CODE (value_type (*args
)) == TYPE_CODE_STRUCT
898 && TYPE_LENGTH (value_type (*args
)) > 8)
900 /* Change to pointer-to-type. */
902 store_unsigned_integer (valbuf
, push_size
,
903 VALUE_ADDRESS (*args
));
908 arg_len
= TYPE_LENGTH (value_type (*args
));
909 val
= (char *) value_contents (*args
);
912 while (regs_used
< 2 && arg_len
> 0)
914 write_register (regs_used
,
915 extract_unsigned_integer (val
, push_size
));
917 arg_len
-= push_size
;
923 write_memory (sp
+ stack_offset
, val
, push_size
);
924 arg_len
-= push_size
;
926 stack_offset
+= push_size
;
932 /* Make space for the flushback area. */
935 /* Push the return address that contains the magic breakpoint. */
937 write_memory_unsigned_integer (sp
, push_size
, bp_addr
);
939 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
944 static struct gdbarch
*
945 mn10300_gdbarch_init (struct gdbarch_info info
,
946 struct gdbarch_list
*arches
)
948 struct gdbarch
*gdbarch
;
949 struct gdbarch_tdep
*tdep
;
951 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
953 return arches
->gdbarch
;
955 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
956 gdbarch
= gdbarch_alloc (&info
, tdep
);
958 switch (info
.bfd_arch_info
->mach
)
961 case bfd_mach_mn10300
:
962 set_gdbarch_register_name (gdbarch
, mn10300_generic_register_name
);
966 set_gdbarch_register_name (gdbarch
, am33_register_name
);
970 internal_error (__FILE__
, __LINE__
,
971 _("mn10300_gdbarch_init: Unknown mn10300 variant"));
976 set_gdbarch_num_regs (gdbarch
, E_NUM_REGS
);
977 set_gdbarch_register_type (gdbarch
, mn10300_register_type
);
978 set_gdbarch_skip_prologue (gdbarch
, mn10300_skip_prologue
);
979 set_gdbarch_read_pc (gdbarch
, mn10300_read_pc
);
980 set_gdbarch_write_pc (gdbarch
, mn10300_write_pc
);
981 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
982 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
984 /* Stack unwinding. */
985 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
987 set_gdbarch_breakpoint_from_pc (gdbarch
, mn10300_breakpoint_from_pc
);
988 /* decr_pc_after_break? */
990 set_gdbarch_print_insn (gdbarch
, print_insn_mn10300
);
993 /* MVS Note: at least the first one is deprecated! */
994 set_gdbarch_deprecated_use_struct_convention (gdbarch
,
995 mn10300_use_struct_convention
);
996 set_gdbarch_store_return_value (gdbarch
, mn10300_store_return_value
);
997 set_gdbarch_extract_return_value (gdbarch
, mn10300_extract_return_value
);
999 /* Stage 3 -- get target calls working. */
1000 set_gdbarch_push_dummy_call (gdbarch
, mn10300_push_dummy_call
);
1001 /* set_gdbarch_return_value (store, extract) */
1004 mn10300_frame_unwind_init (gdbarch
);
1009 /* Dump out the mn10300 specific architecture information. */
1012 mn10300_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
1014 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
1015 fprintf_unfiltered (file
, "mn10300_dump_tdep: am33_mode = %d\n",
1020 _initialize_mn10300_tdep (void)
1022 gdbarch_register (bfd_arch_mn10300
, mn10300_gdbarch_init
, mn10300_dump_tdep
);