1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
2 Copyright 1996, 1997, 1998, 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 extern void _initialize_mn10300_tdep (void);
34 static CORE_ADDR
mn10300_analyze_prologue (struct frame_info
*fi
,
37 /* mn10300 private data */
41 #define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode)
44 /* Additional info used by the frame */
46 struct frame_extra_info
54 register_name (int reg
, char **regs
, long sizeof_regs
)
56 if (reg
< 0 || reg
>= sizeof_regs
/ sizeof (regs
[0]))
63 mn10300_generic_register_name (int reg
)
66 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
67 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
68 "", "", "", "", "", "", "", "",
69 "", "", "", "", "", "", "", "fp"
71 return register_name (reg
, regs
, sizeof regs
);
76 am33_register_name (int reg
)
79 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
80 "sp", "pc", "mdr", "psw", "lir", "lar", "",
81 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
82 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
84 return register_name (reg
, regs
, sizeof regs
);
88 mn10300_saved_pc_after_call (struct frame_info
*fi
)
90 return read_memory_integer (read_register (SP_REGNUM
), 4);
94 mn10300_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
96 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
97 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (4), TYPE_LENGTH (type
));
99 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (0), TYPE_LENGTH (type
));
103 mn10300_extract_struct_value_address (char *regbuf
)
105 return extract_address (regbuf
+ REGISTER_BYTE (4),
106 REGISTER_RAW_SIZE (4));
110 mn10300_store_return_value (struct type
*type
, char *valbuf
)
112 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
113 write_register_bytes (REGISTER_BYTE (4), valbuf
, TYPE_LENGTH (type
));
115 write_register_bytes (REGISTER_BYTE (0), valbuf
, TYPE_LENGTH (type
));
118 static struct frame_info
*analyze_dummy_frame (CORE_ADDR
, CORE_ADDR
);
119 static struct frame_info
*
120 analyze_dummy_frame (CORE_ADDR pc
, CORE_ADDR frame
)
122 static struct frame_info
*dummy
= NULL
;
125 dummy
= xmalloc (sizeof (struct frame_info
));
126 dummy
->saved_regs
= xmalloc (SIZEOF_FRAME_SAVED_REGS
);
127 dummy
->extra_info
= xmalloc (sizeof (struct frame_extra_info
));
132 dummy
->frame
= frame
;
133 dummy
->extra_info
->status
= 0;
134 dummy
->extra_info
->stack_size
= 0;
135 memset (dummy
->saved_regs
, '\000', SIZEOF_FRAME_SAVED_REGS
);
136 mn10300_analyze_prologue (dummy
, 0);
140 /* Values for frame_info.status */
142 #define MY_FRAME_IN_SP 0x1
143 #define MY_FRAME_IN_FP 0x2
144 #define NO_MORE_FRAMES 0x4
147 /* Should call_function allocate stack space for a struct return? */
149 mn10300_use_struct_convention (int gcc_p
, struct type
*type
)
151 return (TYPE_NFIELDS (type
) > 1 || TYPE_LENGTH (type
) > 8);
154 /* The breakpoint instruction must be the same size as the smallest
155 instruction in the instruction set.
157 The Matsushita mn10x00 processors have single byte instructions
158 so we need a single byte breakpoint. Matsushita hasn't defined
159 one, so we defined it ourselves. */
162 mn10300_breakpoint_from_pc (CORE_ADDR
*bp_addr
, int *bp_size
)
164 static char breakpoint
[] =
171 /* Fix fi->frame if it's bogus at this point. This is a helper
172 function for mn10300_analyze_prologue. */
175 fix_frame_pointer (struct frame_info
*fi
, int stack_size
)
177 if (fi
&& fi
->next
== NULL
)
179 if (fi
->extra_info
->status
& MY_FRAME_IN_SP
)
180 fi
->frame
= read_sp () - stack_size
;
181 else if (fi
->extra_info
->status
& MY_FRAME_IN_FP
)
182 fi
->frame
= read_register (A3_REGNUM
);
187 /* Set offsets of registers saved by movm instruction.
188 This is a helper function for mn10300_analyze_prologue. */
191 set_movm_offsets (struct frame_info
*fi
, int movm_args
)
195 if (fi
== NULL
|| movm_args
== 0)
198 if (movm_args
& 0x10)
200 fi
->saved_regs
[A3_REGNUM
] = fi
->frame
+ offset
;
203 if (movm_args
& 0x20)
205 fi
->saved_regs
[A2_REGNUM
] = fi
->frame
+ offset
;
208 if (movm_args
& 0x40)
210 fi
->saved_regs
[D3_REGNUM
] = fi
->frame
+ offset
;
213 if (movm_args
& 0x80)
215 fi
->saved_regs
[D2_REGNUM
] = fi
->frame
+ offset
;
218 if (AM33_MODE
&& movm_args
& 0x02)
220 fi
->saved_regs
[E0_REGNUM
+ 5] = fi
->frame
+ offset
;
221 fi
->saved_regs
[E0_REGNUM
+ 4] = fi
->frame
+ offset
+ 4;
222 fi
->saved_regs
[E0_REGNUM
+ 3] = fi
->frame
+ offset
+ 8;
223 fi
->saved_regs
[E0_REGNUM
+ 2] = fi
->frame
+ offset
+ 12;
228 /* The main purpose of this file is dealing with prologues to extract
229 information about stack frames and saved registers.
231 For reference here's how prologues look on the mn10300:
234 movm [d2,d3,a2,a3],sp
238 Without frame pointer:
239 movm [d2,d3,a2,a3],sp (if needed)
242 One day we might keep the stack pointer constant, that won't
243 change the code for prologues, but it will make the frame
244 pointerless case much more common. */
246 /* Analyze the prologue to determine where registers are saved,
247 the end of the prologue, etc etc. Return the end of the prologue
250 We store into FI (if non-null) several tidbits of information:
252 * stack_size -- size of this stack frame. Note that if we stop in
253 certain parts of the prologue/epilogue we may claim the size of the
254 current frame is zero. This happens when the current frame has
255 not been allocated yet or has already been deallocated.
257 * fsr -- Addresses of registers saved in the stack by this frame.
259 * status -- A (relatively) generic status indicator. It's a bitmask
260 with the following bits:
262 MY_FRAME_IN_SP: The base of the current frame is actually in
263 the stack pointer. This can happen for frame pointerless
264 functions, or cases where we're stopped in the prologue/epilogue
265 itself. For these cases mn10300_analyze_prologue will need up
266 update fi->frame before returning or analyzing the register
269 MY_FRAME_IN_FP: The base of the current frame is in the
270 frame pointer register ($a2).
272 NO_MORE_FRAMES: Set this if the current frame is "start" or
273 if the first instruction looks like mov <imm>,sp. This tells
274 frame chain to not bother trying to unwind past this frame. */
277 mn10300_analyze_prologue (struct frame_info
*fi
, CORE_ADDR pc
)
279 CORE_ADDR func_addr
, func_end
, addr
, stop
;
280 CORE_ADDR stack_size
;
282 unsigned char buf
[4];
283 int status
, movm_args
= 0;
286 /* Use the PC in the frame if it's provided to look up the
287 start of this function. */
288 pc
= (fi
? fi
->pc
: pc
);
290 /* Find the start of this function. */
291 status
= find_pc_partial_function (pc
, &name
, &func_addr
, &func_end
);
293 /* Do nothing if we couldn't find the start of this function or if we're
294 stopped at the first instruction in the prologue. */
300 /* If we're in start, then give up. */
301 if (strcmp (name
, "start") == 0)
304 fi
->extra_info
->status
= NO_MORE_FRAMES
;
308 /* At the start of a function our frame is in the stack pointer. */
310 fi
->extra_info
->status
= MY_FRAME_IN_SP
;
312 /* Get the next two bytes into buf, we need two because rets is a two
313 byte insn and the first isn't enough to uniquely identify it. */
314 status
= read_memory_nobpt (pc
, buf
, 2);
318 /* If we're physically on an "rets" instruction, then our frame has
319 already been deallocated. Note this can also be true for retf
320 and ret if they specify a size of zero.
322 In this case fi->frame is bogus, we need to fix it. */
323 if (fi
&& buf
[0] == 0xf0 && buf
[1] == 0xfc)
325 if (fi
->next
== NULL
)
326 fi
->frame
= read_sp ();
330 /* Similarly if we're stopped on the first insn of a prologue as our
331 frame hasn't been allocated yet. */
332 if (fi
&& fi
->pc
== func_addr
)
334 if (fi
->next
== NULL
)
335 fi
->frame
= read_sp ();
339 /* Figure out where to stop scanning. */
340 stop
= fi
? fi
->pc
: func_end
;
342 /* Don't walk off the end of the function. */
343 stop
= stop
> func_end
? func_end
: stop
;
345 /* Start scanning on the first instruction of this function. */
348 /* Suck in two bytes. */
349 status
= read_memory_nobpt (addr
, buf
, 2);
352 fix_frame_pointer (fi
, 0);
356 /* First see if this insn sets the stack pointer; if so, it's something
357 we won't understand, so quit now. */
358 if (buf
[0] == 0xf2 && (buf
[1] & 0xf3) == 0xf0)
361 fi
->extra_info
->status
= NO_MORE_FRAMES
;
365 /* Now look for movm [regs],sp, which saves the callee saved registers.
367 At this time we don't know if fi->frame is valid, so we only note
368 that we encountered a movm instruction. Later, we'll set the entries
369 in fsr.regs as needed. */
372 /* Extract the register list for the movm instruction. */
373 status
= read_memory_nobpt (addr
+ 1, buf
, 1);
378 /* Quit now if we're beyond the stop point. */
381 /* Fix fi->frame since it's bogus at this point. */
382 if (fi
&& fi
->next
== NULL
)
383 fi
->frame
= read_sp ();
385 /* Note if/where callee saved registers were saved. */
386 set_movm_offsets (fi
, movm_args
);
390 /* Get the next two bytes so the prologue scan can continue. */
391 status
= read_memory_nobpt (addr
, buf
, 2);
394 /* Fix fi->frame since it's bogus at this point. */
395 if (fi
&& fi
->next
== NULL
)
396 fi
->frame
= read_sp ();
398 /* Note if/where callee saved registers were saved. */
399 set_movm_offsets (fi
, movm_args
);
404 /* Now see if we set up a frame pointer via "mov sp,a3" */
409 /* The frame pointer is now valid. */
412 fi
->extra_info
->status
|= MY_FRAME_IN_FP
;
413 fi
->extra_info
->status
&= ~MY_FRAME_IN_SP
;
416 /* Quit now if we're beyond the stop point. */
419 /* Fix fi->frame if it's bogus at this point. */
420 fix_frame_pointer (fi
, 0);
422 /* Note if/where callee saved registers were saved. */
423 set_movm_offsets (fi
, movm_args
);
427 /* Get two more bytes so scanning can continue. */
428 status
= read_memory_nobpt (addr
, buf
, 2);
431 /* Fix fi->frame if it's bogus at this point. */
432 fix_frame_pointer (fi
, 0);
434 /* Note if/where callee saved registers were saved. */
435 set_movm_offsets (fi
, movm_args
);
440 /* Next we should allocate the local frame. No more prologue insns
441 are found after allocating the local frame.
443 Search for add imm8,sp (0xf8feXX)
444 or add imm16,sp (0xfafeXXXX)
445 or add imm32,sp (0xfcfeXXXXXXXX).
447 If none of the above was found, then this prologue has no
450 status
= read_memory_nobpt (addr
, buf
, 2);
453 /* Fix fi->frame if it's bogus at this point. */
454 fix_frame_pointer (fi
, 0);
456 /* Note if/where callee saved registers were saved. */
457 set_movm_offsets (fi
, movm_args
);
462 if (buf
[0] == 0xf8 && buf
[1] == 0xfe)
464 else if (buf
[0] == 0xfa && buf
[1] == 0xfe)
466 else if (buf
[0] == 0xfc && buf
[1] == 0xfe)
471 /* Suck in imm_size more bytes, they'll hold the size of the
473 status
= read_memory_nobpt (addr
+ 2, buf
, imm_size
);
476 /* Fix fi->frame if it's bogus at this point. */
477 fix_frame_pointer (fi
, 0);
479 /* Note if/where callee saved registers were saved. */
480 set_movm_offsets (fi
, movm_args
);
484 /* Note the size of the stack in the frame info structure. */
485 stack_size
= extract_signed_integer (buf
, imm_size
);
487 fi
->extra_info
->stack_size
= stack_size
;
489 /* We just consumed 2 + imm_size bytes. */
490 addr
+= 2 + imm_size
;
492 /* No more prologue insns follow, so begin preparation to return. */
493 /* Fix fi->frame if it's bogus at this point. */
494 fix_frame_pointer (fi
, stack_size
);
496 /* Note if/where callee saved registers were saved. */
497 set_movm_offsets (fi
, movm_args
);
501 /* We never found an insn which allocates local stack space, regardless
502 this is the end of the prologue. */
503 /* Fix fi->frame if it's bogus at this point. */
504 fix_frame_pointer (fi
, 0);
506 /* Note if/where callee saved registers were saved. */
507 set_movm_offsets (fi
, movm_args
);
511 /* Function: frame_chain
512 Figure out and return the caller's frame pointer given current
515 We don't handle dummy frames yet but we would probably just return the
516 stack pointer that was in use at the time the function call was made? */
519 mn10300_frame_chain (struct frame_info
*fi
)
521 struct frame_info
*dummy
;
522 /* Walk through the prologue to determine the stack size,
523 location of saved registers, end of the prologue, etc. */
524 if (fi
->extra_info
->status
== 0)
525 mn10300_analyze_prologue (fi
, (CORE_ADDR
) 0);
527 /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
528 if (fi
->extra_info
->status
& NO_MORE_FRAMES
)
531 /* Now that we've analyzed our prologue, determine the frame
532 pointer for our caller.
534 If our caller has a frame pointer, then we need to
535 find the entry value of $a3 to our function.
537 If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
538 location pointed to by fsr.regs[A3_REGNUM].
540 Else it's still in $a3.
542 If our caller does not have a frame pointer, then his
543 frame base is fi->frame + -caller's stack size. */
545 /* The easiest way to get that info is to analyze our caller's frame.
546 So we set up a dummy frame and call mn10300_analyze_prologue to
547 find stuff for us. */
548 dummy
= analyze_dummy_frame (FRAME_SAVED_PC (fi
), fi
->frame
);
550 if (dummy
->extra_info
->status
& MY_FRAME_IN_FP
)
552 /* Our caller has a frame pointer. So find the frame in $a3 or
554 if (fi
->saved_regs
[A3_REGNUM
])
555 return (read_memory_integer (fi
->saved_regs
[A3_REGNUM
], REGISTER_SIZE
));
557 return read_register (A3_REGNUM
);
563 adjust
+= (fi
->saved_regs
[D2_REGNUM
] ? 4 : 0);
564 adjust
+= (fi
->saved_regs
[D3_REGNUM
] ? 4 : 0);
565 adjust
+= (fi
->saved_regs
[A2_REGNUM
] ? 4 : 0);
566 adjust
+= (fi
->saved_regs
[A3_REGNUM
] ? 4 : 0);
569 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 5] ? 4 : 0);
570 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 4] ? 4 : 0);
571 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 3] ? 4 : 0);
572 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 2] ? 4 : 0);
575 /* Our caller does not have a frame pointer. So his frame starts
576 at the base of our frame (fi->frame) + register save space
578 return fi
->frame
+ adjust
+ -dummy
->extra_info
->stack_size
;
582 /* Function: skip_prologue
583 Return the address of the first inst past the prologue of the function. */
586 mn10300_skip_prologue (CORE_ADDR pc
)
588 /* We used to check the debug symbols, but that can lose if
589 we have a null prologue. */
590 return mn10300_analyze_prologue (NULL
, pc
);
594 /* Function: pop_frame
595 This routine gets called when either the user uses the `return'
596 command, or the call dummy breakpoint gets hit. */
599 mn10300_pop_frame (struct frame_info
*frame
)
603 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
604 generic_pop_dummy_frame ();
607 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
609 /* Restore any saved registers. */
610 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
611 if (frame
->saved_regs
[regnum
] != 0)
615 value
= read_memory_unsigned_integer (frame
->saved_regs
[regnum
],
616 REGISTER_RAW_SIZE (regnum
));
617 write_register (regnum
, value
);
620 /* Actually cut back the stack. */
621 write_register (SP_REGNUM
, FRAME_FP (frame
));
623 /* Don't we need to set the PC?!? XXX FIXME. */
626 /* Throw away any cached frame information. */
627 flush_cached_frames ();
630 /* Function: push_arguments
631 Setup arguments for a call to the target. Arguments go in
632 order on the stack. */
635 mn10300_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
636 int struct_return
, CORE_ADDR struct_addr
)
640 int stack_offset
= 0;
641 int regsused
= struct_return
? 1 : 0;
643 /* This should be a nop, but align the stack just in case something
644 went wrong. Stacks are four byte aligned on the mn10300. */
647 /* Now make space on the stack for the args.
649 XXX This doesn't appear to handle pass-by-invisible reference
651 for (argnum
= 0; argnum
< nargs
; argnum
++)
653 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3;
655 while (regsused
< 2 && arg_length
> 0)
663 /* Allocate stack space. */
666 regsused
= struct_return
? 1 : 0;
667 /* Push all arguments onto the stack. */
668 for (argnum
= 0; argnum
< nargs
; argnum
++)
673 /* XXX Check this. What about UNIONS? */
674 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
675 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
677 /* XXX Wrong, we want a pointer to this argument. */
678 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
679 val
= (char *) VALUE_CONTENTS (*args
);
683 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
684 val
= (char *) VALUE_CONTENTS (*args
);
687 while (regsused
< 2 && len
> 0)
689 write_register (regsused
, extract_unsigned_integer (val
, 4));
697 write_memory (sp
+ stack_offset
, val
, 4);
706 /* Make space for the flushback area. */
711 /* Function: push_return_address (pc)
712 Set up the return address for the inferior function call.
713 Needed for targets where we don't actually execute a JSR/BSR instruction */
716 mn10300_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
718 unsigned char buf
[4];
720 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
721 write_memory (sp
- 4, buf
, 4);
725 /* Function: store_struct_return (addr,sp)
726 Store the structure value return address for an inferior function
730 mn10300_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
732 /* The structure return address is passed as the first argument. */
733 write_register (0, addr
);
737 /* Function: frame_saved_pc
738 Find the caller of this frame. We do this by seeing if RP_REGNUM
739 is saved in the stack anywhere, otherwise we get it from the
740 registers. If the inner frame is a dummy frame, return its PC
741 instead of RP, because that's where "caller" of the dummy-frame
745 mn10300_frame_saved_pc (struct frame_info
*fi
)
749 adjust
+= (fi
->saved_regs
[D2_REGNUM
] ? 4 : 0);
750 adjust
+= (fi
->saved_regs
[D3_REGNUM
] ? 4 : 0);
751 adjust
+= (fi
->saved_regs
[A2_REGNUM
] ? 4 : 0);
752 adjust
+= (fi
->saved_regs
[A3_REGNUM
] ? 4 : 0);
755 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 5] ? 4 : 0);
756 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 4] ? 4 : 0);
757 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 3] ? 4 : 0);
758 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 2] ? 4 : 0);
761 return (read_memory_integer (fi
->frame
+ adjust
, REGISTER_SIZE
));
764 /* Function: mn10300_init_extra_frame_info
765 Setup the frame's frame pointer, pc, and frame addresses for saved
766 registers. Most of the work is done in mn10300_analyze_prologue().
768 Note that when we are called for the last frame (currently active frame),
769 that fi->pc and fi->frame will already be setup. However, fi->frame will
770 be valid only if this routine uses FP. For previous frames, fi-frame will
771 always be correct. mn10300_analyze_prologue will fix fi->frame if
774 We can be called with the PC in the call dummy under two circumstances.
775 First, during normal backtracing, second, while figuring out the frame
776 pointer just prior to calling the target function (see run_stack_dummy). */
779 mn10300_init_extra_frame_info (struct frame_info
*fi
)
782 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
784 frame_saved_regs_zalloc (fi
);
785 fi
->extra_info
= (struct frame_extra_info
*)
786 frame_obstack_alloc (sizeof (struct frame_extra_info
));
788 fi
->extra_info
->status
= 0;
789 fi
->extra_info
->stack_size
= 0;
791 mn10300_analyze_prologue (fi
, 0);
794 /* Function: mn10300_virtual_frame_pointer
795 Return the register that the function uses for a frame pointer,
796 plus any necessary offset to be applied to the register before
797 any frame pointer offsets. */
800 mn10300_virtual_frame_pointer (CORE_ADDR pc
, long *reg
, long *offset
)
802 struct frame_info
*dummy
= analyze_dummy_frame (pc
, 0);
803 /* Set up a dummy frame_info, Analyze the prolog and fill in the
805 /* Results will tell us which type of frame it uses. */
806 if (dummy
->extra_info
->status
& MY_FRAME_IN_SP
)
809 *offset
= -(dummy
->extra_info
->stack_size
);
819 mn10300_reg_struct_has_addr (int gcc_p
, struct type
*type
)
821 return (TYPE_LENGTH (type
) > 8);
825 mn10300_register_virtual_type (int reg
)
827 return builtin_type_int
;
831 mn10300_register_byte (int reg
)
837 mn10300_register_virtual_size (int reg
)
843 mn10300_register_raw_size (int reg
)
849 mn10300_print_register (const char *name
, int regnum
, int reg_width
)
851 char *raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
854 printf_filtered ("%*s: ", reg_width
, name
);
856 printf_filtered ("%s: ", name
);
859 if (read_relative_register_raw_bytes (regnum
, raw_buffer
))
861 printf_filtered ("[invalid]");
867 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
869 for (byte
= REGISTER_RAW_SIZE (regnum
) - REGISTER_VIRTUAL_SIZE (regnum
);
870 byte
< REGISTER_RAW_SIZE (regnum
);
872 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
876 for (byte
= REGISTER_VIRTUAL_SIZE (regnum
) - 1;
879 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
885 mn10300_do_registers_info (int regnum
, int fpregs
)
889 const char *name
= REGISTER_NAME (regnum
);
890 if (name
== NULL
|| name
[0] == '\0')
891 error ("Not a valid register for the current processor type");
892 mn10300_print_register (name
, regnum
, 0);
893 printf_filtered ("\n");
897 /* print registers in an array 4x8 */
900 const int nr_in_row
= 4;
901 const int reg_width
= 4;
902 for (r
= 0; r
< NUM_REGS
; r
+= nr_in_row
)
907 for (c
= r
; c
< r
+ nr_in_row
; c
++)
909 const char *name
= REGISTER_NAME (c
);
910 if (name
!= NULL
&& *name
!= '\0')
915 printf_filtered (" ");
918 mn10300_print_register (name
, c
, reg_width
);
919 printf_filtered (" ");
923 padding
+= (reg_width
+ 2 + 8 + 1);
927 printf_filtered ("\n");
932 /* Dump out the mn10300 speciic architecture information. */
935 mn10300_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
937 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
938 fprintf_unfiltered (file
, "mn10300_dump_tdep: am33_mode = %d\n",
942 static struct gdbarch
*
943 mn10300_gdbarch_init (struct gdbarch_info info
,
944 struct gdbarch_list
*arches
)
946 struct gdbarch
*gdbarch
;
947 struct gdbarch_tdep
*tdep
= NULL
;
949 gdbarch_register_name_ftype
*register_name
;
953 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
955 return arches
->gdbarch
;
956 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
957 gdbarch
= gdbarch_alloc (&info
, tdep
);
959 if (info
.bfd_arch_info
!= NULL
960 && info
.bfd_arch_info
->arch
== bfd_arch_mn10300
)
961 mach
= info
.bfd_arch_info
->mach
;
967 case bfd_mach_mn10300
:
969 register_name
= mn10300_generic_register_name
;
974 register_name
= am33_register_name
;
978 internal_error (__FILE__
, __LINE__
,
979 "mn10300_gdbarch_init: Unknown mn10300 variant");
980 return NULL
; /* keep GCC happy. */
983 set_gdbarch_register_size (gdbarch
, 4);
984 set_gdbarch_max_register_raw_size (gdbarch
, 4);
985 set_gdbarch_register_virtual_type (gdbarch
, mn10300_register_virtual_type
);
986 set_gdbarch_register_byte (gdbarch
, mn10300_register_byte
);
987 set_gdbarch_register_virtual_size (gdbarch
, mn10300_register_virtual_size
);
988 set_gdbarch_register_raw_size (gdbarch
, mn10300_register_raw_size
);
989 set_gdbarch_call_dummy_p (gdbarch
, 1);
990 set_gdbarch_register_name (gdbarch
, register_name
);
991 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
992 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 0);
993 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
994 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
995 set_gdbarch_push_arguments (gdbarch
, mn10300_push_arguments
);
996 set_gdbarch_push_return_address (gdbarch
, mn10300_push_return_address
);
997 set_gdbarch_frame_chain_valid (gdbarch
, generic_file_frame_chain_valid
);
998 set_gdbarch_reg_struct_has_addr (gdbarch
, mn10300_reg_struct_has_addr
);
999 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1000 set_gdbarch_num_regs (gdbarch
, num_regs
);
1001 set_gdbarch_do_registers_info (gdbarch
, mn10300_do_registers_info
);
1003 tdep
->am33_mode
= am33_mode
;
1009 _initialize_mn10300_tdep (void)
1011 /* printf("_initialize_mn10300_tdep\n"); */
1013 tm_print_insn
= print_insn_mn10300
;
1015 register_gdbarch_init (bfd_arch_mn10300
, mn10300_gdbarch_init
);