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. */
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 & 0x10)
202 fi->saved_regs[A3_REGNUM] = fi->frame + offset;
205 if (movm_args & 0x20)
207 fi->saved_regs[A2_REGNUM] = fi->frame + offset;
210 if (movm_args & 0x40)
212 fi->saved_regs[D3_REGNUM] = fi->frame + offset;
215 if (movm_args & 0x80)
217 fi->saved_regs[D2_REGNUM] = fi->frame + offset;
220 if (AM33_MODE && movm_args & 0x02)
222 fi->saved_regs[E0_REGNUM + 5] = fi->frame + offset;
223 fi->saved_regs[E0_REGNUM + 4] = fi->frame + offset + 4;
224 fi->saved_regs[E0_REGNUM + 3] = fi->frame + offset + 8;
225 fi->saved_regs[E0_REGNUM + 2] = fi->frame + offset + 12;
230 /* The main purpose of this file is dealing with prologues to extract
231 information about stack frames and saved registers.
233 For reference here's how prologues look on the mn10300:
236 movm [d2,d3,a2,a3],sp
240 Without frame pointer:
241 movm [d2,d3,a2,a3],sp (if needed)
244 One day we might keep the stack pointer constant, that won't
245 change the code for prologues, but it will make the frame
246 pointerless case much more common. */
248 /* Analyze the prologue to determine where registers are saved,
249 the end of the prologue, etc etc. Return the end of the prologue
252 We store into FI (if non-null) several tidbits of information:
254 * stack_size -- size of this stack frame. Note that if we stop in
255 certain parts of the prologue/epilogue we may claim the size of the
256 current frame is zero. This happens when the current frame has
257 not been allocated yet or has already been deallocated.
259 * fsr -- Addresses of registers saved in the stack by this frame.
261 * status -- A (relatively) generic status indicator. It's a bitmask
262 with the following bits:
264 MY_FRAME_IN_SP: The base of the current frame is actually in
265 the stack pointer. This can happen for frame pointerless
266 functions, or cases where we're stopped in the prologue/epilogue
267 itself. For these cases mn10300_analyze_prologue will need up
268 update fi->frame before returning or analyzing the register
271 MY_FRAME_IN_FP: The base of the current frame is in the
272 frame pointer register ($a2).
274 NO_MORE_FRAMES: Set this if the current frame is "start" or
275 if the first instruction looks like mov <imm>,sp. This tells
276 frame chain to not bother trying to unwind past this frame. */
279 mn10300_analyze_prologue (struct frame_info *fi, CORE_ADDR pc)
281 CORE_ADDR func_addr, func_end, addr, stop;
282 CORE_ADDR stack_size;
284 unsigned char buf[4];
285 int status, movm_args = 0;
288 /* Use the PC in the frame if it's provided to look up the
289 start of this function. */
290 pc = (fi ? fi->pc : pc);
292 /* Find the start of this function. */
293 status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
295 /* Do nothing if we couldn't find the start of this function or if we're
296 stopped at the first instruction in the prologue. */
302 /* If we're in start, then give up. */
303 if (strcmp (name, "start") == 0)
306 fi->extra_info->status = NO_MORE_FRAMES;
310 /* At the start of a function our frame is in the stack pointer. */
312 fi->extra_info->status = MY_FRAME_IN_SP;
314 /* Get the next two bytes into buf, we need two because rets is a two
315 byte insn and the first isn't enough to uniquely identify it. */
316 status = read_memory_nobpt (pc, buf, 2);
320 /* If we're physically on an "rets" instruction, then our frame has
321 already been deallocated. Note this can also be true for retf
322 and ret if they specify a size of zero.
324 In this case fi->frame is bogus, we need to fix it. */
325 if (fi && buf[0] == 0xf0 && buf[1] == 0xfc)
327 if (fi->next == NULL)
328 fi->frame = read_sp ();
332 /* Similarly if we're stopped on the first insn of a prologue as our
333 frame hasn't been allocated yet. */
334 if (fi && fi->pc == func_addr)
336 if (fi->next == NULL)
337 fi->frame = read_sp ();
341 /* Figure out where to stop scanning. */
342 stop = fi ? fi->pc : func_end;
344 /* Don't walk off the end of the function. */
345 stop = stop > func_end ? func_end : stop;
347 /* Start scanning on the first instruction of this function. */
350 /* Suck in two bytes. */
351 status = read_memory_nobpt (addr, buf, 2);
354 fix_frame_pointer (fi, 0);
358 /* First see if this insn sets the stack pointer; if so, it's something
359 we won't understand, so quit now. */
360 if (buf[0] == 0xf2 && (buf[1] & 0xf3) == 0xf0)
363 fi->extra_info->status = NO_MORE_FRAMES;
367 /* Now look for movm [regs],sp, which saves the callee saved registers.
369 At this time we don't know if fi->frame is valid, so we only note
370 that we encountered a movm instruction. Later, we'll set the entries
371 in fsr.regs as needed. */
374 /* Extract the register list for the movm instruction. */
375 status = read_memory_nobpt (addr + 1, buf, 1);
380 /* Quit now if we're beyond the stop point. */
383 /* Fix fi->frame since it's bogus at this point. */
384 if (fi && fi->next == NULL)
385 fi->frame = read_sp ();
387 /* Note if/where callee saved registers were saved. */
388 set_movm_offsets (fi, movm_args);
392 /* Get the next two bytes so the prologue scan can continue. */
393 status = read_memory_nobpt (addr, buf, 2);
396 /* Fix fi->frame since it's bogus at this point. */
397 if (fi && fi->next == NULL)
398 fi->frame = read_sp ();
400 /* Note if/where callee saved registers were saved. */
401 set_movm_offsets (fi, movm_args);
406 /* Now see if we set up a frame pointer via "mov sp,a3" */
411 /* The frame pointer is now valid. */
414 fi->extra_info->status |= MY_FRAME_IN_FP;
415 fi->extra_info->status &= ~MY_FRAME_IN_SP;
418 /* Quit now if we're beyond the stop point. */
421 /* Fix fi->frame if it's bogus at this point. */
422 fix_frame_pointer (fi, 0);
424 /* Note if/where callee saved registers were saved. */
425 set_movm_offsets (fi, movm_args);
429 /* Get two more bytes so scanning can continue. */
430 status = read_memory_nobpt (addr, buf, 2);
433 /* Fix fi->frame if it's bogus at this point. */
434 fix_frame_pointer (fi, 0);
436 /* Note if/where callee saved registers were saved. */
437 set_movm_offsets (fi, movm_args);
442 /* Next we should allocate the local frame. No more prologue insns
443 are found after allocating the local frame.
445 Search for add imm8,sp (0xf8feXX)
446 or add imm16,sp (0xfafeXXXX)
447 or add imm32,sp (0xfcfeXXXXXXXX).
449 If none of the above was found, then this prologue has no
452 status = read_memory_nobpt (addr, buf, 2);
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);
464 if (buf[0] == 0xf8 && buf[1] == 0xfe)
466 else if (buf[0] == 0xfa && buf[1] == 0xfe)
468 else if (buf[0] == 0xfc && buf[1] == 0xfe)
473 /* Suck in imm_size more bytes, they'll hold the size of the
475 status = read_memory_nobpt (addr + 2, buf, imm_size);
478 /* Fix fi->frame if it's bogus at this point. */
479 fix_frame_pointer (fi, 0);
481 /* Note if/where callee saved registers were saved. */
482 set_movm_offsets (fi, movm_args);
486 /* Note the size of the stack in the frame info structure. */
487 stack_size = extract_signed_integer (buf, imm_size);
489 fi->extra_info->stack_size = stack_size;
491 /* We just consumed 2 + imm_size bytes. */
492 addr += 2 + imm_size;
494 /* No more prologue insns follow, so begin preparation to return. */
495 /* Fix fi->frame if it's bogus at this point. */
496 fix_frame_pointer (fi, stack_size);
498 /* Note if/where callee saved registers were saved. */
499 set_movm_offsets (fi, movm_args);
503 /* We never found an insn which allocates local stack space, regardless
504 this is the end of the prologue. */
505 /* Fix fi->frame if it's bogus at this point. */
506 fix_frame_pointer (fi, 0);
508 /* Note if/where callee saved registers were saved. */
509 set_movm_offsets (fi, movm_args);
513 /* Function: frame_chain
514 Figure out and return the caller's frame pointer given current
517 We don't handle dummy frames yet but we would probably just return the
518 stack pointer that was in use at the time the function call was made? */
521 mn10300_frame_chain (struct frame_info *fi)
523 struct frame_info *dummy;
524 /* Walk through the prologue to determine the stack size,
525 location of saved registers, end of the prologue, etc. */
526 if (fi->extra_info->status == 0)
527 mn10300_analyze_prologue (fi, (CORE_ADDR) 0);
529 /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
530 if (fi->extra_info->status & NO_MORE_FRAMES)
533 /* Now that we've analyzed our prologue, determine the frame
534 pointer for our caller.
536 If our caller has a frame pointer, then we need to
537 find the entry value of $a3 to our function.
539 If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
540 location pointed to by fsr.regs[A3_REGNUM].
542 Else it's still in $a3.
544 If our caller does not have a frame pointer, then his
545 frame base is fi->frame + -caller's stack size. */
547 /* The easiest way to get that info is to analyze our caller's frame.
548 So we set up a dummy frame and call mn10300_analyze_prologue to
549 find stuff for us. */
550 dummy = analyze_dummy_frame (FRAME_SAVED_PC (fi), fi->frame);
552 if (dummy->extra_info->status & MY_FRAME_IN_FP)
554 /* Our caller has a frame pointer. So find the frame in $a3 or
556 if (fi->saved_regs[A3_REGNUM])
557 return (read_memory_integer (fi->saved_regs[A3_REGNUM], REGISTER_SIZE));
559 return read_register (A3_REGNUM);
565 adjust += (fi->saved_regs[D2_REGNUM] ? 4 : 0);
566 adjust += (fi->saved_regs[D3_REGNUM] ? 4 : 0);
567 adjust += (fi->saved_regs[A2_REGNUM] ? 4 : 0);
568 adjust += (fi->saved_regs[A3_REGNUM] ? 4 : 0);
571 adjust += (fi->saved_regs[E0_REGNUM + 5] ? 4 : 0);
572 adjust += (fi->saved_regs[E0_REGNUM + 4] ? 4 : 0);
573 adjust += (fi->saved_regs[E0_REGNUM + 3] ? 4 : 0);
574 adjust += (fi->saved_regs[E0_REGNUM + 2] ? 4 : 0);
577 /* Our caller does not have a frame pointer. So his frame starts
578 at the base of our frame (fi->frame) + register save space
580 return fi->frame + adjust + -dummy->extra_info->stack_size;
584 /* Function: skip_prologue
585 Return the address of the first inst past the prologue of the function. */
588 mn10300_skip_prologue (CORE_ADDR pc)
590 /* We used to check the debug symbols, but that can lose if
591 we have a null prologue. */
592 return mn10300_analyze_prologue (NULL, pc);
596 /* Function: pop_frame
597 This routine gets called when either the user uses the `return'
598 command, or the call dummy breakpoint gets hit. */
601 mn10300_pop_frame (struct frame_info *frame)
605 if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
606 generic_pop_dummy_frame ();
609 write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
611 /* Restore any saved registers. */
612 for (regnum = 0; regnum < NUM_REGS; regnum++)
613 if (frame->saved_regs[regnum] != 0)
617 value = read_memory_unsigned_integer (frame->saved_regs[regnum],
618 REGISTER_RAW_SIZE (regnum));
619 write_register (regnum, value);
622 /* Actually cut back the stack. */
623 write_register (SP_REGNUM, FRAME_FP (frame));
625 /* Don't we need to set the PC?!? XXX FIXME. */
628 /* Throw away any cached frame information. */
629 flush_cached_frames ();
632 /* Function: push_arguments
633 Setup arguments for a call to the target. Arguments go in
634 order on the stack. */
637 mn10300_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
638 int struct_return, CORE_ADDR struct_addr)
642 int stack_offset = 0;
643 int regsused = struct_return ? 1 : 0;
645 /* This should be a nop, but align the stack just in case something
646 went wrong. Stacks are four byte aligned on the mn10300. */
649 /* Now make space on the stack for the args.
651 XXX This doesn't appear to handle pass-by-invisible reference
653 for (argnum = 0; argnum < nargs; argnum++)
655 int arg_length = (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3;
657 while (regsused < 2 && arg_length > 0)
665 /* Allocate stack space. */
668 regsused = struct_return ? 1 : 0;
669 /* Push all arguments onto the stack. */
670 for (argnum = 0; argnum < nargs; argnum++)
675 /* XXX Check this. What about UNIONS? */
676 if (TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_STRUCT
677 && TYPE_LENGTH (VALUE_TYPE (*args)) > 8)
679 /* XXX Wrong, we want a pointer to this argument. */
680 len = TYPE_LENGTH (VALUE_TYPE (*args));
681 val = (char *) VALUE_CONTENTS (*args);
685 len = TYPE_LENGTH (VALUE_TYPE (*args));
686 val = (char *) VALUE_CONTENTS (*args);
689 while (regsused < 2 && len > 0)
691 write_register (regsused, extract_unsigned_integer (val, 4));
699 write_memory (sp + stack_offset, val, 4);
708 /* Make space for the flushback area. */
713 /* Function: push_return_address (pc)
714 Set up the return address for the inferior function call.
715 Needed for targets where we don't actually execute a JSR/BSR instruction */
718 mn10300_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
720 unsigned char buf[4];
722 store_unsigned_integer (buf, 4, CALL_DUMMY_ADDRESS ());
723 write_memory (sp - 4, buf, 4);
727 /* Function: store_struct_return (addr,sp)
728 Store the structure value return address for an inferior function
732 mn10300_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
734 /* The structure return address is passed as the first argument. */
735 write_register (0, addr);
738 /* Function: frame_saved_pc
739 Find the caller of this frame. We do this by seeing if RP_REGNUM
740 is saved in the stack anywhere, otherwise we get it from the
741 registers. If the inner frame is a dummy frame, return its PC
742 instead of RP, because that's where "caller" of the dummy-frame
746 mn10300_frame_saved_pc (struct frame_info *fi)
750 adjust += (fi->saved_regs[D2_REGNUM] ? 4 : 0);
751 adjust += (fi->saved_regs[D3_REGNUM] ? 4 : 0);
752 adjust += (fi->saved_regs[A2_REGNUM] ? 4 : 0);
753 adjust += (fi->saved_regs[A3_REGNUM] ? 4 : 0);
756 adjust += (fi->saved_regs[E0_REGNUM + 5] ? 4 : 0);
757 adjust += (fi->saved_regs[E0_REGNUM + 4] ? 4 : 0);
758 adjust += (fi->saved_regs[E0_REGNUM + 3] ? 4 : 0);
759 adjust += (fi->saved_regs[E0_REGNUM + 2] ? 4 : 0);
762 return (read_memory_integer (fi->frame + adjust, REGISTER_SIZE));
765 /* Function: mn10300_init_extra_frame_info
766 Setup the frame's frame pointer, pc, and frame addresses for saved
767 registers. Most of the work is done in mn10300_analyze_prologue().
769 Note that when we are called for the last frame (currently active frame),
770 that fi->pc and fi->frame will already be setup. However, fi->frame will
771 be valid only if this routine uses FP. For previous frames, fi-frame will
772 always be correct. mn10300_analyze_prologue will fix fi->frame if
775 We can be called with the PC in the call dummy under two circumstances.
776 First, during normal backtracing, second, while figuring out the frame
777 pointer just prior to calling the target function (see run_stack_dummy). */
780 mn10300_init_extra_frame_info (int fromleaf, struct frame_info *fi)
783 fi->pc = FRAME_SAVED_PC (fi->next);
785 frame_saved_regs_zalloc (fi);
786 fi->extra_info = (struct frame_extra_info *)
787 frame_obstack_alloc (sizeof (struct frame_extra_info));
789 fi->extra_info->status = 0;
790 fi->extra_info->stack_size = 0;
792 mn10300_analyze_prologue (fi, 0);
796 /* This function's job is handled by init_extra_frame_info. */
798 mn10300_frame_init_saved_regs (struct frame_info *frame)
803 /* Function: mn10300_virtual_frame_pointer
804 Return the register that the function uses for a frame pointer,
805 plus any necessary offset to be applied to the register before
806 any frame pointer offsets. */
809 mn10300_virtual_frame_pointer (CORE_ADDR pc, long *reg, long *offset)
811 struct frame_info *dummy = analyze_dummy_frame (pc, 0);
812 /* Set up a dummy frame_info, Analyze the prolog and fill in the
814 /* Results will tell us which type of frame it uses. */
815 if (dummy->extra_info->status & MY_FRAME_IN_SP)
818 *offset = -(dummy->extra_info->stack_size);
828 mn10300_reg_struct_has_addr (int gcc_p, struct type *type)
830 return (TYPE_LENGTH (type) > 8);
834 mn10300_register_virtual_type (int reg)
836 return builtin_type_int;
840 mn10300_register_byte (int reg)
846 mn10300_register_virtual_size (int reg)
852 mn10300_register_raw_size (int reg)
858 mn10300_print_register (const char *name, int regnum, int reg_width)
860 char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
863 printf_filtered ("%*s: ", reg_width, name);
865 printf_filtered ("%s: ", name);
868 if (read_relative_register_raw_bytes (regnum, raw_buffer))
870 printf_filtered ("[invalid]");
876 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
878 for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
879 byte < REGISTER_RAW_SIZE (regnum);
881 printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
885 for (byte = REGISTER_VIRTUAL_SIZE (regnum) - 1;
888 printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
894 mn10300_do_registers_info (int regnum, int fpregs)
898 const char *name = REGISTER_NAME (regnum);
899 if (name == NULL || name[0] == '\0')
900 error ("Not a valid register for the current processor type");
901 mn10300_print_register (name, regnum, 0);
902 printf_filtered ("\n");
906 /* print registers in an array 4x8 */
909 const int nr_in_row = 4;
910 const int reg_width = 4;
911 for (r = 0; r < NUM_REGS; r += nr_in_row)
916 for (c = r; c < r + nr_in_row; c++)
918 const char *name = REGISTER_NAME (c);
919 if (name != NULL && *name != '\0')
924 printf_filtered (" ");
927 mn10300_print_register (name, c, reg_width);
928 printf_filtered (" ");
932 padding += (reg_width + 2 + 8 + 1);
936 printf_filtered ("\n");
941 /* Dump out the mn10300 speciic architecture information. */
944 mn10300_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
946 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
947 fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
951 static struct gdbarch *
952 mn10300_gdbarch_init (struct gdbarch_info info,
953 struct gdbarch_list *arches)
955 static LONGEST mn10300_call_dummy_words[] = { 0 };
956 struct gdbarch *gdbarch;
957 struct gdbarch_tdep *tdep = NULL;
959 gdbarch_register_name_ftype *register_name;
963 arches = gdbarch_list_lookup_by_info (arches, &info);
965 return arches->gdbarch;
966 tdep = xmalloc (sizeof (struct gdbarch_tdep));
967 gdbarch = gdbarch_alloc (&info, tdep);
969 if (info.bfd_arch_info != NULL
970 && info.bfd_arch_info->arch == bfd_arch_mn10300)
971 mach = info.bfd_arch_info->mach;
977 case bfd_mach_mn10300:
979 register_name = mn10300_generic_register_name;
984 register_name = am33_register_name;
988 internal_error (__FILE__, __LINE__,
989 "mn10300_gdbarch_init: Unknown mn10300 variant");
990 return NULL; /* keep GCC happy. */
993 set_gdbarch_register_size (gdbarch, 4);
994 set_gdbarch_max_register_raw_size (gdbarch, 4);
995 set_gdbarch_register_virtual_type (gdbarch, mn10300_register_virtual_type);
996 set_gdbarch_register_byte (gdbarch, mn10300_register_byte);
997 set_gdbarch_register_virtual_size (gdbarch, mn10300_register_virtual_size);
998 set_gdbarch_register_raw_size (gdbarch, mn10300_register_raw_size);
999 set_gdbarch_call_dummy_p (gdbarch, 1);
1000 set_gdbarch_register_name (gdbarch, register_name);
1001 set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
1002 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 0);
1003 set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
1004 set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
1005 set_gdbarch_push_arguments (gdbarch, mn10300_push_arguments);
1006 set_gdbarch_push_return_address (gdbarch, mn10300_push_return_address);
1007 set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
1008 set_gdbarch_reg_struct_has_addr (gdbarch, mn10300_reg_struct_has_addr);
1009 set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
1010 set_gdbarch_num_regs (gdbarch, num_regs);
1011 set_gdbarch_do_registers_info (gdbarch, mn10300_do_registers_info);
1013 set_gdbarch_fp_regnum (gdbarch, 31);
1014 set_gdbarch_max_register_virtual_size (gdbarch, 4);
1015 set_gdbarch_register_bytes (gdbarch,
1016 num_regs * gdbarch_register_size (gdbarch));
1017 set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
1018 set_gdbarch_function_start_offset (gdbarch, 0);
1019 set_gdbarch_decr_pc_after_break (gdbarch, 0);
1020 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1021 set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
1022 set_gdbarch_saved_pc_after_call (gdbarch, mn10300_saved_pc_after_call);
1023 set_gdbarch_init_extra_frame_info (gdbarch, mn10300_init_extra_frame_info);
1024 set_gdbarch_frame_init_saved_regs (gdbarch, mn10300_frame_init_saved_regs);
1025 set_gdbarch_frame_chain (gdbarch, mn10300_frame_chain);
1026 set_gdbarch_frame_saved_pc (gdbarch, mn10300_frame_saved_pc);
1027 set_gdbarch_extract_return_value (gdbarch, mn10300_extract_return_value);
1028 set_gdbarch_extract_struct_value_address
1029 (gdbarch, mn10300_extract_struct_value_address);
1030 set_gdbarch_store_return_value (gdbarch, mn10300_store_return_value);
1031 set_gdbarch_store_struct_return (gdbarch, mn10300_store_struct_return);
1032 set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
1033 set_gdbarch_frame_args_skip (gdbarch, 0);
1034 set_gdbarch_frame_args_address (gdbarch, default_frame_address);
1035 set_gdbarch_frame_locals_address (gdbarch, default_frame_address);
1036 set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1037 /* That's right, we're using the stack pointer as our frame pointer. */
1038 set_gdbarch_read_fp (gdbarch, generic_target_read_sp);
1039 set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1040 set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
1041 set_gdbarch_call_dummy_words (gdbarch, mn10300_call_dummy_words);
1042 set_gdbarch_sizeof_call_dummy_words (gdbarch,
1043 sizeof (mn10300_call_dummy_words));
1044 set_gdbarch_call_dummy_length (gdbarch, 0);
1045 set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
1046 set_gdbarch_call_dummy_start_offset (gdbarch, 0);
1047 set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
1048 set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
1049 set_gdbarch_use_struct_convention (gdbarch, mn10300_use_struct_convention);
1051 tdep->am33_mode = am33_mode;
1057 _initialize_mn10300_tdep (void)
1059 /* printf("_initialize_mn10300_tdep\n"); */
1061 tm_print_insn = print_insn_mn10300;
1063 register_gdbarch_init (bfd_arch_mn10300, mn10300_gdbarch_init);