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"
40 #include "mn10300-tdep.h"
43 extern struct trad_frame_cache
*mn10300_frame_unwind_cache (struct frame_info
*,
46 /* Compute the alignment required by a type. */
49 mn10300_type_align (struct type
*type
)
53 switch (TYPE_CODE (type
))
64 return TYPE_LENGTH (type
);
66 case TYPE_CODE_COMPLEX
:
67 return TYPE_LENGTH (type
) / 2;
69 case TYPE_CODE_STRUCT
:
71 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
73 int falign
= mn10300_type_align (TYPE_FIELD_TYPE (type
, i
));
74 while (align
< falign
)
80 /* HACK! Structures containing arrays, even small ones, are not
81 elligible for returning in registers. */
84 case TYPE_CODE_TYPEDEF
:
85 return mn10300_type_align (check_typedef (type
));
88 internal_error (__FILE__
, __LINE__
, _("bad switch"));
92 /* Should call_function allocate stack space for a struct return? */
94 mn10300_use_struct_convention (struct type
*type
)
96 /* Structures bigger than a pair of words can't be returned in
98 if (TYPE_LENGTH (type
) > 8)
101 switch (TYPE_CODE (type
))
103 case TYPE_CODE_STRUCT
:
104 case TYPE_CODE_UNION
:
105 /* Structures with a single field are handled as the field
107 if (TYPE_NFIELDS (type
) == 1)
108 return mn10300_use_struct_convention (TYPE_FIELD_TYPE (type
, 0));
110 /* Structures with word or double-word size are passed in memory, as
111 long as they require at least word alignment. */
112 if (mn10300_type_align (type
) >= 4)
117 /* Arrays are addressable, so they're never returned in
118 registers. This condition can only hold when the array is
119 the only field of a struct or union. */
120 case TYPE_CODE_ARRAY
:
123 case TYPE_CODE_TYPEDEF
:
124 return mn10300_use_struct_convention (check_typedef (type
));
132 mn10300_store_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
133 struct regcache
*regcache
, const void *valbuf
)
135 int len
= TYPE_LENGTH (type
);
138 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
143 regsz
= register_size (gdbarch
, reg
);
146 regcache_raw_write_part (regcache
, reg
, 0, len
, valbuf
);
147 else if (len
<= 2 * regsz
)
149 regcache_raw_write (regcache
, reg
, valbuf
);
150 gdb_assert (regsz
== register_size (gdbarch
, reg
+ 1));
151 regcache_raw_write_part (regcache
, reg
+1, 0,
152 len
- regsz
, (char *) valbuf
+ regsz
);
155 internal_error (__FILE__
, __LINE__
,
156 _("Cannot store return value %d bytes long."), len
);
160 mn10300_extract_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
161 struct regcache
*regcache
, void *valbuf
)
163 char buf
[MAX_REGISTER_SIZE
];
164 int len
= TYPE_LENGTH (type
);
167 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
172 regsz
= register_size (gdbarch
, reg
);
175 regcache_raw_read (regcache
, reg
, buf
);
176 memcpy (valbuf
, buf
, len
);
178 else if (len
<= 2 * regsz
)
180 regcache_raw_read (regcache
, reg
, buf
);
181 memcpy (valbuf
, buf
, regsz
);
182 gdb_assert (regsz
== register_size (gdbarch
, reg
+ 1));
183 regcache_raw_read (regcache
, reg
+ 1, buf
);
184 memcpy ((char *) valbuf
+ regsz
, buf
, len
- regsz
);
187 internal_error (__FILE__
, __LINE__
,
188 _("Cannot extract return value %d bytes long."), len
);
191 /* Determine, for architecture GDBARCH, how a return value of TYPE
192 should be returned. If it is supposed to be returned in registers,
193 and READBUF is non-zero, read the appropriate value from REGCACHE,
194 and copy it into READBUF. If WRITEBUF is non-zero, write the value
195 from WRITEBUF into REGCACHE. */
197 static enum return_value_convention
198 mn10300_return_value (struct gdbarch
*gdbarch
, struct type
*type
,
199 struct regcache
*regcache
, gdb_byte
*readbuf
,
200 const gdb_byte
*writebuf
)
202 if (mn10300_use_struct_convention (type
))
203 return RETURN_VALUE_STRUCT_CONVENTION
;
206 mn10300_extract_return_value (gdbarch
, type
, regcache
, readbuf
);
208 mn10300_store_return_value (gdbarch
, type
, regcache
, writebuf
);
210 return RETURN_VALUE_REGISTER_CONVENTION
;
214 register_name (int reg
, char **regs
, long sizeof_regs
)
216 if (reg
< 0 || reg
>= sizeof_regs
/ sizeof (regs
[0]))
223 mn10300_generic_register_name (struct gdbarch
*gdbarch
, int reg
)
225 static char *regs
[] =
226 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
227 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
228 "", "", "", "", "", "", "", "",
229 "", "", "", "", "", "", "", "fp"
231 return register_name (reg
, regs
, sizeof regs
);
236 am33_register_name (struct gdbarch
*gdbarch
, int reg
)
238 static char *regs
[] =
239 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
240 "sp", "pc", "mdr", "psw", "lir", "lar", "",
241 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
242 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
244 return register_name (reg
, regs
, sizeof regs
);
248 am33_2_register_name (struct gdbarch
*gdbarch
, int reg
)
250 static char *regs
[] =
252 "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
253 "sp", "pc", "mdr", "psw", "lir", "lar", "mdrq", "r0",
254 "r1", "r2", "r3", "r4", "r5", "r6", "r7", "ssp",
255 "msp", "usp", "mcrh", "mcrl", "mcvf", "fpcr", "", "",
256 "fs0", "fs1", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7",
257 "fs8", "fs9", "fs10", "fs11", "fs12", "fs13", "fs14", "fs15",
258 "fs16", "fs17", "fs18", "fs19", "fs20", "fs21", "fs22", "fs23",
259 "fs24", "fs25", "fs26", "fs27", "fs28", "fs29", "fs30", "fs31"
261 return register_name (reg
, regs
, sizeof regs
);
265 mn10300_register_type (struct gdbarch
*gdbarch
, int reg
)
267 return builtin_type_int
;
271 mn10300_read_pc (struct regcache
*regcache
)
274 regcache_cooked_read_unsigned (regcache
, E_PC_REGNUM
, &val
);
279 mn10300_write_pc (struct regcache
*regcache
, CORE_ADDR val
)
281 regcache_cooked_write_unsigned (regcache
, E_PC_REGNUM
, val
);
284 /* The breakpoint instruction must be the same size as the smallest
285 instruction in the instruction set.
287 The Matsushita mn10x00 processors have single byte instructions
288 so we need a single byte breakpoint. Matsushita hasn't defined
289 one, so we defined it ourselves. */
291 const static unsigned char *
292 mn10300_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*bp_addr
,
295 static char breakpoint
[] = {0xff};
300 /* Set offsets of saved registers.
301 This is a helper function for mn10300_analyze_prologue. */
304 set_reg_offsets (struct frame_info
*fi
,
308 int stack_extra_size
,
311 struct gdbarch
*gdbarch
;
312 struct trad_frame_cache
*cache
;
316 if (fi
== NULL
|| this_cache
== NULL
)
319 cache
= mn10300_frame_unwind_cache (fi
, this_cache
);
322 gdbarch
= get_frame_arch (fi
);
326 base
= frame_unwind_register_unsigned (fi
, E_A3_REGNUM
);
330 base
= frame_unwind_register_unsigned (fi
, E_SP_REGNUM
)
334 trad_frame_set_this_base (cache
, base
);
336 if (AM33_MODE (gdbarch
) == 2)
338 /* If bit N is set in fpregmask, fsN is saved on the stack.
339 The floating point registers are saved in ascending order.
340 For example: fs16 <- Frame Pointer
341 fs17 Frame Pointer + 4 */
345 for (i
= 0; i
< 32; i
++)
347 if (fpregmask
& (1 << i
))
349 trad_frame_set_reg_addr (cache
, E_FS0_REGNUM
+ i
,
358 if (movm_args
& movm_other_bit
)
360 /* The `other' bit leaves a blank area of four bytes at the
361 beginning of its block of saved registers, making it 32 bytes
363 trad_frame_set_reg_addr (cache
, E_LAR_REGNUM
, base
+ offset
+ 4);
364 trad_frame_set_reg_addr (cache
, E_LIR_REGNUM
, base
+ offset
+ 8);
365 trad_frame_set_reg_addr (cache
, E_MDR_REGNUM
, base
+ offset
+ 12);
366 trad_frame_set_reg_addr (cache
, E_A0_REGNUM
+ 1, base
+ offset
+ 16);
367 trad_frame_set_reg_addr (cache
, E_A0_REGNUM
, base
+ offset
+ 20);
368 trad_frame_set_reg_addr (cache
, E_D0_REGNUM
+ 1, base
+ offset
+ 24);
369 trad_frame_set_reg_addr (cache
, E_D0_REGNUM
, base
+ offset
+ 28);
373 if (movm_args
& movm_a3_bit
)
375 trad_frame_set_reg_addr (cache
, E_A3_REGNUM
, base
+ offset
);
378 if (movm_args
& movm_a2_bit
)
380 trad_frame_set_reg_addr (cache
, E_A2_REGNUM
, base
+ offset
);
383 if (movm_args
& movm_d3_bit
)
385 trad_frame_set_reg_addr (cache
, E_D3_REGNUM
, base
+ offset
);
388 if (movm_args
& movm_d2_bit
)
390 trad_frame_set_reg_addr (cache
, E_D2_REGNUM
, base
+ offset
);
393 if (AM33_MODE (gdbarch
))
395 if (movm_args
& movm_exother_bit
)
397 trad_frame_set_reg_addr (cache
, E_MCVF_REGNUM
, base
+ offset
);
398 trad_frame_set_reg_addr (cache
, E_MCRL_REGNUM
, base
+ offset
+ 4);
399 trad_frame_set_reg_addr (cache
, E_MCRH_REGNUM
, base
+ offset
+ 8);
400 trad_frame_set_reg_addr (cache
, E_MDRQ_REGNUM
, base
+ offset
+ 12);
401 trad_frame_set_reg_addr (cache
, E_E1_REGNUM
, base
+ offset
+ 16);
402 trad_frame_set_reg_addr (cache
, E_E0_REGNUM
, base
+ offset
+ 20);
405 if (movm_args
& movm_exreg1_bit
)
407 trad_frame_set_reg_addr (cache
, E_E7_REGNUM
, base
+ offset
);
408 trad_frame_set_reg_addr (cache
, E_E6_REGNUM
, base
+ offset
+ 4);
409 trad_frame_set_reg_addr (cache
, E_E5_REGNUM
, base
+ offset
+ 8);
410 trad_frame_set_reg_addr (cache
, E_E4_REGNUM
, base
+ offset
+ 12);
413 if (movm_args
& movm_exreg0_bit
)
415 trad_frame_set_reg_addr (cache
, E_E3_REGNUM
, base
+ offset
);
416 trad_frame_set_reg_addr (cache
, E_E2_REGNUM
, base
+ offset
+ 4);
420 /* The last (or first) thing on the stack will be the PC. */
421 trad_frame_set_reg_addr (cache
, E_PC_REGNUM
, base
+ offset
);
422 /* Save the SP in the 'traditional' way.
423 This will be the same location where the PC is saved. */
424 trad_frame_set_reg_value (cache
, E_SP_REGNUM
, base
+ offset
);
427 /* The main purpose of this file is dealing with prologues to extract
428 information about stack frames and saved registers.
430 In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
431 function is pretty readable, and has a nice explanation of how the
432 prologue is generated. The prologues generated by that code will
433 have the following form (NOTE: the current code doesn't handle all
436 + If this is an old-style varargs function, then its arguments
437 need to be flushed back to the stack:
442 + If we use any of the callee-saved registers, save them now.
444 movm [some callee-saved registers],(sp)
446 + If we have any floating-point registers to save:
448 - Decrement the stack pointer to reserve space for the registers.
449 If the function doesn't need a frame pointer, we may combine
450 this with the adjustment that reserves space for the frame.
454 - Save the floating-point registers. We have two possible
457 . Save them at fixed offset from the SP:
459 fmov fsN,(OFFSETN,sp)
460 fmov fsM,(OFFSETM,sp)
463 Note that, if OFFSETN happens to be zero, you'll get the
464 different opcode: fmov fsN,(sp)
466 . Or, set a0 to the start of the save area, and then use
467 post-increment addressing to save the FP registers.
475 + If the function needs a frame pointer, we set it here.
479 + Now we reserve space for the stack frame proper. This could be
480 merged into the `add -SIZE, sp' instruction for FP saves up
481 above, unless we needed to set the frame pointer in the previous
482 step, or the frame is so large that allocating the whole thing at
483 once would put the FP register save slots out of reach of the
484 addressing mode (128 bytes).
488 One day we might keep the stack pointer constant, that won't
489 change the code for prologues, but it will make the frame
490 pointerless case much more common. */
492 /* Analyze the prologue to determine where registers are saved,
493 the end of the prologue, etc etc. Return the end of the prologue
496 We store into FI (if non-null) several tidbits of information:
498 * stack_size -- size of this stack frame. Note that if we stop in
499 certain parts of the prologue/epilogue we may claim the size of the
500 current frame is zero. This happens when the current frame has
501 not been allocated yet or has already been deallocated.
503 * fsr -- Addresses of registers saved in the stack by this frame.
505 * status -- A (relatively) generic status indicator. It's a bitmask
506 with the following bits:
508 MY_FRAME_IN_SP: The base of the current frame is actually in
509 the stack pointer. This can happen for frame pointerless
510 functions, or cases where we're stopped in the prologue/epilogue
511 itself. For these cases mn10300_analyze_prologue will need up
512 update fi->frame before returning or analyzing the register
515 MY_FRAME_IN_FP: The base of the current frame is in the
516 frame pointer register ($a3).
518 NO_MORE_FRAMES: Set this if the current frame is "start" or
519 if the first instruction looks like mov <imm>,sp. This tells
520 frame chain to not bother trying to unwind past this frame. */
523 mn10300_analyze_prologue (struct gdbarch
*gdbarch
, struct frame_info
*fi
,
527 CORE_ADDR func_addr
, func_end
, addr
, stop
;
528 long stack_extra_size
= 0;
530 unsigned char buf
[4];
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
));
549 /* Find the start of this function. */
550 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
552 /* Do nothing if we couldn't find the start of this function
554 MVS: comment went on to say "or if we're stopped at the first
555 instruction in the prologue" -- but code doesn't reflect that,
556 and I don't want to do that anyway. */
560 goto finish_prologue
;
563 /* If we're in start, then give up. */
564 if (strcmp (name
, "start") == 0)
567 goto finish_prologue
;
570 /* Figure out where to stop scanning. */
571 stop
= fi
? pc
: func_end
;
573 /* Don't walk off the end of the function. */
574 stop
= stop
> func_end
? func_end
: stop
;
576 /* Start scanning on the first instruction of this function. */
579 /* Suck in two bytes. */
580 if (addr
+ 2 > stop
|| !safe_frame_unwind_memory (fi
, addr
, buf
, 2))
581 goto finish_prologue
;
583 /* First see if this insn sets the stack pointer from a register; if
584 so, it's probably the initialization of the stack pointer in _start,
585 so mark this as the bottom-most frame. */
586 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
588 goto finish_prologue
;
591 /* Now look for movm [regs],sp, which saves the callee saved registers.
593 At this time we don't know if fi->frame is valid, so we only note
594 that we encountered a movm instruction. Later, we'll set the entries
595 in fsr.regs as needed. */
598 /* Extract the register list for the movm instruction. */
603 /* Quit now if we're beyond the stop point. */
605 goto finish_prologue
;
607 /* Get the next two bytes so the prologue scan can continue. */
608 if (!safe_frame_unwind_memory (fi
, addr
, buf
, 2))
609 goto finish_prologue
;
612 /* Check for "mov pc, a2", an instruction found in optimized, position
613 independent code. Skip it if found. */
614 if (buf
[0] == 0xf0 && buf
[1] == 0x2e)
618 /* Quit now if we're beyond the stop point. */
620 goto finish_prologue
;
622 /* Get the next two bytes so the prologue scan can continue. */
623 status
= target_read_memory (addr
, buf
, 2);
625 goto finish_prologue
;
628 if (AM33_MODE (gdbarch
) == 2)
630 /* Determine if any floating point registers are to be saved.
631 Look for one of the following three prologue formats:
633 [movm [regs],(sp)] [movm [regs],(sp)] [movm [regs],(sp)]
635 add -SIZE,sp add -SIZE,sp add -SIZE,sp
636 fmov fs#,(sp) mov sp,a0/a1 mov sp,a0/a1
637 fmov fs#,(#,sp) fmov fs#,(a0/a1+) add SIZE2,a0/a1
638 ... ... fmov fs#,(a0/a1+)
640 fmov fs#,(#,sp) fmov fs#,(a0/a1+) fmov fs#,(a0/a1+)
642 [mov sp,a3] [mov sp,a3]
643 [add -SIZE2,sp] [add -SIZE2,sp] */
645 /* Remember the address at which we started in the event that we
646 don't ultimately find an fmov instruction. Once we're certain
647 that we matched one of the above patterns, we'll set
648 ``restore_addr'' to the appropriate value. Note: At one time
649 in the past, this code attempted to not adjust ``addr'' until
650 there was a fair degree of certainty that the pattern would be
651 matched. However, that code did not wait until an fmov instruction
652 was actually encountered. As a consequence, ``addr'' would
653 sometimes be advanced even when no fmov instructions were found. */
654 CORE_ADDR restore_addr
= addr
;
657 /* First, look for add -SIZE,sp (i.e. add imm8,sp (0xf8feXX)
658 or add imm16,sp (0xfafeXXXX)
659 or add imm32,sp (0xfcfeXXXXXXXX)) */
661 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
663 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
665 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
669 /* An "add -#,sp" instruction has been found. "addr + 2 + imm_size"
670 is the address of the next instruction. Don't modify "addr" until
671 the next "floating point prologue" instruction is found. If this
672 is not a prologue that saves floating point registers we need to
673 be able to back out of this bit of code and continue with the
674 prologue analysis. */
675 if (addr
+ 2 + imm_size
< stop
)
677 if (!safe_frame_unwind_memory (fi
, addr
+ 2 + imm_size
, buf
, 3))
678 goto finish_prologue
;
679 if ((buf
[0] & 0xfc) == 0x3c)
681 /* Occasionally, especially with C++ code, the "fmov"
682 instructions will be preceded by "mov sp,aN"
683 (aN => a0, a1, a2, or a3).
685 This is a one byte instruction: mov sp,aN = 0011 11XX
686 where XX is the register number.
688 Skip this instruction by incrementing addr. The "fmov"
689 instructions will have the form "fmov fs#,(aN+)" in this
690 case, but that will not necessitate a change in the
691 "fmov" parsing logic below. */
695 if ((buf
[1] & 0xfc) == 0x20)
697 /* Occasionally, especially with C++ code compiled with
698 the -fomit-frame-pointer or -O3 options, the
699 "mov sp,aN" instruction will be followed by an
700 "add #,aN" instruction. This indicates the
701 "stack_size", the size of the portion of the stack
702 containing the arguments. This instruction format is:
703 add #,aN = 0010 00XX YYYY YYYY
704 where XX is the register number
705 YYYY YYYY is the constant.
706 Note the size of the stack (as a negative number) in
707 the frame info structure. */
709 stack_extra_size
+= -buf
[2];
715 if ((buf
[0] & 0xfc) == 0x3c ||
716 buf
[0] == 0xf9 || buf
[0] == 0xfb)
718 /* An "fmov" instruction has been found indicating that this
719 prologue saves floating point registers (or, as described
720 above, a "mov sp,aN" and possible "add #,aN" have been
721 found and we will assume an "fmov" follows). Process the
722 consecutive "fmov" instructions. */
723 for (addr
+= 2 + imm_size
;;addr
+= imm_size
)
727 /* Read the "fmov" instruction. */
729 !safe_frame_unwind_memory (fi
, addr
, buf
, 4))
730 goto finish_prologue
;
732 if (buf
[0] != 0xf9 && buf
[0] != 0xfb)
735 /* An fmov instruction has just been seen. We can
736 now really commit to the pattern match. */
740 /* Get the floating point register number from the
741 2nd and 3rd bytes of the "fmov" instruction:
742 Machine Code: 0000 00X0 YYYY 0000 =>
744 regnum
= (buf
[1] & 0x02) << 3;
745 regnum
|= ((buf
[2] & 0xf0) >> 4) & 0x0f;
747 /* Add this register number to the bit mask of floating
748 point registers that have been saved. */
749 fpregmask
|= 1 << regnum
;
751 /* Determine the length of this "fmov" instruction.
752 fmov fs#,(sp) => 3 byte instruction
753 fmov fs#,(#,sp) => 4 byte instruction */
754 imm_size
= (buf
[0] == 0xf9) ? 3 : 4;
759 /* If no fmov instructions were found by the above sequence, reset
760 the state and pretend that the above bit of code never happened. */
764 status
= target_read_memory (addr
, buf
, 2);
766 goto finish_prologue
;
767 stack_extra_size
= 0;
771 /* Now see if we set up a frame pointer via "mov sp,a3" */
776 /* The frame pointer is now valid. */
782 /* Quit now if we're beyond the stop point. */
784 goto finish_prologue
;
786 /* Get two more bytes so scanning can continue. */
787 if (!safe_frame_unwind_memory (fi
, addr
, buf
, 2))
788 goto finish_prologue
;
791 /* Next we should allocate the local frame. No more prologue insns
792 are found after allocating the local frame.
794 Search for add imm8,sp (0xf8feXX)
795 or add imm16,sp (0xfafeXXXX)
796 or add imm32,sp (0xfcfeXXXXXXXX).
798 If none of the above was found, then this prologue has no
802 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
804 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
806 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
811 /* Suck in imm_size more bytes, they'll hold the size of the
813 if (!safe_frame_unwind_memory (fi
, addr
+ 2, buf
, imm_size
))
814 goto finish_prologue
;
816 /* Note the size of the stack. */
817 stack_extra_size
-= extract_signed_integer (buf
, imm_size
);
819 /* We just consumed 2 + imm_size bytes. */
820 addr
+= 2 + imm_size
;
822 /* No more prologue insns follow, so begin preparation to return. */
823 goto finish_prologue
;
825 /* Do the essentials and get out of here. */
827 /* Note if/where callee saved registers were saved. */
829 set_reg_offsets (fi
, this_cache
, movm_args
, fpregmask
, stack_extra_size
,
834 /* Function: skip_prologue
835 Return the address of the first inst past the prologue of the function. */
838 mn10300_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
840 return mn10300_analyze_prologue (gdbarch
, NULL
, NULL
, pc
);
843 /* Simple frame_unwind_cache.
844 This finds the "extra info" for the frame. */
845 struct trad_frame_cache
*
846 mn10300_frame_unwind_cache (struct frame_info
*next_frame
,
847 void **this_prologue_cache
)
849 struct gdbarch
*gdbarch
;
850 struct trad_frame_cache
*cache
;
851 CORE_ADDR pc
, start
, end
;
854 if (*this_prologue_cache
)
855 return (*this_prologue_cache
);
857 gdbarch
= get_frame_arch (next_frame
);
858 cache_p
= trad_frame_cache_zalloc (next_frame
);
859 pc
= gdbarch_unwind_pc (gdbarch
, next_frame
);
860 mn10300_analyze_prologue (gdbarch
, next_frame
, &cache_p
, pc
);
863 if (find_pc_partial_function (pc
, NULL
, &start
, &end
))
864 trad_frame_set_id (cache
,
865 frame_id_build (trad_frame_get_this_base (cache
),
869 start
= frame_func_unwind (next_frame
, NORMAL_FRAME
);
870 trad_frame_set_id (cache
,
871 frame_id_build (trad_frame_get_this_base (cache
),
875 (*this_prologue_cache
) = cache
;
879 /* Here is a dummy implementation. */
880 static struct frame_id
881 mn10300_unwind_dummy_id (struct gdbarch
*gdbarch
,
882 struct frame_info
*next_frame
)
884 return frame_id_build (frame_sp_unwind (next_frame
),
885 frame_pc_unwind (next_frame
));
888 /* Trad frame implementation. */
890 mn10300_frame_this_id (struct frame_info
*next_frame
,
891 void **this_prologue_cache
,
892 struct frame_id
*this_id
)
894 struct trad_frame_cache
*cache
=
895 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
897 trad_frame_get_id (cache
, this_id
);
901 mn10300_frame_prev_register (struct frame_info
*next_frame
,
902 void **this_prologue_cache
,
903 int regnum
, int *optimizedp
,
904 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
905 int *realnump
, gdb_byte
*bufferp
)
907 struct trad_frame_cache
*cache
=
908 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
910 trad_frame_get_register (cache
, next_frame
, regnum
, optimizedp
,
911 lvalp
, addrp
, realnump
, bufferp
);
913 trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum,
914 optimizedp, lvalp, addrp, realnump, bufferp);
918 static const struct frame_unwind mn10300_frame_unwind
= {
920 mn10300_frame_this_id
,
921 mn10300_frame_prev_register
925 mn10300_frame_base_address (struct frame_info
*next_frame
,
926 void **this_prologue_cache
)
928 struct trad_frame_cache
*cache
=
929 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
931 return trad_frame_get_this_base (cache
);
934 static const struct frame_unwind
*
935 mn10300_frame_sniffer (struct frame_info
*next_frame
)
937 return &mn10300_frame_unwind
;
940 static const struct frame_base mn10300_frame_base
= {
941 &mn10300_frame_unwind
,
942 mn10300_frame_base_address
,
943 mn10300_frame_base_address
,
944 mn10300_frame_base_address
948 mn10300_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
952 pc
= frame_unwind_register_unsigned (next_frame
, E_PC_REGNUM
);
957 mn10300_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
961 sp
= frame_unwind_register_unsigned (next_frame
, E_SP_REGNUM
);
966 mn10300_frame_unwind_init (struct gdbarch
*gdbarch
)
968 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
969 frame_unwind_append_sniffer (gdbarch
, mn10300_frame_sniffer
);
970 frame_base_set_default (gdbarch
, &mn10300_frame_base
);
971 set_gdbarch_unwind_dummy_id (gdbarch
, mn10300_unwind_dummy_id
);
972 set_gdbarch_unwind_pc (gdbarch
, mn10300_unwind_pc
);
973 set_gdbarch_unwind_sp (gdbarch
, mn10300_unwind_sp
);
976 /* Function: push_dummy_call
978 * Set up machine state for a target call, including
979 * function arguments, stack, return address, etc.
984 mn10300_push_dummy_call (struct gdbarch
*gdbarch
,
985 struct value
*target_func
,
986 struct regcache
*regcache
,
988 int nargs
, struct value
**args
,
991 CORE_ADDR struct_addr
)
993 const int push_size
= register_size (gdbarch
, E_PC_REGNUM
);
996 int stack_offset
= 0;
998 char *val
, valbuf
[MAX_REGISTER_SIZE
];
1000 /* This should be a nop, but align the stack just in case something
1001 went wrong. Stacks are four byte aligned on the mn10300. */
1004 /* Now make space on the stack for the args.
1006 XXX This doesn't appear to handle pass-by-invisible reference
1008 regs_used
= struct_return
? 1 : 0;
1009 for (len
= 0, argnum
= 0; argnum
< nargs
; argnum
++)
1011 arg_len
= (TYPE_LENGTH (value_type (args
[argnum
])) + 3) & ~3;
1012 while (regs_used
< 2 && arg_len
> 0)
1015 arg_len
-= push_size
;
1020 /* Allocate stack space. */
1026 regcache_cooked_write_unsigned (regcache
, E_D0_REGNUM
, struct_addr
);
1031 /* Push all arguments onto the stack. */
1032 for (argnum
= 0; argnum
< nargs
; argnum
++)
1034 /* FIXME what about structs? Unions? */
1035 if (TYPE_CODE (value_type (*args
)) == TYPE_CODE_STRUCT
1036 && TYPE_LENGTH (value_type (*args
)) > 8)
1038 /* Change to pointer-to-type. */
1039 arg_len
= push_size
;
1040 store_unsigned_integer (valbuf
, push_size
,
1041 VALUE_ADDRESS (*args
));
1046 arg_len
= TYPE_LENGTH (value_type (*args
));
1047 val
= (char *) value_contents (*args
);
1050 while (regs_used
< 2 && arg_len
> 0)
1052 regcache_cooked_write_unsigned (regcache
, regs_used
,
1053 extract_unsigned_integer (val
, push_size
));
1055 arg_len
-= push_size
;
1061 write_memory (sp
+ stack_offset
, val
, push_size
);
1062 arg_len
-= push_size
;
1064 stack_offset
+= push_size
;
1070 /* Make space for the flushback area. */
1073 /* Push the return address that contains the magic breakpoint. */
1075 write_memory_unsigned_integer (sp
, push_size
, bp_addr
);
1077 /* The CPU also writes the return address always into the
1078 MDR register on "call". */
1079 regcache_cooked_write_unsigned (regcache
, E_MDR_REGNUM
, bp_addr
);
1082 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
1084 /* On the mn10300, it's possible to move some of the stack adjustment
1085 and saving of the caller-save registers out of the prologue and
1086 into the call sites. (When using gcc, this optimization can
1087 occur when using the -mrelax switch.) If this occurs, the dwarf2
1088 info will reflect this fact. We can test to see if this is the
1089 case by creating a new frame using the current stack pointer and
1090 the address of the function that we're about to call. We then
1091 unwind SP and see if it's different than the SP of our newly
1092 created frame. If the SP values are the same, the caller is not
1093 expected to allocate any additional stack. On the other hand, if
1094 the SP values are different, the difference determines the
1095 additional stack that must be allocated.
1097 Note that we don't update the return value though because that's
1098 the value of the stack just after pushing the arguments, but prior
1099 to performing the call. This value is needed in order to
1100 construct the frame ID of the dummy call. */
1102 CORE_ADDR func_addr
= find_function_addr (target_func
, NULL
);
1103 CORE_ADDR unwound_sp
1104 = mn10300_unwind_sp (gdbarch
, create_new_frame (sp
, func_addr
));
1105 if (sp
!= unwound_sp
)
1106 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
,
1107 sp
- (unwound_sp
- sp
));
1113 /* If DWARF2 is a register number appearing in Dwarf2 debug info, then
1114 mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
1115 register number. Why don't Dwarf2 and GDB use the same numbering?
1116 Who knows? But since people have object files lying around with
1117 the existing Dwarf2 numbering, and other people have written stubs
1118 to work with the existing GDB, neither of them can change. So we
1119 just have to cope. */
1121 mn10300_dwarf2_reg_to_regnum (struct gdbarch
*gdbarch
, int dwarf2
)
1123 /* This table is supposed to be shaped like the gdbarch_register_name
1124 initializer in gcc/config/mn10300/mn10300.h. Registers which
1125 appear in GCC's numbering, but have no counterpart in GDB's
1126 world, are marked with a -1. */
1127 static int dwarf2_to_gdb
[] = {
1128 0, 1, 2, 3, 4, 5, 6, 7, -1, 8,
1129 15, 16, 17, 18, 19, 20, 21, 22,
1130 32, 33, 34, 35, 36, 37, 38, 39,
1131 40, 41, 42, 43, 44, 45, 46, 47,
1132 48, 49, 50, 51, 52, 53, 54, 55,
1133 56, 57, 58, 59, 60, 61, 62, 63,
1138 || dwarf2
>= ARRAY_SIZE (dwarf2_to_gdb
))
1140 warning (_("Bogus register number in debug info: %d"), dwarf2
);
1144 return dwarf2_to_gdb
[dwarf2
];
1147 static struct gdbarch
*
1148 mn10300_gdbarch_init (struct gdbarch_info info
,
1149 struct gdbarch_list
*arches
)
1151 struct gdbarch
*gdbarch
;
1152 struct gdbarch_tdep
*tdep
;
1155 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1157 return arches
->gdbarch
;
1159 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
1160 gdbarch
= gdbarch_alloc (&info
, tdep
);
1162 switch (info
.bfd_arch_info
->mach
)
1165 case bfd_mach_mn10300
:
1166 set_gdbarch_register_name (gdbarch
, mn10300_generic_register_name
);
1167 tdep
->am33_mode
= 0;
1171 set_gdbarch_register_name (gdbarch
, am33_register_name
);
1172 tdep
->am33_mode
= 1;
1175 case bfd_mach_am33_2
:
1176 set_gdbarch_register_name (gdbarch
, am33_2_register_name
);
1177 tdep
->am33_mode
= 2;
1179 set_gdbarch_fp0_regnum (gdbarch
, 32);
1182 internal_error (__FILE__
, __LINE__
,
1183 _("mn10300_gdbarch_init: Unknown mn10300 variant"));
1188 set_gdbarch_num_regs (gdbarch
, num_regs
);
1189 set_gdbarch_register_type (gdbarch
, mn10300_register_type
);
1190 set_gdbarch_skip_prologue (gdbarch
, mn10300_skip_prologue
);
1191 set_gdbarch_read_pc (gdbarch
, mn10300_read_pc
);
1192 set_gdbarch_write_pc (gdbarch
, mn10300_write_pc
);
1193 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
1194 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
1195 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, mn10300_dwarf2_reg_to_regnum
);
1197 /* Stack unwinding. */
1198 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1200 set_gdbarch_breakpoint_from_pc (gdbarch
, mn10300_breakpoint_from_pc
);
1201 /* decr_pc_after_break? */
1203 set_gdbarch_print_insn (gdbarch
, print_insn_mn10300
);
1206 set_gdbarch_return_value (gdbarch
, mn10300_return_value
);
1208 /* Stage 3 -- get target calls working. */
1209 set_gdbarch_push_dummy_call (gdbarch
, mn10300_push_dummy_call
);
1210 /* set_gdbarch_return_value (store, extract) */
1213 mn10300_frame_unwind_init (gdbarch
);
1215 /* Hook in ABI-specific overrides, if they have been registered. */
1216 gdbarch_init_osabi (info
, gdbarch
);
1221 /* Dump out the mn10300 specific architecture information. */
1224 mn10300_dump_tdep (struct gdbarch
*gdbarch
, struct ui_file
*file
)
1226 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1227 fprintf_unfiltered (file
, "mn10300_dump_tdep: am33_mode = %d\n",
1232 _initialize_mn10300_tdep (void)
1234 gdbarch_register (bfd_arch_mn10300
, mn10300_gdbarch_init
, mn10300_dump_tdep
);