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"
34 extern void _initialize_mn10300_tdep (void);
35 static CORE_ADDR
mn10300_analyze_prologue (struct frame_info
*fi
,
38 /* mn10300 private data */
42 #define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode)
45 /* Additional info used by the frame */
47 struct frame_extra_info
55 register_name (int reg
, char **regs
, long sizeof_regs
)
57 if (reg
< 0 || reg
>= sizeof_regs
/ sizeof (regs
[0]))
64 mn10300_generic_register_name (int reg
)
67 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
68 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
69 "", "", "", "", "", "", "", "",
70 "", "", "", "", "", "", "", "fp"
72 return register_name (reg
, regs
, sizeof regs
);
77 am33_register_name (int reg
)
80 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
81 "sp", "pc", "mdr", "psw", "lir", "lar", "",
82 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
83 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
85 return register_name (reg
, regs
, sizeof regs
);
89 mn10300_saved_pc_after_call (struct frame_info
*fi
)
91 return read_memory_integer (read_register (SP_REGNUM
), 4);
95 mn10300_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
97 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
98 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (4), TYPE_LENGTH (type
));
100 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), TYPE_LENGTH (type
));
104 mn10300_extract_struct_value_address (char *regbuf
)
106 return extract_address (regbuf
+ REGISTER_BYTE (4),
107 REGISTER_RAW_SIZE (4));
111 mn10300_store_return_value (struct type
*type
, char *valbuf
)
113 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
114 write_register_bytes (REGISTER_BYTE (4), valbuf
, TYPE_LENGTH (type
));
116 write_register_bytes (REGISTER_BYTE (0), valbuf
, TYPE_LENGTH (type
));
119 static struct frame_info
*analyze_dummy_frame (CORE_ADDR
, CORE_ADDR
);
120 static struct frame_info
*
121 analyze_dummy_frame (CORE_ADDR pc
, CORE_ADDR frame
)
123 static struct frame_info
*dummy
= NULL
;
126 dummy
= xmalloc (sizeof (struct frame_info
));
127 dummy
->saved_regs
= xmalloc (SIZEOF_FRAME_SAVED_REGS
);
128 dummy
->extra_info
= xmalloc (sizeof (struct frame_extra_info
));
133 dummy
->frame
= frame
;
134 dummy
->extra_info
->status
= 0;
135 dummy
->extra_info
->stack_size
= 0;
136 memset (dummy
->saved_regs
, '\000', SIZEOF_FRAME_SAVED_REGS
);
137 mn10300_analyze_prologue (dummy
, 0);
141 /* Values for frame_info.status */
143 #define MY_FRAME_IN_SP 0x1
144 #define MY_FRAME_IN_FP 0x2
145 #define NO_MORE_FRAMES 0x4
148 /* Should call_function allocate stack space for a struct return? */
150 mn10300_use_struct_convention (int gcc_p
, struct type
*type
)
152 return (TYPE_NFIELDS (type
) > 1 || TYPE_LENGTH (type
) > 8);
155 /* The breakpoint instruction must be the same size as the smallest
156 instruction in the instruction set.
158 The Matsushita mn10x00 processors have single byte instructions
159 so we need a single byte breakpoint. Matsushita hasn't defined
160 one, so we defined it ourselves. */
163 mn10300_breakpoint_from_pc (CORE_ADDR
*bp_addr
, int *bp_size
)
165 static char breakpoint
[] =
172 /* Fix fi->frame if it's bogus at this point. This is a helper
173 function for mn10300_analyze_prologue. */
176 fix_frame_pointer (struct frame_info
*fi
, int stack_size
)
178 if (fi
&& fi
->next
== NULL
)
180 if (fi
->extra_info
->status
& MY_FRAME_IN_SP
)
181 fi
->frame
= read_sp () - stack_size
;
182 else if (fi
->extra_info
->status
& MY_FRAME_IN_FP
)
183 fi
->frame
= read_register (A3_REGNUM
);
188 /* Set offsets of registers saved by movm instruction.
189 This is a helper function for mn10300_analyze_prologue. */
192 set_movm_offsets (struct frame_info
*fi
, int movm_args
)
196 if (fi
== NULL
|| movm_args
== 0)
199 if (movm_args
& 0x10)
201 fi
->saved_regs
[A3_REGNUM
] = fi
->frame
+ offset
;
204 if (movm_args
& 0x20)
206 fi
->saved_regs
[A2_REGNUM
] = fi
->frame
+ offset
;
209 if (movm_args
& 0x40)
211 fi
->saved_regs
[D3_REGNUM
] = fi
->frame
+ offset
;
214 if (movm_args
& 0x80)
216 fi
->saved_regs
[D2_REGNUM
] = fi
->frame
+ offset
;
219 if (AM33_MODE
&& movm_args
& 0x02)
221 fi
->saved_regs
[E0_REGNUM
+ 5] = fi
->frame
+ offset
;
222 fi
->saved_regs
[E0_REGNUM
+ 4] = fi
->frame
+ offset
+ 4;
223 fi
->saved_regs
[E0_REGNUM
+ 3] = fi
->frame
+ offset
+ 8;
224 fi
->saved_regs
[E0_REGNUM
+ 2] = fi
->frame
+ offset
+ 12;
229 /* The main purpose of this file is dealing with prologues to extract
230 information about stack frames and saved registers.
232 For reference here's how prologues look on the mn10300:
235 movm [d2,d3,a2,a3],sp
239 Without frame pointer:
240 movm [d2,d3,a2,a3],sp (if needed)
243 One day we might keep the stack pointer constant, that won't
244 change the code for prologues, but it will make the frame
245 pointerless case much more common. */
247 /* Analyze the prologue to determine where registers are saved,
248 the end of the prologue, etc etc. Return the end of the prologue
251 We store into FI (if non-null) several tidbits of information:
253 * stack_size -- size of this stack frame. Note that if we stop in
254 certain parts of the prologue/epilogue we may claim the size of the
255 current frame is zero. This happens when the current frame has
256 not been allocated yet or has already been deallocated.
258 * fsr -- Addresses of registers saved in the stack by this frame.
260 * status -- A (relatively) generic status indicator. It's a bitmask
261 with the following bits:
263 MY_FRAME_IN_SP: The base of the current frame is actually in
264 the stack pointer. This can happen for frame pointerless
265 functions, or cases where we're stopped in the prologue/epilogue
266 itself. For these cases mn10300_analyze_prologue will need up
267 update fi->frame before returning or analyzing the register
270 MY_FRAME_IN_FP: The base of the current frame is in the
271 frame pointer register ($a2).
273 NO_MORE_FRAMES: Set this if the current frame is "start" or
274 if the first instruction looks like mov <imm>,sp. This tells
275 frame chain to not bother trying to unwind past this frame. */
278 mn10300_analyze_prologue (struct frame_info
*fi
, CORE_ADDR pc
)
280 CORE_ADDR func_addr
, func_end
, addr
, stop
;
281 CORE_ADDR stack_size
;
283 unsigned char buf
[4];
284 int status
, movm_args
= 0;
287 /* Use the PC in the frame if it's provided to look up the
288 start of this function. */
289 pc
= (fi
? fi
->pc
: pc
);
291 /* Find the start of this function. */
292 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
294 /* Do nothing if we couldn't find the start of this function or if we're
295 stopped at the first instruction in the prologue. */
301 /* If we're in start, then give up. */
302 if (strcmp (name
, "start") == 0)
305 fi
->extra_info
->status
= NO_MORE_FRAMES
;
309 /* At the start of a function our frame is in the stack pointer. */
311 fi
->extra_info
->status
= MY_FRAME_IN_SP
;
313 /* Get the next two bytes into buf, we need two because rets is a two
314 byte insn and the first isn't enough to uniquely identify it. */
315 status
= read_memory_nobpt (pc
, buf
, 2);
319 /* If we're physically on an "rets" instruction, then our frame has
320 already been deallocated. Note this can also be true for retf
321 and ret if they specify a size of zero.
323 In this case fi->frame is bogus, we need to fix it. */
324 if (fi
&& buf
[0] == 0xf0 && buf
[1] == 0xfc)
326 if (fi
->next
== NULL
)
327 fi
->frame
= read_sp ();
331 /* Similarly if we're stopped on the first insn of a prologue as our
332 frame hasn't been allocated yet. */
333 if (fi
&& fi
->pc
== func_addr
)
335 if (fi
->next
== NULL
)
336 fi
->frame
= read_sp ();
340 /* Figure out where to stop scanning. */
341 stop
= fi
? fi
->pc
: func_end
;
343 /* Don't walk off the end of the function. */
344 stop
= stop
> func_end
? func_end
: stop
;
346 /* Start scanning on the first instruction of this function. */
349 /* Suck in two bytes. */
350 status
= read_memory_nobpt (addr
, buf
, 2);
353 fix_frame_pointer (fi
, 0);
357 /* First see if this insn sets the stack pointer; if so, it's something
358 we won't understand, so quit now. */
359 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
362 fi
->extra_info
->status
= NO_MORE_FRAMES
;
366 /* Now look for movm [regs],sp, which saves the callee saved registers.
368 At this time we don't know if fi->frame is valid, so we only note
369 that we encountered a movm instruction. Later, we'll set the entries
370 in fsr.regs as needed. */
373 /* Extract the register list for the movm instruction. */
374 status
= read_memory_nobpt (addr
+ 1, buf
, 1);
379 /* Quit now if we're beyond the stop point. */
382 /* Fix fi->frame since it's bogus at this point. */
383 if (fi
&& fi
->next
== NULL
)
384 fi
->frame
= read_sp ();
386 /* Note if/where callee saved registers were saved. */
387 set_movm_offsets (fi
, movm_args
);
391 /* Get the next two bytes so the prologue scan can continue. */
392 status
= read_memory_nobpt (addr
, buf
, 2);
395 /* Fix fi->frame since it's bogus at this point. */
396 if (fi
&& fi
->next
== NULL
)
397 fi
->frame
= read_sp ();
399 /* Note if/where callee saved registers were saved. */
400 set_movm_offsets (fi
, movm_args
);
405 /* Now see if we set up a frame pointer via "mov sp,a3" */
410 /* The frame pointer is now valid. */
413 fi
->extra_info
->status
|= MY_FRAME_IN_FP
;
414 fi
->extra_info
->status
&= ~MY_FRAME_IN_SP
;
417 /* Quit now if we're beyond the stop point. */
420 /* Fix fi->frame if it's bogus at this point. */
421 fix_frame_pointer (fi
, 0);
423 /* Note if/where callee saved registers were saved. */
424 set_movm_offsets (fi
, movm_args
);
428 /* Get two more bytes so scanning can continue. */
429 status
= read_memory_nobpt (addr
, buf
, 2);
432 /* Fix fi->frame if it's bogus at this point. */
433 fix_frame_pointer (fi
, 0);
435 /* Note if/where callee saved registers were saved. */
436 set_movm_offsets (fi
, movm_args
);
441 /* Next we should allocate the local frame. No more prologue insns
442 are found after allocating the local frame.
444 Search for add imm8,sp (0xf8feXX)
445 or add imm16,sp (0xfafeXXXX)
446 or add imm32,sp (0xfcfeXXXXXXXX).
448 If none of the above was found, then this prologue has no
451 status
= read_memory_nobpt (addr
, buf
, 2);
454 /* Fix fi->frame if it's bogus at this point. */
455 fix_frame_pointer (fi
, 0);
457 /* Note if/where callee saved registers were saved. */
458 set_movm_offsets (fi
, movm_args
);
463 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
465 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
467 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
472 /* Suck in imm_size more bytes, they'll hold the size of the
474 status
= read_memory_nobpt (addr
+ 2, buf
, imm_size
);
477 /* Fix fi->frame if it's bogus at this point. */
478 fix_frame_pointer (fi
, 0);
480 /* Note if/where callee saved registers were saved. */
481 set_movm_offsets (fi
, movm_args
);
485 /* Note the size of the stack in the frame info structure. */
486 stack_size
= extract_signed_integer (buf
, imm_size
);
488 fi
->extra_info
->stack_size
= stack_size
;
490 /* We just consumed 2 + imm_size bytes. */
491 addr
+= 2 + imm_size
;
493 /* No more prologue insns follow, so begin preparation to return. */
494 /* Fix fi->frame if it's bogus at this point. */
495 fix_frame_pointer (fi
, stack_size
);
497 /* Note if/where callee saved registers were saved. */
498 set_movm_offsets (fi
, movm_args
);
502 /* We never found an insn which allocates local stack space, regardless
503 this is the end of the prologue. */
504 /* Fix fi->frame if it's bogus at this point. */
505 fix_frame_pointer (fi
, 0);
507 /* Note if/where callee saved registers were saved. */
508 set_movm_offsets (fi
, movm_args
);
512 /* Function: frame_chain
513 Figure out and return the caller's frame pointer given current
516 We don't handle dummy frames yet but we would probably just return the
517 stack pointer that was in use at the time the function call was made? */
520 mn10300_frame_chain (struct frame_info
*fi
)
522 struct frame_info
*dummy
;
523 /* Walk through the prologue to determine the stack size,
524 location of saved registers, end of the prologue, etc. */
525 if (fi
->extra_info
->status
== 0)
526 mn10300_analyze_prologue (fi
, (CORE_ADDR
) 0);
528 /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
529 if (fi
->extra_info
->status
& NO_MORE_FRAMES
)
532 /* Now that we've analyzed our prologue, determine the frame
533 pointer for our caller.
535 If our caller has a frame pointer, then we need to
536 find the entry value of $a3 to our function.
538 If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
539 location pointed to by fsr.regs[A3_REGNUM].
541 Else it's still in $a3.
543 If our caller does not have a frame pointer, then his
544 frame base is fi->frame + -caller's stack size. */
546 /* The easiest way to get that info is to analyze our caller's frame.
547 So we set up a dummy frame and call mn10300_analyze_prologue to
548 find stuff for us. */
549 dummy
= analyze_dummy_frame (FRAME_SAVED_PC (fi
), fi
->frame
);
551 if (dummy
->extra_info
->status
& MY_FRAME_IN_FP
)
553 /* Our caller has a frame pointer. So find the frame in $a3 or
555 if (fi
->saved_regs
[A3_REGNUM
])
556 return (read_memory_integer (fi
->saved_regs
[A3_REGNUM
], REGISTER_SIZE
));
558 return read_register (A3_REGNUM
);
564 adjust
+= (fi
->saved_regs
[D2_REGNUM
] ? 4 : 0);
565 adjust
+= (fi
->saved_regs
[D3_REGNUM
] ? 4 : 0);
566 adjust
+= (fi
->saved_regs
[A2_REGNUM
] ? 4 : 0);
567 adjust
+= (fi
->saved_regs
[A3_REGNUM
] ? 4 : 0);
570 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 5] ? 4 : 0);
571 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 4] ? 4 : 0);
572 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 3] ? 4 : 0);
573 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 2] ? 4 : 0);
576 /* Our caller does not have a frame pointer. So his frame starts
577 at the base of our frame (fi->frame) + register save space
579 return fi
->frame
+ adjust
+ -dummy
->extra_info
->stack_size
;
583 /* Function: skip_prologue
584 Return the address of the first inst past the prologue of the function. */
587 mn10300_skip_prologue (CORE_ADDR pc
)
589 /* We used to check the debug symbols, but that can lose if
590 we have a null prologue. */
591 return mn10300_analyze_prologue (NULL
, pc
);
595 /* Function: pop_frame
596 This routine gets called when either the user uses the `return'
597 command, or the call dummy breakpoint gets hit. */
600 mn10300_pop_frame (struct frame_info
*frame
)
604 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
605 generic_pop_dummy_frame ();
608 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
610 /* Restore any saved registers. */
611 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
612 if (frame
->saved_regs
[regnum
] != 0)
616 value
= read_memory_unsigned_integer (frame
->saved_regs
[regnum
],
617 REGISTER_RAW_SIZE (regnum
));
618 write_register (regnum
, value
);
621 /* Actually cut back the stack. */
622 write_register (SP_REGNUM
, FRAME_FP (frame
));
624 /* Don't we need to set the PC?!? XXX FIXME. */
627 /* Throw away any cached frame information. */
628 flush_cached_frames ();
631 /* Function: push_arguments
632 Setup arguments for a call to the target. Arguments go in
633 order on the stack. */
636 mn10300_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
637 int struct_return
, CORE_ADDR struct_addr
)
641 int stack_offset
= 0;
642 int regsused
= struct_return
? 1 : 0;
644 /* This should be a nop, but align the stack just in case something
645 went wrong. Stacks are four byte aligned on the mn10300. */
648 /* Now make space on the stack for the args.
650 XXX This doesn't appear to handle pass-by-invisible reference
652 for (argnum
= 0; argnum
< nargs
; argnum
++)
654 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3;
656 while (regsused
< 2 && arg_length
> 0)
664 /* Allocate stack space. */
667 regsused
= struct_return
? 1 : 0;
668 /* Push all arguments onto the stack. */
669 for (argnum
= 0; argnum
< nargs
; argnum
++)
674 /* XXX Check this. What about UNIONS? */
675 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
676 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
678 /* XXX Wrong, we want a pointer to this argument. */
679 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
680 val
= (char *) VALUE_CONTENTS (*args
);
684 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
685 val
= (char *) VALUE_CONTENTS (*args
);
688 while (regsused
< 2 && len
> 0)
690 write_register (regsused
, extract_unsigned_integer (val
, 4));
698 write_memory (sp
+ stack_offset
, val
, 4);
707 /* Make space for the flushback area. */
712 /* Function: push_return_address (pc)
713 Set up the return address for the inferior function call.
714 Needed for targets where we don't actually execute a JSR/BSR instruction */
717 mn10300_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
719 unsigned char buf
[4];
721 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
722 write_memory (sp
- 4, buf
, 4);
726 /* Function: store_struct_return (addr,sp)
727 Store the structure value return address for an inferior function
731 mn10300_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
733 /* The structure return address is passed as the first argument. */
734 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 (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);
795 /* Function: mn10300_virtual_frame_pointer
796 Return the register that the function uses for a frame pointer,
797 plus any necessary offset to be applied to the register before
798 any frame pointer offsets. */
801 mn10300_virtual_frame_pointer (CORE_ADDR pc
, long *reg
, long *offset
)
803 struct frame_info
*dummy
= analyze_dummy_frame (pc
, 0);
804 /* Set up a dummy frame_info, Analyze the prolog and fill in the
806 /* Results will tell us which type of frame it uses. */
807 if (dummy
->extra_info
->status
& MY_FRAME_IN_SP
)
810 *offset
= -(dummy
->extra_info
->stack_size
);
820 mn10300_reg_struct_has_addr (int gcc_p
, struct type
*type
)
822 return (TYPE_LENGTH (type
) > 8);
826 mn10300_register_virtual_type (int reg
)
828 return builtin_type_int
;
832 mn10300_register_byte (int reg
)
838 mn10300_register_virtual_size (int reg
)
844 mn10300_register_raw_size (int reg
)
850 mn10300_print_register (const char *name
, int regnum
, int reg_width
)
852 char *raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
855 printf_filtered ("%*s: ", reg_width
, name
);
857 printf_filtered ("%s: ", name
);
860 if (read_relative_register_raw_bytes (regnum
, raw_buffer
))
862 printf_filtered ("[invalid]");
868 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
870 for (byte
= REGISTER_RAW_SIZE (regnum
) - REGISTER_VIRTUAL_SIZE (regnum
);
871 byte
< REGISTER_RAW_SIZE (regnum
);
873 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
877 for (byte
= REGISTER_VIRTUAL_SIZE (regnum
) - 1;
880 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
886 mn10300_do_registers_info (int regnum
, int fpregs
)
890 const char *name
= REGISTER_NAME (regnum
);
891 if (name
== NULL
|| name
[0] == '\0')
892 error ("Not a valid register for the current processor type");
893 mn10300_print_register (name
, regnum
, 0);
894 printf_filtered ("\n");
898 /* print registers in an array 4x8 */
901 const int nr_in_row
= 4;
902 const int reg_width
= 4;
903 for (r
= 0; r
< NUM_REGS
; r
+= nr_in_row
)
908 for (c
= r
; c
< r
+ nr_in_row
; c
++)
910 const char *name
= REGISTER_NAME (c
);
911 if (name
!= NULL
&& *name
!= '\0')
916 printf_filtered (" ");
919 mn10300_print_register (name
, c
, reg_width
);
920 printf_filtered (" ");
924 padding
+= (reg_width
+ 2 + 8 + 1);
928 printf_filtered ("\n");
933 /* Dump out the mn10300 speciic architecture information. */
936 mn10300_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
938 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
939 fprintf_unfiltered (file
, "mn10300_dump_tdep: am33_mode = %d\n",
943 static struct gdbarch
*
944 mn10300_gdbarch_init (struct gdbarch_info info
,
945 struct gdbarch_list
*arches
)
947 struct gdbarch
*gdbarch
;
948 struct gdbarch_tdep
*tdep
= NULL
;
950 gdbarch_register_name_ftype
*register_name
;
954 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
956 return arches
->gdbarch
;
957 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
958 gdbarch
= gdbarch_alloc (&info
, tdep
);
960 if (info
.bfd_arch_info
!= NULL
961 && info
.bfd_arch_info
->arch
== bfd_arch_mn10300
)
962 mach
= info
.bfd_arch_info
->mach
;
968 case bfd_mach_mn10300
:
970 register_name
= mn10300_generic_register_name
;
975 register_name
= am33_register_name
;
979 internal_error (__FILE__
, __LINE__
,
980 "mn10300_gdbarch_init: Unknown mn10300 variant");
981 return NULL
; /* keep GCC happy. */
984 set_gdbarch_register_size (gdbarch
, 4);
985 set_gdbarch_max_register_raw_size (gdbarch
, 4);
986 set_gdbarch_register_virtual_type (gdbarch
, mn10300_register_virtual_type
);
987 set_gdbarch_register_byte (gdbarch
, mn10300_register_byte
);
988 set_gdbarch_register_virtual_size (gdbarch
, mn10300_register_virtual_size
);
989 set_gdbarch_register_raw_size (gdbarch
, mn10300_register_raw_size
);
990 set_gdbarch_call_dummy_p (gdbarch
, 1);
991 set_gdbarch_register_name (gdbarch
, register_name
);
992 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
993 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 0);
994 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
995 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
996 set_gdbarch_push_arguments (gdbarch
, mn10300_push_arguments
);
997 set_gdbarch_push_return_address (gdbarch
, mn10300_push_return_address
);
998 set_gdbarch_frame_chain_valid (gdbarch
, generic_file_frame_chain_valid
);
999 set_gdbarch_reg_struct_has_addr (gdbarch
, mn10300_reg_struct_has_addr
);
1000 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1001 set_gdbarch_num_regs (gdbarch
, num_regs
);
1002 set_gdbarch_do_registers_info (gdbarch
, mn10300_do_registers_info
);
1004 tdep
->am33_mode
= am33_mode
;
1010 _initialize_mn10300_tdep (void)
1012 /* printf("_initialize_mn10300_tdep\n"); */
1014 tm_print_insn
= print_insn_mn10300
;
1016 register_gdbarch_init (bfd_arch_mn10300
, mn10300_gdbarch_init
);