1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
26 #include "gdb_string.h"
27 #include "gdb_assert.h"
28 #include "gdbcore.h" /* for write_memory_unsigned_integer */
32 #include "frame-unwind.h"
33 #include "frame-base.h"
34 #include "trad-frame.h"
36 #include "dwarf2-frame.h"
39 #include "mn10300-tdep.h"
42 extern struct trad_frame_cache
*mn10300_frame_unwind_cache (struct frame_info
*,
45 /* Compute the alignment required by a type. */
48 mn10300_type_align (struct type
*type
)
52 switch (TYPE_CODE (type
))
63 return TYPE_LENGTH (type
);
65 case TYPE_CODE_COMPLEX
:
66 return TYPE_LENGTH (type
) / 2;
68 case TYPE_CODE_STRUCT
:
70 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
72 int falign
= mn10300_type_align (TYPE_FIELD_TYPE (type
, i
));
73 while (align
< falign
)
79 /* HACK! Structures containing arrays, even small ones, are not
80 elligible for returning in registers. */
83 case TYPE_CODE_TYPEDEF
:
84 return mn10300_type_align (check_typedef (type
));
87 internal_error (__FILE__
, __LINE__
, _("bad switch"));
91 /* Should call_function allocate stack space for a struct return? */
93 mn10300_use_struct_convention (struct type
*type
)
95 /* Structures bigger than a pair of words can't be returned in
97 if (TYPE_LENGTH (type
) > 8)
100 switch (TYPE_CODE (type
))
102 case TYPE_CODE_STRUCT
:
103 case TYPE_CODE_UNION
:
104 /* Structures with a single field are handled as the field
106 if (TYPE_NFIELDS (type
) == 1)
107 return mn10300_use_struct_convention (TYPE_FIELD_TYPE (type
, 0));
109 /* Structures with word or double-word size are passed in memory, as
110 long as they require at least word alignment. */
111 if (mn10300_type_align (type
) >= 4)
116 /* Arrays are addressable, so they're never returned in
117 registers. This condition can only hold when the array is
118 the only field of a struct or union. */
119 case TYPE_CODE_ARRAY
:
122 case TYPE_CODE_TYPEDEF
:
123 return mn10300_use_struct_convention (check_typedef (type
));
131 mn10300_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
132 struct regcache
*regcache
, const void *valbuf
)
134 int len
= TYPE_LENGTH (type
);
137 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
142 regsz
= register_size (gdbarch
, reg
);
145 regcache_raw_write_part (regcache
, reg
, 0, len
, valbuf
);
146 else if (len
<= 2 * regsz
)
148 regcache_raw_write (regcache
, reg
, valbuf
);
149 gdb_assert (regsz
== register_size (gdbarch
, reg
+ 1));
150 regcache_raw_write_part (regcache
, reg
+1, 0,
151 len
- regsz
, (char *) valbuf
+ regsz
);
154 internal_error (__FILE__
, __LINE__
,
155 _("Cannot store return value %d bytes long."), len
);
159 mn10300_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
160 struct regcache
*regcache
, void *valbuf
)
162 char buf
[MAX_REGISTER_SIZE
];
163 int len
= TYPE_LENGTH (type
);
166 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
171 regsz
= register_size (gdbarch
, reg
);
174 regcache_raw_read (regcache
, reg
, buf
);
175 memcpy (valbuf
, buf
, len
);
177 else if (len
<= 2 * regsz
)
179 regcache_raw_read (regcache
, reg
, buf
);
180 memcpy (valbuf
, buf
, regsz
);
181 gdb_assert (regsz
== register_size (gdbarch
, reg
+ 1));
182 regcache_raw_read (regcache
, reg
+ 1, buf
);
183 memcpy ((char *) valbuf
+ regsz
, buf
, len
- regsz
);
186 internal_error (__FILE__
, __LINE__
,
187 _("Cannot extract return value %d bytes long."), len
);
190 /* Determine, for architecture GDBARCH, how a return value of TYPE
191 should be returned. If it is supposed to be returned in registers,
192 and READBUF is non-zero, read the appropriate value from REGCACHE,
193 and copy it into READBUF. If WRITEBUF is non-zero, write the value
194 from WRITEBUF into REGCACHE. */
196 static enum return_value_convention
197 mn10300_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
198 struct regcache
*regcache
, gdb_byte
*readbuf
,
199 const gdb_byte
*writebuf
)
201 if (mn10300_use_struct_convention (type
))
202 return RETURN_VALUE_STRUCT_CONVENTION
;
205 mn10300_extract_return_value (gdbarch
, type
, regcache
, readbuf
);
207 mn10300_store_return_value (gdbarch
, type
, regcache
, writebuf
);
209 return RETURN_VALUE_REGISTER_CONVENTION
;
213 register_name (int reg
, char **regs
, long sizeof_regs
)
215 if (reg
< 0 || reg
>= sizeof_regs
/ sizeof (regs
[0]))
222 mn10300_generic_register_name (struct gdbarch
*gdbarch
, int reg
)
224 static char *regs
[] =
225 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
226 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
227 "", "", "", "", "", "", "", "",
228 "", "", "", "", "", "", "", "fp"
230 return register_name (reg
, regs
, sizeof regs
);
235 am33_register_name (struct gdbarch
*gdbarch
, int reg
)
237 static char *regs
[] =
238 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
239 "sp", "pc", "mdr", "psw", "lir", "lar", "",
240 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
241 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
243 return register_name (reg
, regs
, sizeof regs
);
247 am33_2_register_name (struct gdbarch
*gdbarch
, int reg
)
249 static char *regs
[] =
251 "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
252 "sp", "pc", "mdr", "psw", "lir", "lar", "mdrq", "r0",
253 "r1", "r2", "r3", "r4", "r5", "r6", "r7", "ssp",
254 "msp", "usp", "mcrh", "mcrl", "mcvf", "fpcr", "", "",
255 "fs0", "fs1", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7",
256 "fs8", "fs9", "fs10", "fs11", "fs12", "fs13", "fs14", "fs15",
257 "fs16", "fs17", "fs18", "fs19", "fs20", "fs21", "fs22", "fs23",
258 "fs24", "fs25", "fs26", "fs27", "fs28", "fs29", "fs30", "fs31"
260 return register_name (reg
, regs
, sizeof regs
);
264 mn10300_register_type (struct gdbarch
*gdbarch
, int reg
)
266 return builtin_type_int
;
270 mn10300_read_pc (struct regcache
*regcache
)
273 regcache_cooked_read_unsigned (regcache
, E_PC_REGNUM
, &val
);
278 mn10300_write_pc (struct regcache
*regcache
, CORE_ADDR val
)
280 regcache_cooked_write_unsigned (regcache
, E_PC_REGNUM
, val
);
283 /* The breakpoint instruction must be the same size as the smallest
284 instruction in the instruction set.
286 The Matsushita mn10x00 processors have single byte instructions
287 so we need a single byte breakpoint. Matsushita hasn't defined
288 one, so we defined it ourselves. */
290 const static unsigned char *
291 mn10300_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*bp_addr
,
294 static char breakpoint
[] = {0xff};
299 /* Set offsets of saved registers.
300 This is a helper function for mn10300_analyze_prologue. */
303 set_reg_offsets (struct frame_info
*fi
,
307 int stack_extra_size
,
310 struct gdbarch
*gdbarch
;
311 struct trad_frame_cache
*cache
;
315 if (fi
== NULL
|| this_cache
== NULL
)
318 cache
= mn10300_frame_unwind_cache (fi
, this_cache
);
321 gdbarch
= get_frame_arch (fi
);
325 base
= frame_unwind_register_unsigned (fi
, E_A3_REGNUM
);
329 base
= frame_unwind_register_unsigned (fi
, E_SP_REGNUM
)
333 trad_frame_set_this_base (cache
, base
);
335 if (AM33_MODE (gdbarch
) == 2)
337 /* If bit N is set in fpregmask, fsN is saved on the stack.
338 The floating point registers are saved in ascending order.
339 For example: fs16 <- Frame Pointer
340 fs17 Frame Pointer + 4 */
344 for (i
= 0; i
< 32; i
++)
346 if (fpregmask
& (1 << i
))
348 trad_frame_set_reg_addr (cache
, E_FS0_REGNUM
+ i
,
357 if (movm_args
& movm_other_bit
)
359 /* The `other' bit leaves a blank area of four bytes at the
360 beginning of its block of saved registers, making it 32 bytes
362 trad_frame_set_reg_addr (cache
, E_LAR_REGNUM
, base
+ offset
+ 4);
363 trad_frame_set_reg_addr (cache
, E_LIR_REGNUM
, base
+ offset
+ 8);
364 trad_frame_set_reg_addr (cache
, E_MDR_REGNUM
, base
+ offset
+ 12);
365 trad_frame_set_reg_addr (cache
, E_A0_REGNUM
+ 1, base
+ offset
+ 16);
366 trad_frame_set_reg_addr (cache
, E_A0_REGNUM
, base
+ offset
+ 20);
367 trad_frame_set_reg_addr (cache
, E_D0_REGNUM
+ 1, base
+ offset
+ 24);
368 trad_frame_set_reg_addr (cache
, E_D0_REGNUM
, base
+ offset
+ 28);
372 if (movm_args
& movm_a3_bit
)
374 trad_frame_set_reg_addr (cache
, E_A3_REGNUM
, base
+ offset
);
377 if (movm_args
& movm_a2_bit
)
379 trad_frame_set_reg_addr (cache
, E_A2_REGNUM
, base
+ offset
);
382 if (movm_args
& movm_d3_bit
)
384 trad_frame_set_reg_addr (cache
, E_D3_REGNUM
, base
+ offset
);
387 if (movm_args
& movm_d2_bit
)
389 trad_frame_set_reg_addr (cache
, E_D2_REGNUM
, base
+ offset
);
392 if (AM33_MODE (gdbarch
))
394 if (movm_args
& movm_exother_bit
)
396 trad_frame_set_reg_addr (cache
, E_MCVF_REGNUM
, base
+ offset
);
397 trad_frame_set_reg_addr (cache
, E_MCRL_REGNUM
, base
+ offset
+ 4);
398 trad_frame_set_reg_addr (cache
, E_MCRH_REGNUM
, base
+ offset
+ 8);
399 trad_frame_set_reg_addr (cache
, E_MDRQ_REGNUM
, base
+ offset
+ 12);
400 trad_frame_set_reg_addr (cache
, E_E1_REGNUM
, base
+ offset
+ 16);
401 trad_frame_set_reg_addr (cache
, E_E0_REGNUM
, base
+ offset
+ 20);
404 if (movm_args
& movm_exreg1_bit
)
406 trad_frame_set_reg_addr (cache
, E_E7_REGNUM
, base
+ offset
);
407 trad_frame_set_reg_addr (cache
, E_E6_REGNUM
, base
+ offset
+ 4);
408 trad_frame_set_reg_addr (cache
, E_E5_REGNUM
, base
+ offset
+ 8);
409 trad_frame_set_reg_addr (cache
, E_E4_REGNUM
, base
+ offset
+ 12);
412 if (movm_args
& movm_exreg0_bit
)
414 trad_frame_set_reg_addr (cache
, E_E3_REGNUM
, base
+ offset
);
415 trad_frame_set_reg_addr (cache
, E_E2_REGNUM
, base
+ offset
+ 4);
419 /* The last (or first) thing on the stack will be the PC. */
420 trad_frame_set_reg_addr (cache
, E_PC_REGNUM
, base
+ offset
);
421 /* Save the SP in the 'traditional' way.
422 This will be the same location where the PC is saved. */
423 trad_frame_set_reg_value (cache
, E_SP_REGNUM
, base
+ offset
);
426 /* The main purpose of this file is dealing with prologues to extract
427 information about stack frames and saved registers.
429 In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
430 function is pretty readable, and has a nice explanation of how the
431 prologue is generated. The prologues generated by that code will
432 have the following form (NOTE: the current code doesn't handle all
435 + If this is an old-style varargs function, then its arguments
436 need to be flushed back to the stack:
441 + If we use any of the callee-saved registers, save them now.
443 movm [some callee-saved registers],(sp)
445 + If we have any floating-point registers to save:
447 - Decrement the stack pointer to reserve space for the registers.
448 If the function doesn't need a frame pointer, we may combine
449 this with the adjustment that reserves space for the frame.
453 - Save the floating-point registers. We have two possible
456 . Save them at fixed offset from the SP:
458 fmov fsN,(OFFSETN,sp)
459 fmov fsM,(OFFSETM,sp)
462 Note that, if OFFSETN happens to be zero, you'll get the
463 different opcode: fmov fsN,(sp)
465 . Or, set a0 to the start of the save area, and then use
466 post-increment addressing to save the FP registers.
474 + If the function needs a frame pointer, we set it here.
478 + Now we reserve space for the stack frame proper. This could be
479 merged into the `add -SIZE, sp' instruction for FP saves up
480 above, unless we needed to set the frame pointer in the previous
481 step, or the frame is so large that allocating the whole thing at
482 once would put the FP register save slots out of reach of the
483 addressing mode (128 bytes).
487 One day we might keep the stack pointer constant, that won't
488 change the code for prologues, but it will make the frame
489 pointerless case much more common. */
491 /* Analyze the prologue to determine where registers are saved,
492 the end of the prologue, etc etc. Return the end of the prologue
495 We store into FI (if non-null) several tidbits of information:
497 * stack_size -- size of this stack frame. Note that if we stop in
498 certain parts of the prologue/epilogue we may claim the size of the
499 current frame is zero. This happens when the current frame has
500 not been allocated yet or has already been deallocated.
502 * fsr -- Addresses of registers saved in the stack by this frame.
504 * status -- A (relatively) generic status indicator. It's a bitmask
505 with the following bits:
507 MY_FRAME_IN_SP: The base of the current frame is actually in
508 the stack pointer. This can happen for frame pointerless
509 functions, or cases where we're stopped in the prologue/epilogue
510 itself. For these cases mn10300_analyze_prologue will need up
511 update fi->frame before returning or analyzing the register
514 MY_FRAME_IN_FP: The base of the current frame is in the
515 frame pointer register ($a3).
517 NO_MORE_FRAMES: Set this if the current frame is "start" or
518 if the first instruction looks like mov <imm>,sp. This tells
519 frame chain to not bother trying to unwind past this frame. */
522 mn10300_analyze_prologue (struct gdbarch
*gdbarch
, struct frame_info
*fi
,
526 CORE_ADDR func_addr
, func_end
, addr
, stop
;
527 long stack_extra_size
= 0;
529 unsigned char buf
[4];
536 /* Use the PC in the frame if it's provided to look up the
537 start of this function.
539 Note: kevinb/2003-07-16: We used to do the following here:
540 pc = (fi ? get_frame_pc (fi) : pc);
541 But this is (now) badly broken when called from analyze_dummy_frame().
545 pc
= (pc
? pc
: get_frame_pc (fi
));
548 /* Find the start of this function. */
549 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
551 /* Do nothing if we couldn't find the start of this function
553 MVS: comment went on to say "or if we're stopped at the first
554 instruction in the prologue" -- but code doesn't reflect that,
555 and I don't want to do that anyway. */
559 goto finish_prologue
;
562 /* If we're in start, then give up. */
563 if (strcmp (name
, "start") == 0)
566 goto finish_prologue
;
569 /* Figure out where to stop scanning. */
570 stop
= fi
? pc
: func_end
;
572 /* Don't walk off the end of the function. */
573 stop
= stop
> func_end
? func_end
: stop
;
575 /* Start scanning on the first instruction of this function. */
578 /* Suck in two bytes. */
579 if (addr
+ 2 > stop
|| !safe_frame_unwind_memory (fi
, addr
, buf
, 2))
580 goto finish_prologue
;
582 /* First see if this insn sets the stack pointer from a register; if
583 so, it's probably the initialization of the stack pointer in _start,
584 so mark this as the bottom-most frame. */
585 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
587 goto finish_prologue
;
590 /* Now look for movm [regs],sp, which saves the callee saved registers.
592 At this time we don't know if fi->frame is valid, so we only note
593 that we encountered a movm instruction. Later, we'll set the entries
594 in fsr.regs as needed. */
597 /* Extract the register list for the movm instruction. */
602 /* Quit now if we're beyond the stop point. */
604 goto finish_prologue
;
606 /* Get the next two bytes so the prologue scan can continue. */
607 if (!safe_frame_unwind_memory (fi
, addr
, buf
, 2))
608 goto finish_prologue
;
611 if (AM33_MODE (gdbarch
) == 2)
613 /* Determine if any floating point registers are to be saved.
614 Look for one of the following three prologue formats:
616 [movm [regs],(sp)] [movm [regs],(sp)] [movm [regs],(sp)]
618 add -SIZE,sp add -SIZE,sp add -SIZE,sp
619 fmov fs#,(sp) mov sp,a0/a1 mov sp,a0/a1
620 fmov fs#,(#,sp) fmov fs#,(a0/a1+) add SIZE2,a0/a1
621 ... ... fmov fs#,(a0/a1+)
623 fmov fs#,(#,sp) fmov fs#,(a0/a1+) fmov fs#,(a0/a1+)
625 [mov sp,a3] [mov sp,a3]
626 [add -SIZE2,sp] [add -SIZE2,sp] */
628 /* Remember the address at which we started in the event that we
629 don't ultimately find an fmov instruction. Once we're certain
630 that we matched one of the above patterns, we'll set
631 ``restore_addr'' to the appropriate value. Note: At one time
632 in the past, this code attempted to not adjust ``addr'' until
633 there was a fair degree of certainty that the pattern would be
634 matched. However, that code did not wait until an fmov instruction
635 was actually encountered. As a consequence, ``addr'' would
636 sometimes be advanced even when no fmov instructions were found. */
637 CORE_ADDR restore_addr
= addr
;
639 /* First, look for add -SIZE,sp (i.e. add imm8,sp (0xf8feXX)
640 or add imm16,sp (0xfafeXXXX)
641 or add imm32,sp (0xfcfeXXXXXXXX)) */
643 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
645 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
647 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
651 /* An "add -#,sp" instruction has been found. "addr + 2 + imm_size"
652 is the address of the next instruction. Don't modify "addr" until
653 the next "floating point prologue" instruction is found. If this
654 is not a prologue that saves floating point registers we need to
655 be able to back out of this bit of code and continue with the
656 prologue analysis. */
657 if (addr
+ 2 + imm_size
< stop
)
659 if (!safe_frame_unwind_memory (fi
, addr
+ 2 + imm_size
, buf
, 3))
660 goto finish_prologue
;
661 if ((buf
[0] & 0xfc) == 0x3c)
663 /* Occasionally, especially with C++ code, the "fmov"
664 instructions will be preceded by "mov sp,aN"
665 (aN => a0, a1, a2, or a3).
667 This is a one byte instruction: mov sp,aN = 0011 11XX
668 where XX is the register number.
670 Skip this instruction by incrementing addr. The "fmov"
671 instructions will have the form "fmov fs#,(aN+)" in this
672 case, but that will not necessitate a change in the
673 "fmov" parsing logic below. */
677 if ((buf
[1] & 0xfc) == 0x20)
679 /* Occasionally, especially with C++ code compiled with
680 the -fomit-frame-pointer or -O3 options, the
681 "mov sp,aN" instruction will be followed by an
682 "add #,aN" instruction. This indicates the
683 "stack_size", the size of the portion of the stack
684 containing the arguments. This instruction format is:
685 add #,aN = 0010 00XX YYYY YYYY
686 where XX is the register number
687 YYYY YYYY is the constant.
688 Note the size of the stack (as a negative number) in
689 the frame info structure. */
691 stack_extra_size
+= -buf
[2];
697 if ((buf
[0] & 0xfc) == 0x3c ||
698 buf
[0] == 0xf9 || buf
[0] == 0xfb)
700 /* An "fmov" instruction has been found indicating that this
701 prologue saves floating point registers (or, as described
702 above, a "mov sp,aN" and possible "add #,aN" have been
703 found and we will assume an "fmov" follows). Process the
704 consecutive "fmov" instructions. */
705 for (addr
+= 2 + imm_size
;;addr
+= imm_size
)
709 /* Read the "fmov" instruction. */
711 !safe_frame_unwind_memory (fi
, addr
, buf
, 4))
712 goto finish_prologue
;
714 if (buf
[0] != 0xf9 && buf
[0] != 0xfb)
717 /* An fmov instruction has just been seen. We can
718 now really commit to the pattern match. Set the
719 address to restore at the end of this speculative
720 bit of code to the actually address that we've
721 been incrementing (or not) throughout the
725 /* Get the floating point register number from the
726 2nd and 3rd bytes of the "fmov" instruction:
727 Machine Code: 0000 00X0 YYYY 0000 =>
729 regnum
= (buf
[1] & 0x02) << 3;
730 regnum
|= ((buf
[2] & 0xf0) >> 4) & 0x0f;
732 /* Add this register number to the bit mask of floating
733 point registers that have been saved. */
734 fpregmask
|= 1 << regnum
;
736 /* Determine the length of this "fmov" instruction.
737 fmov fs#,(sp) => 3 byte instruction
738 fmov fs#,(#,sp) => 4 byte instruction */
739 imm_size
= (buf
[0] == 0xf9) ? 3 : 4;
744 /* No "fmov" was found. Reread the two bytes at the original
745 "addr" to reset the state. */
747 if (!safe_frame_unwind_memory (fi
, addr
, buf
, 2))
748 goto finish_prologue
;
751 /* else the prologue consists entirely of an "add -SIZE,sp"
752 instruction. Handle this below. */
754 /* else no "add -SIZE,sp" was found indicating no floating point
755 registers are saved in this prologue. */
757 /* In the pattern match code contained within this block, `restore_addr'
758 is set to the starting address at the very beginning and then
759 iteratively to the next address to start scanning at once the
760 pattern match has succeeded. Thus `restore_addr' will contain
761 the address to rewind to if the pattern match failed. If the
762 match succeeded, `restore_addr' and `addr' will already have the
767 /* Now see if we set up a frame pointer via "mov sp,a3" */
772 /* The frame pointer is now valid. */
778 /* Quit now if we're beyond the stop point. */
780 goto finish_prologue
;
782 /* Get two more bytes so scanning can continue. */
783 if (!safe_frame_unwind_memory (fi
, addr
, buf
, 2))
784 goto finish_prologue
;
787 /* Next we should allocate the local frame. No more prologue insns
788 are found after allocating the local frame.
790 Search for add imm8,sp (0xf8feXX)
791 or add imm16,sp (0xfafeXXXX)
792 or add imm32,sp (0xfcfeXXXXXXXX).
794 If none of the above was found, then this prologue has no
798 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
800 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
802 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
807 /* Suck in imm_size more bytes, they'll hold the size of the
809 if (!safe_frame_unwind_memory (fi
, addr
+ 2, buf
, imm_size
))
810 goto finish_prologue
;
812 /* Note the size of the stack. */
813 stack_extra_size
-= extract_signed_integer (buf
, imm_size
);
815 /* We just consumed 2 + imm_size bytes. */
816 addr
+= 2 + imm_size
;
818 /* No more prologue insns follow, so begin preparation to return. */
819 goto finish_prologue
;
821 /* Do the essentials and get out of here. */
823 /* Note if/where callee saved registers were saved. */
825 set_reg_offsets (fi
, this_cache
, movm_args
, fpregmask
, stack_extra_size
,
830 /* Function: skip_prologue
831 Return the address of the first inst past the prologue of the function. */
834 mn10300_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
836 return mn10300_analyze_prologue (gdbarch
, NULL
, NULL
, pc
);
839 /* Simple frame_unwind_cache.
840 This finds the "extra info" for the frame. */
841 struct trad_frame_cache
*
842 mn10300_frame_unwind_cache (struct frame_info
*next_frame
,
843 void **this_prologue_cache
)
845 struct gdbarch
*gdbarch
;
846 struct trad_frame_cache
*cache
;
847 CORE_ADDR pc
, start
, end
;
850 if (*this_prologue_cache
)
851 return (*this_prologue_cache
);
853 gdbarch
= get_frame_arch (next_frame
);
854 cache_p
= trad_frame_cache_zalloc (next_frame
);
855 pc
= gdbarch_unwind_pc (gdbarch
, next_frame
);
856 mn10300_analyze_prologue (gdbarch
, next_frame
, &cache_p
, pc
);
859 if (find_pc_partial_function (pc
, NULL
, &start
, &end
))
860 trad_frame_set_id (cache
,
861 frame_id_build (trad_frame_get_this_base (cache
),
865 start
= frame_func_unwind (next_frame
, NORMAL_FRAME
);
866 trad_frame_set_id (cache
,
867 frame_id_build (trad_frame_get_this_base (cache
),
871 (*this_prologue_cache
) = cache
;
875 /* Here is a dummy implementation. */
876 static struct frame_id
877 mn10300_unwind_dummy_id (struct gdbarch
*gdbarch
,
878 struct frame_info
*next_frame
)
880 return frame_id_build (frame_sp_unwind (next_frame
),
881 frame_pc_unwind (next_frame
));
884 /* Trad frame implementation. */
886 mn10300_frame_this_id (struct frame_info
*next_frame
,
887 void **this_prologue_cache
,
888 struct frame_id
*this_id
)
890 struct trad_frame_cache
*cache
=
891 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
893 trad_frame_get_id (cache
, this_id
);
897 mn10300_frame_prev_register (struct frame_info
*next_frame
,
898 void **this_prologue_cache
,
899 int regnum
, int *optimizedp
,
900 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
901 int *realnump
, gdb_byte
*bufferp
)
903 struct trad_frame_cache
*cache
=
904 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
906 trad_frame_get_register (cache
, next_frame
, regnum
, optimizedp
,
907 lvalp
, addrp
, realnump
, bufferp
);
909 trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum,
910 optimizedp, lvalp, addrp, realnump, bufferp);
914 static const struct frame_unwind mn10300_frame_unwind
= {
916 mn10300_frame_this_id
,
917 mn10300_frame_prev_register
921 mn10300_frame_base_address (struct frame_info
*next_frame
,
922 void **this_prologue_cache
)
924 struct trad_frame_cache
*cache
=
925 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
927 return trad_frame_get_this_base (cache
);
930 static const struct frame_unwind
*
931 mn10300_frame_sniffer (struct frame_info
*next_frame
)
933 return &mn10300_frame_unwind
;
936 static const struct frame_base mn10300_frame_base
= {
937 &mn10300_frame_unwind
,
938 mn10300_frame_base_address
,
939 mn10300_frame_base_address
,
940 mn10300_frame_base_address
944 mn10300_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
948 pc
= frame_unwind_register_unsigned (next_frame
, E_PC_REGNUM
);
953 mn10300_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
957 sp
= frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
);
962 mn10300_frame_unwind_init (struct gdbarch
*gdbarch
)
964 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
965 frame_unwind_append_sniffer (gdbarch
, mn10300_frame_sniffer
);
966 frame_base_set_default (gdbarch
, &mn10300_frame_base
);
967 set_gdbarch_unwind_dummy_id (gdbarch
, mn10300_unwind_dummy_id
);
968 set_gdbarch_unwind_pc (gdbarch
, mn10300_unwind_pc
);
969 set_gdbarch_unwind_sp (gdbarch
, mn10300_unwind_sp
);
972 /* Function: push_dummy_call
974 * Set up machine state for a target call, including
975 * function arguments, stack, return address, etc.
980 mn10300_push_dummy_call (struct gdbarch
*gdbarch
,
981 struct value
*target_func
,
982 struct regcache
*regcache
,
984 int nargs
, struct value
**args
,
987 CORE_ADDR struct_addr
)
989 const int push_size
= register_size (gdbarch
, E_PC_REGNUM
);
992 int stack_offset
= 0;
994 char *val
, valbuf
[MAX_REGISTER_SIZE
];
996 /* This should be a nop, but align the stack just in case something
997 went wrong. Stacks are four byte aligned on the mn10300. */
1000 /* Now make space on the stack for the args.
1002 XXX This doesn't appear to handle pass-by-invisible reference
1004 regs_used
= struct_return
? 1 : 0;
1005 for (len
= 0, argnum
= 0; argnum
< nargs
; argnum
++)
1007 arg_len
= (TYPE_LENGTH (value_type (args
[argnum
])) + 3) & ~3;
1008 while (regs_used
< 2 && arg_len
> 0)
1011 arg_len
-= push_size
;
1016 /* Allocate stack space. */
1022 regcache_cooked_write_unsigned (regcache
, E_D0_REGNUM
, struct_addr
);
1027 /* Push all arguments onto the stack. */
1028 for (argnum
= 0; argnum
< nargs
; argnum
++)
1030 /* FIXME what about structs? Unions? */
1031 if (TYPE_CODE (value_type (*args
)) == TYPE_CODE_STRUCT
1032 && TYPE_LENGTH (value_type (*args
)) > 8)
1034 /* Change to pointer-to-type. */
1035 arg_len
= push_size
;
1036 store_unsigned_integer (valbuf
, push_size
,
1037 VALUE_ADDRESS (*args
));
1042 arg_len
= TYPE_LENGTH (value_type (*args
));
1043 val
= (char *) value_contents (*args
);
1046 while (regs_used
< 2 && arg_len
> 0)
1048 regcache_cooked_write_unsigned (regcache
, regs_used
,
1049 extract_unsigned_integer (val
, push_size
));
1051 arg_len
-= push_size
;
1057 write_memory (sp
+ stack_offset
, val
, push_size
);
1058 arg_len
-= push_size
;
1060 stack_offset
+= push_size
;
1066 /* Make space for the flushback area. */
1069 /* Push the return address that contains the magic breakpoint. */
1071 write_memory_unsigned_integer (sp
, push_size
, bp_addr
);
1073 /* The CPU also writes the return address always into the
1074 MDR register on "call". */
1075 regcache_cooked_write_unsigned (regcache
, E_MDR_REGNUM
, bp_addr
);
1078 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
1082 /* If DWARF2 is a register number appearing in Dwarf2 debug info, then
1083 mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
1084 register number. Why don't Dwarf2 and GDB use the same numbering?
1085 Who knows? But since people have object files lying around with
1086 the existing Dwarf2 numbering, and other people have written stubs
1087 to work with the existing GDB, neither of them can change. So we
1088 just have to cope. */
1090 mn10300_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf2
)
1092 /* This table is supposed to be shaped like the gdbarch_register_name
1093 initializer in gcc/config/mn10300/mn10300.h. Registers which
1094 appear in GCC's numbering, but have no counterpart in GDB's
1095 world, are marked with a -1. */
1096 static int dwarf2_to_gdb
[] = {
1097 0, 1, 2, 3, 4, 5, 6, 7, -1, 8,
1098 15, 16, 17, 18, 19, 20, 21, 22,
1099 32, 33, 34, 35, 36, 37, 38, 39,
1100 40, 41, 42, 43, 44, 45, 46, 47,
1101 48, 49, 50, 51, 52, 53, 54, 55,
1102 56, 57, 58, 59, 60, 61, 62, 63,
1107 || dwarf2
>= ARRAY_SIZE (dwarf2_to_gdb
))
1109 warning (_("Bogus register number in debug info: %d"), dwarf2
);
1113 return dwarf2_to_gdb
[dwarf2
];
1116 static struct gdbarch
*
1117 mn10300_gdbarch_init (struct gdbarch_info info
,
1118 struct gdbarch_list
*arches
)
1120 struct gdbarch
*gdbarch
;
1121 struct gdbarch_tdep
*tdep
;
1124 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1126 return arches
->gdbarch
;
1128 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1129 gdbarch
= gdbarch_alloc (&info
, tdep
);
1131 switch (info
.bfd_arch_info
->mach
)
1134 case bfd_mach_mn10300
:
1135 set_gdbarch_register_name (gdbarch
, mn10300_generic_register_name
);
1136 tdep
->am33_mode
= 0;
1140 set_gdbarch_register_name (gdbarch
, am33_register_name
);
1141 tdep
->am33_mode
= 1;
1144 case bfd_mach_am33_2
:
1145 set_gdbarch_register_name (gdbarch
, am33_2_register_name
);
1146 tdep
->am33_mode
= 2;
1148 set_gdbarch_fp0_regnum (gdbarch
, 32);
1151 internal_error (__FILE__
, __LINE__
,
1152 _("mn10300_gdbarch_init: Unknown mn10300 variant"));
1157 set_gdbarch_num_regs (gdbarch
, num_regs
);
1158 set_gdbarch_register_type (gdbarch
, mn10300_register_type
);
1159 set_gdbarch_skip_prologue (gdbarch
, mn10300_skip_prologue
);
1160 set_gdbarch_read_pc (gdbarch
, mn10300_read_pc
);
1161 set_gdbarch_write_pc (gdbarch
, mn10300_write_pc
);
1162 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
1163 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
1164 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, mn10300_dwarf2_reg_to_regnum
);
1166 /* Stack unwinding. */
1167 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1169 set_gdbarch_breakpoint_from_pc (gdbarch
, mn10300_breakpoint_from_pc
);
1170 /* decr_pc_after_break? */
1172 set_gdbarch_print_insn (gdbarch
, print_insn_mn10300
);
1175 set_gdbarch_return_value (gdbarch
, mn10300_return_value
);
1177 /* Stage 3 -- get target calls working. */
1178 set_gdbarch_push_dummy_call (gdbarch
, mn10300_push_dummy_call
);
1179 /* set_gdbarch_return_value (store, extract) */
1182 mn10300_frame_unwind_init (gdbarch
);
1184 /* Hook in ABI-specific overrides, if they have been registered. */
1185 gdbarch_init_osabi (info
, gdbarch
);
1190 /* Dump out the mn10300 specific architecture information. */
1193 mn10300_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
1195 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1196 fprintf_unfiltered (file
, "mn10300_dump_tdep: am33_mode = %d\n",
1201 _initialize_mn10300_tdep (void)
1203 gdbarch_register (bfd_arch_mn10300
, mn10300_gdbarch_init
, mn10300_dump_tdep
);