1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
29 #include "gdb_string.h"
33 #include "arch-utils.h"
35 extern void _initialize_mn10300_tdep (void);
36 static CORE_ADDR mn10300_analyze_prologue (struct frame_info *fi,
39 /* mn10300 private data */
43 #define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode)
46 /* Additional info used by the frame */
48 struct frame_extra_info
56 register_name (int reg, char **regs, long sizeof_regs)
58 if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
65 mn10300_generic_register_name (int reg)
68 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
69 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
70 "", "", "", "", "", "", "", "",
71 "", "", "", "", "", "", "", "fp"
73 return register_name (reg, regs, sizeof regs);
78 am33_register_name (int reg)
81 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
82 "sp", "pc", "mdr", "psw", "lir", "lar", "",
83 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
84 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
86 return register_name (reg, regs, sizeof regs);
90 mn10300_saved_pc_after_call (struct frame_info *fi)
92 return read_memory_integer (read_register (SP_REGNUM), 4);
96 mn10300_extract_return_value (struct type *type, char *regbuf, char *valbuf)
98 if (TYPE_CODE (type) == TYPE_CODE_PTR)
99 memcpy (valbuf, regbuf + REGISTER_BYTE (4), TYPE_LENGTH (type));
101 memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (type));
105 mn10300_extract_struct_value_address (char *regbuf)
107 return extract_address (regbuf + REGISTER_BYTE (4),
108 REGISTER_RAW_SIZE (4));
112 mn10300_store_return_value (struct type *type, char *valbuf)
114 if (TYPE_CODE (type) == TYPE_CODE_PTR)
115 write_register_bytes (REGISTER_BYTE (4), valbuf, TYPE_LENGTH (type));
117 write_register_bytes (REGISTER_BYTE (0), valbuf, TYPE_LENGTH (type));
120 static struct frame_info *analyze_dummy_frame (CORE_ADDR, CORE_ADDR);
121 static struct frame_info *
122 analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
124 static struct frame_info *dummy = NULL;
127 dummy = xmalloc (sizeof (struct frame_info));
128 dummy->saved_regs = xmalloc (SIZEOF_FRAME_SAVED_REGS);
129 dummy->extra_info = xmalloc (sizeof (struct frame_extra_info));
134 dummy->frame = frame;
135 dummy->extra_info->status = 0;
136 dummy->extra_info->stack_size = 0;
137 memset (dummy->saved_regs, '\000', SIZEOF_FRAME_SAVED_REGS);
138 mn10300_analyze_prologue (dummy, 0);
142 /* Values for frame_info.status */
144 #define MY_FRAME_IN_SP 0x1
145 #define MY_FRAME_IN_FP 0x2
146 #define NO_MORE_FRAMES 0x4
149 /* Should call_function allocate stack space for a struct return? */
151 mn10300_use_struct_convention (int gcc_p, struct type *type)
153 return (TYPE_NFIELDS (type) > 1 || TYPE_LENGTH (type) > 8);
156 /* The breakpoint instruction must be the same size as the smallest
157 instruction in the instruction set.
159 The Matsushita mn10x00 processors have single byte instructions
160 so we need a single byte breakpoint. Matsushita hasn't defined
161 one, so we defined it ourselves. */
163 static unsigned char *
164 mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
166 static char breakpoint[] =
173 /* Fix fi->frame if it's bogus at this point. This is a helper
174 function for mn10300_analyze_prologue. */
177 fix_frame_pointer (struct frame_info *fi, int stack_size)
179 if (fi && fi->next == NULL)
181 if (fi->extra_info->status & MY_FRAME_IN_SP)
182 fi->frame = read_sp () - stack_size;
183 else if (fi->extra_info->status & MY_FRAME_IN_FP)
184 fi->frame = read_register (A3_REGNUM);
189 /* Set offsets of registers saved by movm instruction.
190 This is a helper function for mn10300_analyze_prologue. */
193 set_movm_offsets (struct frame_info *fi, int movm_args)
197 if (fi == NULL || movm_args == 0)
200 if (movm_args & movm_other_bit)
202 /* The `other' bit leaves a blank area of four bytes at the
203 beginning of its block of saved registers, making it 32 bytes
205 fi->saved_regs[LAR_REGNUM] = fi->frame + offset + 4;
206 fi->saved_regs[LIR_REGNUM] = fi->frame + offset + 8;
207 fi->saved_regs[MDR_REGNUM] = fi->frame + offset + 12;
208 fi->saved_regs[A0_REGNUM + 1] = fi->frame + offset + 16;
209 fi->saved_regs[A0_REGNUM] = fi->frame + offset + 20;
210 fi->saved_regs[D0_REGNUM + 1] = fi->frame + offset + 24;
211 fi->saved_regs[D0_REGNUM] = fi->frame + offset + 28;
214 if (movm_args & movm_a3_bit)
216 fi->saved_regs[A3_REGNUM] = fi->frame + offset;
219 if (movm_args & movm_a2_bit)
221 fi->saved_regs[A2_REGNUM] = fi->frame + offset;
224 if (movm_args & movm_d3_bit)
226 fi->saved_regs[D3_REGNUM] = fi->frame + offset;
229 if (movm_args & movm_d2_bit)
231 fi->saved_regs[D2_REGNUM] = fi->frame + offset;
236 if (movm_args & movm_exother_bit)
238 fi->saved_regs[MCVF_REGNUM] = fi->frame + offset;
239 fi->saved_regs[MCRL_REGNUM] = fi->frame + offset + 4;
240 fi->saved_regs[MCRH_REGNUM] = fi->frame + offset + 8;
241 fi->saved_regs[MDRQ_REGNUM] = fi->frame + offset + 12;
242 fi->saved_regs[E0_REGNUM + 1] = fi->frame + offset + 16;
243 fi->saved_regs[E0_REGNUM + 0] = fi->frame + offset + 20;
246 if (movm_args & movm_exreg1_bit)
248 fi->saved_regs[E0_REGNUM + 7] = fi->frame + offset;
249 fi->saved_regs[E0_REGNUM + 6] = fi->frame + offset + 4;
250 fi->saved_regs[E0_REGNUM + 5] = fi->frame + offset + 8;
251 fi->saved_regs[E0_REGNUM + 4] = fi->frame + offset + 12;
254 if (movm_args & movm_exreg0_bit)
256 fi->saved_regs[E0_REGNUM + 3] = fi->frame + offset;
257 fi->saved_regs[E0_REGNUM + 2] = fi->frame + offset + 4;
264 /* The main purpose of this file is dealing with prologues to extract
265 information about stack frames and saved registers.
267 For reference here's how prologues look on the mn10300:
270 movm [d2,d3,a2,a3],sp
274 Without frame pointer:
275 movm [d2,d3,a2,a3],sp (if needed)
278 One day we might keep the stack pointer constant, that won't
279 change the code for prologues, but it will make the frame
280 pointerless case much more common. */
282 /* Analyze the prologue to determine where registers are saved,
283 the end of the prologue, etc etc. Return the end of the prologue
286 We store into FI (if non-null) several tidbits of information:
288 * stack_size -- size of this stack frame. Note that if we stop in
289 certain parts of the prologue/epilogue we may claim the size of the
290 current frame is zero. This happens when the current frame has
291 not been allocated yet or has already been deallocated.
293 * fsr -- Addresses of registers saved in the stack by this frame.
295 * status -- A (relatively) generic status indicator. It's a bitmask
296 with the following bits:
298 MY_FRAME_IN_SP: The base of the current frame is actually in
299 the stack pointer. This can happen for frame pointerless
300 functions, or cases where we're stopped in the prologue/epilogue
301 itself. For these cases mn10300_analyze_prologue will need up
302 update fi->frame before returning or analyzing the register
305 MY_FRAME_IN_FP: The base of the current frame is in the
306 frame pointer register ($a2).
308 NO_MORE_FRAMES: Set this if the current frame is "start" or
309 if the first instruction looks like mov <imm>,sp. This tells
310 frame chain to not bother trying to unwind past this frame. */
313 mn10300_analyze_prologue (struct frame_info *fi, CORE_ADDR pc)
315 CORE_ADDR func_addr, func_end, addr, stop;
316 CORE_ADDR stack_size;
318 unsigned char buf[4];
319 int status, movm_args = 0;
322 /* Use the PC in the frame if it's provided to look up the
323 start of this function. */
324 pc = (fi ? fi->pc : pc);
326 /* Find the start of this function. */
327 status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
329 /* Do nothing if we couldn't find the start of this function or if we're
330 stopped at the first instruction in the prologue. */
336 /* If we're in start, then give up. */
337 if (strcmp (name, "start") == 0)
340 fi->extra_info->status = NO_MORE_FRAMES;
344 /* At the start of a function our frame is in the stack pointer. */
346 fi->extra_info->status = MY_FRAME_IN_SP;
348 /* Get the next two bytes into buf, we need two because rets is a two
349 byte insn and the first isn't enough to uniquely identify it. */
350 status = read_memory_nobpt (pc, buf, 2);
354 /* If we're physically on an "rets" instruction, then our frame has
355 already been deallocated. Note this can also be true for retf
356 and ret if they specify a size of zero.
358 In this case fi->frame is bogus, we need to fix it. */
359 if (fi && buf[0] == 0xf0 && buf[1] == 0xfc)
361 if (fi->next == NULL)
362 fi->frame = read_sp ();
366 /* Similarly if we're stopped on the first insn of a prologue as our
367 frame hasn't been allocated yet. */
368 if (fi && fi->pc == func_addr)
370 if (fi->next == NULL)
371 fi->frame = read_sp ();
375 /* Figure out where to stop scanning. */
376 stop = fi ? fi->pc : func_end;
378 /* Don't walk off the end of the function. */
379 stop = stop > func_end ? func_end : stop;
381 /* Start scanning on the first instruction of this function. */
384 /* Suck in two bytes. */
385 status = read_memory_nobpt (addr, buf, 2);
388 fix_frame_pointer (fi, 0);
392 /* First see if this insn sets the stack pointer; if so, it's something
393 we won't understand, so quit now. */
394 if (buf[0] == 0xf2 && (buf[1] & 0xf3) == 0xf0)
397 fi->extra_info->status = NO_MORE_FRAMES;
401 /* Now look for movm [regs],sp, which saves the callee saved registers.
403 At this time we don't know if fi->frame is valid, so we only note
404 that we encountered a movm instruction. Later, we'll set the entries
405 in fsr.regs as needed. */
408 /* Extract the register list for the movm instruction. */
409 status = read_memory_nobpt (addr + 1, buf, 1);
414 /* Quit now if we're beyond the stop point. */
417 /* Fix fi->frame since it's bogus at this point. */
418 if (fi && fi->next == NULL)
419 fi->frame = read_sp ();
421 /* Note if/where callee saved registers were saved. */
422 set_movm_offsets (fi, movm_args);
426 /* Get the next two bytes so the prologue scan can continue. */
427 status = read_memory_nobpt (addr, buf, 2);
430 /* Fix fi->frame since it's bogus at this point. */
431 if (fi && fi->next == NULL)
432 fi->frame = read_sp ();
434 /* Note if/where callee saved registers were saved. */
435 set_movm_offsets (fi, movm_args);
440 /* Now see if we set up a frame pointer via "mov sp,a3" */
445 /* The frame pointer is now valid. */
448 fi->extra_info->status |= MY_FRAME_IN_FP;
449 fi->extra_info->status &= ~MY_FRAME_IN_SP;
452 /* Quit now if we're beyond the stop point. */
455 /* Fix fi->frame if it's bogus at this point. */
456 fix_frame_pointer (fi, 0);
458 /* Note if/where callee saved registers were saved. */
459 set_movm_offsets (fi, movm_args);
463 /* Get two more bytes so scanning can continue. */
464 status = read_memory_nobpt (addr, buf, 2);
467 /* Fix fi->frame if it's bogus at this point. */
468 fix_frame_pointer (fi, 0);
470 /* Note if/where callee saved registers were saved. */
471 set_movm_offsets (fi, movm_args);
476 /* Next we should allocate the local frame. No more prologue insns
477 are found after allocating the local frame.
479 Search for add imm8,sp (0xf8feXX)
480 or add imm16,sp (0xfafeXXXX)
481 or add imm32,sp (0xfcfeXXXXXXXX).
483 If none of the above was found, then this prologue has no
486 status = read_memory_nobpt (addr, buf, 2);
489 /* Fix fi->frame if it's bogus at this point. */
490 fix_frame_pointer (fi, 0);
492 /* Note if/where callee saved registers were saved. */
493 set_movm_offsets (fi, movm_args);
498 if (buf[0] == 0xf8 && buf[1] == 0xfe)
500 else if (buf[0] == 0xfa && buf[1] == 0xfe)
502 else if (buf[0] == 0xfc && buf[1] == 0xfe)
507 /* Suck in imm_size more bytes, they'll hold the size of the
509 status = read_memory_nobpt (addr + 2, buf, imm_size);
512 /* Fix fi->frame if it's bogus at this point. */
513 fix_frame_pointer (fi, 0);
515 /* Note if/where callee saved registers were saved. */
516 set_movm_offsets (fi, movm_args);
520 /* Note the size of the stack in the frame info structure. */
521 stack_size = extract_signed_integer (buf, imm_size);
523 fi->extra_info->stack_size = stack_size;
525 /* We just consumed 2 + imm_size bytes. */
526 addr += 2 + imm_size;
528 /* No more prologue insns follow, so begin preparation to return. */
529 /* Fix fi->frame if it's bogus at this point. */
530 fix_frame_pointer (fi, stack_size);
532 /* Note if/where callee saved registers were saved. */
533 set_movm_offsets (fi, movm_args);
537 /* We never found an insn which allocates local stack space, regardless
538 this is the end of the prologue. */
539 /* Fix fi->frame if it's bogus at this point. */
540 fix_frame_pointer (fi, 0);
542 /* Note if/where callee saved registers were saved. */
543 set_movm_offsets (fi, movm_args);
548 /* Function: saved_regs_size
549 Return the size in bytes of the register save area, based on the
550 saved_regs array in FI. */
552 saved_regs_size (struct frame_info *fi)
557 /* Reserve four bytes for every register saved. */
558 for (i = 0; i < NUM_REGS; i++)
559 if (fi->saved_regs[i])
562 /* If we saved LIR, then it's most likely we used a `movm'
563 instruction with the `other' bit set, in which case the SP is
564 decremented by an extra four bytes, "to simplify calculation
565 of the transfer area", according to the processor manual. */
566 if (fi->saved_regs[LIR_REGNUM])
573 /* Function: frame_chain
574 Figure out and return the caller's frame pointer given current
577 We don't handle dummy frames yet but we would probably just return the
578 stack pointer that was in use at the time the function call was made? */
581 mn10300_frame_chain (struct frame_info *fi)
583 struct frame_info *dummy;
584 /* Walk through the prologue to determine the stack size,
585 location of saved registers, end of the prologue, etc. */
586 if (fi->extra_info->status == 0)
587 mn10300_analyze_prologue (fi, (CORE_ADDR) 0);
589 /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
590 if (fi->extra_info->status & NO_MORE_FRAMES)
593 /* Now that we've analyzed our prologue, determine the frame
594 pointer for our caller.
596 If our caller has a frame pointer, then we need to
597 find the entry value of $a3 to our function.
599 If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
600 location pointed to by fsr.regs[A3_REGNUM].
602 Else it's still in $a3.
604 If our caller does not have a frame pointer, then his
605 frame base is fi->frame + -caller's stack size. */
607 /* The easiest way to get that info is to analyze our caller's frame.
608 So we set up a dummy frame and call mn10300_analyze_prologue to
609 find stuff for us. */
610 dummy = analyze_dummy_frame (FRAME_SAVED_PC (fi), fi->frame);
612 if (dummy->extra_info->status & MY_FRAME_IN_FP)
614 /* Our caller has a frame pointer. So find the frame in $a3 or
616 if (fi->saved_regs[A3_REGNUM])
617 return (read_memory_integer (fi->saved_regs[A3_REGNUM], REGISTER_SIZE));
619 return read_register (A3_REGNUM);
623 int adjust = saved_regs_size (fi);
625 /* Our caller does not have a frame pointer. So his frame starts
626 at the base of our frame (fi->frame) + register save space
628 return fi->frame + adjust + -dummy->extra_info->stack_size;
632 /* Function: skip_prologue
633 Return the address of the first inst past the prologue of the function. */
636 mn10300_skip_prologue (CORE_ADDR pc)
638 /* We used to check the debug symbols, but that can lose if
639 we have a null prologue. */
640 return mn10300_analyze_prologue (NULL, pc);
643 /* generic_pop_current_frame calls this function if the current
644 frame isn't a dummy frame. */
646 mn10300_pop_frame_regular (struct frame_info *frame)
650 write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
652 /* Restore any saved registers. */
653 for (regnum = 0; regnum < NUM_REGS; regnum++)
654 if (frame->saved_regs[regnum] != 0)
658 value = read_memory_unsigned_integer (frame->saved_regs[regnum],
659 REGISTER_RAW_SIZE (regnum));
660 write_register (regnum, value);
663 /* Actually cut back the stack. */
664 write_register (SP_REGNUM, FRAME_FP (frame));
666 /* Don't we need to set the PC?!? XXX FIXME. */
669 /* Function: pop_frame
670 This routine gets called when either the user uses the `return'
671 command, or the call dummy breakpoint gets hit. */
673 mn10300_pop_frame (void)
675 /* This function checks for and handles generic dummy frames, and
676 calls back to our function for ordinary frames. */
677 generic_pop_current_frame (mn10300_pop_frame_regular);
679 /* Throw away any cached frame information. */
680 flush_cached_frames ();
683 /* Function: push_arguments
684 Setup arguments for a call to the target. Arguments go in
685 order on the stack. */
688 mn10300_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
689 int struct_return, CORE_ADDR struct_addr)
693 int stack_offset = 0;
694 int regsused = struct_return ? 1 : 0;
696 /* This should be a nop, but align the stack just in case something
697 went wrong. Stacks are four byte aligned on the mn10300. */
700 /* Now make space on the stack for the args.
702 XXX This doesn't appear to handle pass-by-invisible reference
704 for (argnum = 0; argnum < nargs; argnum++)
706 int arg_length = (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3;
708 while (regsused < 2 && arg_length > 0)
716 /* Allocate stack space. */
719 regsused = struct_return ? 1 : 0;
720 /* Push all arguments onto the stack. */
721 for (argnum = 0; argnum < nargs; argnum++)
726 /* XXX Check this. What about UNIONS? */
727 if (TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_STRUCT
728 && TYPE_LENGTH (VALUE_TYPE (*args)) > 8)
730 /* XXX Wrong, we want a pointer to this argument. */
731 len = TYPE_LENGTH (VALUE_TYPE (*args));
732 val = (char *) VALUE_CONTENTS (*args);
736 len = TYPE_LENGTH (VALUE_TYPE (*args));
737 val = (char *) VALUE_CONTENTS (*args);
740 while (regsused < 2 && len > 0)
742 write_register (regsused, extract_unsigned_integer (val, 4));
750 write_memory (sp + stack_offset, val, 4);
759 /* Make space for the flushback area. */
764 /* Function: push_return_address (pc)
765 Set up the return address for the inferior function call.
766 Needed for targets where we don't actually execute a JSR/BSR instruction */
769 mn10300_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
771 unsigned char buf[4];
773 store_unsigned_integer (buf, 4, CALL_DUMMY_ADDRESS ());
774 write_memory (sp - 4, buf, 4);
778 /* Function: store_struct_return (addr,sp)
779 Store the structure value return address for an inferior function
783 mn10300_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
785 /* The structure return address is passed as the first argument. */
786 write_register (0, addr);
789 /* Function: frame_saved_pc
790 Find the caller of this frame. We do this by seeing if RP_REGNUM
791 is saved in the stack anywhere, otherwise we get it from the
792 registers. If the inner frame is a dummy frame, return its PC
793 instead of RP, because that's where "caller" of the dummy-frame
797 mn10300_frame_saved_pc (struct frame_info *fi)
799 int adjust = saved_regs_size (fi);
801 return (read_memory_integer (fi->frame + adjust, REGISTER_SIZE));
804 /* Function: mn10300_init_extra_frame_info
805 Setup the frame's frame pointer, pc, and frame addresses for saved
806 registers. Most of the work is done in mn10300_analyze_prologue().
808 Note that when we are called for the last frame (currently active frame),
809 that fi->pc and fi->frame will already be setup. However, fi->frame will
810 be valid only if this routine uses FP. For previous frames, fi-frame will
811 always be correct. mn10300_analyze_prologue will fix fi->frame if
814 We can be called with the PC in the call dummy under two circumstances.
815 First, during normal backtracing, second, while figuring out the frame
816 pointer just prior to calling the target function (see run_stack_dummy). */
819 mn10300_init_extra_frame_info (int fromleaf, struct frame_info *fi)
822 fi->pc = FRAME_SAVED_PC (fi->next);
824 frame_saved_regs_zalloc (fi);
825 fi->extra_info = (struct frame_extra_info *)
826 frame_obstack_alloc (sizeof (struct frame_extra_info));
828 fi->extra_info->status = 0;
829 fi->extra_info->stack_size = 0;
831 mn10300_analyze_prologue (fi, 0);
835 /* This function's job is handled by init_extra_frame_info. */
837 mn10300_frame_init_saved_regs (struct frame_info *frame)
842 /* Function: mn10300_virtual_frame_pointer
843 Return the register that the function uses for a frame pointer,
844 plus any necessary offset to be applied to the register before
845 any frame pointer offsets. */
848 mn10300_virtual_frame_pointer (CORE_ADDR pc,
852 struct frame_info *dummy = analyze_dummy_frame (pc, 0);
853 /* Set up a dummy frame_info, Analyze the prolog and fill in the
855 /* Results will tell us which type of frame it uses. */
856 if (dummy->extra_info->status & MY_FRAME_IN_SP)
859 *offset = -(dummy->extra_info->stack_size);
869 mn10300_reg_struct_has_addr (int gcc_p, struct type *type)
871 return (TYPE_LENGTH (type) > 8);
875 mn10300_register_virtual_type (int reg)
877 return builtin_type_int;
881 mn10300_register_byte (int reg)
887 mn10300_register_virtual_size (int reg)
893 mn10300_register_raw_size (int reg)
898 /* If DWARF2 is a register number appearing in Dwarf2 debug info, then
899 mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
900 register number. Why don't Dwarf2 and GDB use the same numbering?
901 Who knows? But since people have object files lying around with
902 the existing Dwarf2 numbering, and other people have written stubs
903 to work with the existing GDB, neither of them can change. So we
904 just have to cope. */
906 mn10300_dwarf2_reg_to_regnum (int dwarf2)
908 /* This table is supposed to be shaped like the REGISTER_NAMES
909 initializer in gcc/config/mn10300/mn10300.h. Registers which
910 appear in GCC's numbering, but have no counterpart in GDB's
911 world, are marked with a -1. */
912 static int dwarf2_to_gdb[] = {
913 0, 1, 2, 3, 4, 5, 6, 7, -1, 8,
914 15, 16, 17, 18, 19, 20, 21, 22
919 || dwarf2 >= (sizeof (dwarf2_to_gdb) / sizeof (dwarf2_to_gdb[0]))
920 || dwarf2_to_gdb[dwarf2] == -1)
921 internal_error (__FILE__, __LINE__,
922 "bogus register number in debug info: %d", dwarf2);
924 return dwarf2_to_gdb[dwarf2];
928 mn10300_print_register (const char *name, int regnum, int reg_width)
930 char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
933 printf_filtered ("%*s: ", reg_width, name);
935 printf_filtered ("%s: ", name);
938 if (read_relative_register_raw_bytes (regnum, raw_buffer))
940 printf_filtered ("[invalid]");
946 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
948 for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
949 byte < REGISTER_RAW_SIZE (regnum);
951 printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
955 for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
958 printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
964 mn10300_do_registers_info (int regnum, int fpregs)
968 const char *name = REGISTER_NAME (regnum);
969 if (name == NULL || name[0] == '\0')
970 error ("Not a valid register for the current processor type");
971 mn10300_print_register (name, regnum, 0);
972 printf_filtered ("\n");
976 /* print registers in an array 4x8 */
979 const int nr_in_row = 4;
980 const int reg_width = 4;
981 for (r = 0; r < NUM_REGS; r += nr_in_row)
986 for (c = r; c < r + nr_in_row; c++)
988 const char *name = REGISTER_NAME (c);
989 if (name != NULL && *name != '\0')
994 printf_filtered (" ");
997 mn10300_print_register (name, c, reg_width);
998 printf_filtered (" ");
1002 padding += (reg_width + 2 + 8 + 1);
1006 printf_filtered ("\n");
1011 /* Dump out the mn10300 speciic architecture information. */
1014 mn10300_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
1016 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
1017 fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
1021 static struct gdbarch *
1022 mn10300_gdbarch_init (struct gdbarch_info info,
1023 struct gdbarch_list *arches)
1025 static LONGEST mn10300_call_dummy_words[] = { 0 };
1026 struct gdbarch *gdbarch;
1027 struct gdbarch_tdep *tdep = NULL;
1029 gdbarch_register_name_ftype *register_name;
1033 arches = gdbarch_list_lookup_by_info (arches, &info);
1035 return arches->gdbarch;
1036 tdep = xmalloc (sizeof (struct gdbarch_tdep));
1037 gdbarch = gdbarch_alloc (&info, tdep);
1039 if (info.bfd_arch_info != NULL
1040 && info.bfd_arch_info->arch == bfd_arch_mn10300)
1041 mach = info.bfd_arch_info->mach;
1047 case bfd_mach_mn10300:
1049 register_name = mn10300_generic_register_name;
1054 register_name = am33_register_name;
1058 internal_error (__FILE__, __LINE__,
1059 "mn10300_gdbarch_init: Unknown mn10300 variant");
1060 return NULL; /* keep GCC happy. */
1064 set_gdbarch_num_regs (gdbarch, num_regs);
1065 set_gdbarch_register_name (gdbarch, register_name);
1066 set_gdbarch_register_size (gdbarch, 4);
1067 set_gdbarch_register_bytes (gdbarch,
1068 num_regs * gdbarch_register_size (gdbarch));
1069 set_gdbarch_max_register_raw_size (gdbarch, 4);
1070 set_gdbarch_register_raw_size (gdbarch, mn10300_register_raw_size);
1071 set_gdbarch_register_byte (gdbarch, mn10300_register_byte);
1072 set_gdbarch_max_register_virtual_size (gdbarch, 4);
1073 set_gdbarch_register_virtual_size (gdbarch, mn10300_register_virtual_size);
1074 set_gdbarch_register_virtual_type (gdbarch, mn10300_register_virtual_type);
1075 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, mn10300_dwarf2_reg_to_regnum);
1076 set_gdbarch_do_registers_info (gdbarch, mn10300_do_registers_info);
1077 set_gdbarch_sp_regnum (gdbarch, 8);
1078 set_gdbarch_pc_regnum (gdbarch, 9);
1079 set_gdbarch_fp_regnum (gdbarch, 31);
1080 set_gdbarch_virtual_frame_pointer (gdbarch, mn10300_virtual_frame_pointer);
1083 set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
1084 set_gdbarch_function_start_offset (gdbarch, 0);
1085 set_gdbarch_decr_pc_after_break (gdbarch, 0);
1087 /* Stack unwinding. */
1088 set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
1089 set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
1090 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1091 set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
1092 set_gdbarch_saved_pc_after_call (gdbarch, mn10300_saved_pc_after_call);
1093 set_gdbarch_init_extra_frame_info (gdbarch, mn10300_init_extra_frame_info);
1094 set_gdbarch_init_frame_pc (gdbarch, init_frame_pc_noop);
1095 set_gdbarch_frame_init_saved_regs (gdbarch, mn10300_frame_init_saved_regs);
1096 set_gdbarch_frame_chain (gdbarch, mn10300_frame_chain);
1097 set_gdbarch_frame_saved_pc (gdbarch, mn10300_frame_saved_pc);
1098 set_gdbarch_extract_return_value (gdbarch, mn10300_extract_return_value);
1099 set_gdbarch_extract_struct_value_address
1100 (gdbarch, mn10300_extract_struct_value_address);
1101 set_gdbarch_store_return_value (gdbarch, mn10300_store_return_value);
1102 set_gdbarch_store_struct_return (gdbarch, mn10300_store_struct_return);
1103 set_gdbarch_pop_frame (gdbarch, mn10300_pop_frame);
1104 set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
1105 set_gdbarch_frame_args_skip (gdbarch, 0);
1106 set_gdbarch_frame_args_address (gdbarch, default_frame_address);
1107 set_gdbarch_frame_locals_address (gdbarch, default_frame_address);
1108 set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1109 /* That's right, we're using the stack pointer as our frame pointer. */
1110 set_gdbarch_read_fp (gdbarch, generic_target_read_sp);
1112 /* Calling functions in the inferior from GDB. */
1113 set_gdbarch_call_dummy_p (gdbarch, 1);
1114 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
1115 set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
1116 set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
1117 set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1118 set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
1119 set_gdbarch_call_dummy_words (gdbarch, mn10300_call_dummy_words);
1120 set_gdbarch_sizeof_call_dummy_words (gdbarch,
1121 sizeof (mn10300_call_dummy_words));
1122 set_gdbarch_call_dummy_length (gdbarch, 0);
1123 set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
1124 set_gdbarch_call_dummy_start_offset (gdbarch, 0);
1125 set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point);
1126 set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
1127 set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
1128 set_gdbarch_push_arguments (gdbarch, mn10300_push_arguments);
1129 set_gdbarch_reg_struct_has_addr (gdbarch, mn10300_reg_struct_has_addr);
1130 set_gdbarch_push_return_address (gdbarch, mn10300_push_return_address);
1131 set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
1132 set_gdbarch_use_struct_convention (gdbarch, mn10300_use_struct_convention);
1134 tdep->am33_mode = am33_mode;
1140 _initialize_mn10300_tdep (void)
1142 /* printf("_initialize_mn10300_tdep\n"); */
1144 tm_print_insn = print_insn_mn10300;
1146 register_gdbarch_init (bfd_arch_mn10300, mn10300_gdbarch_init);