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
& 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
);
595 /* generic_pop_current_frame calls this function if the current
596 frame isn't a dummy frame. */
598 mn10300_pop_frame_regular (struct frame_info
*frame
)
602 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
604 /* Restore any saved registers. */
605 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
606 if (frame
->saved_regs
[regnum
] != 0)
610 value
= read_memory_unsigned_integer (frame
->saved_regs
[regnum
],
611 REGISTER_RAW_SIZE (regnum
));
612 write_register (regnum
, value
);
615 /* Actually cut back the stack. */
616 write_register (SP_REGNUM
, FRAME_FP (frame
));
618 /* Don't we need to set the PC?!? XXX FIXME. */
621 /* Function: pop_frame
622 This routine gets called when either the user uses the `return'
623 command, or the call dummy breakpoint gets hit. */
625 mn10300_pop_frame (void)
627 /* This function checks for and handles generic dummy frames, and
628 calls back to our function for ordinary frames. */
629 generic_pop_current_frame (mn10300_pop_frame_regular
);
631 /* Throw away any cached frame information. */
632 flush_cached_frames ();
635 /* Function: push_arguments
636 Setup arguments for a call to the target. Arguments go in
637 order on the stack. */
640 mn10300_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
641 int struct_return
, CORE_ADDR struct_addr
)
645 int stack_offset
= 0;
646 int regsused
= struct_return
? 1 : 0;
648 /* This should be a nop, but align the stack just in case something
649 went wrong. Stacks are four byte aligned on the mn10300. */
652 /* Now make space on the stack for the args.
654 XXX This doesn't appear to handle pass-by-invisible reference
656 for (argnum
= 0; argnum
< nargs
; argnum
++)
658 int arg_length
= (TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3;
660 while (regsused
< 2 && arg_length
> 0)
668 /* Allocate stack space. */
671 regsused
= struct_return
? 1 : 0;
672 /* Push all arguments onto the stack. */
673 for (argnum
= 0; argnum
< nargs
; argnum
++)
678 /* XXX Check this. What about UNIONS? */
679 if (TYPE_CODE (VALUE_TYPE (*args
)) == TYPE_CODE_STRUCT
680 && TYPE_LENGTH (VALUE_TYPE (*args
)) > 8)
682 /* XXX Wrong, we want a pointer to this argument. */
683 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
684 val
= (char *) VALUE_CONTENTS (*args
);
688 len
= TYPE_LENGTH (VALUE_TYPE (*args
));
689 val
= (char *) VALUE_CONTENTS (*args
);
692 while (regsused
< 2 && len
> 0)
694 write_register (regsused
, extract_unsigned_integer (val
, 4));
702 write_memory (sp
+ stack_offset
, val
, 4);
711 /* Make space for the flushback area. */
716 /* Function: push_return_address (pc)
717 Set up the return address for the inferior function call.
718 Needed for targets where we don't actually execute a JSR/BSR instruction */
721 mn10300_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
723 unsigned char buf
[4];
725 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
726 write_memory (sp
- 4, buf
, 4);
730 /* Function: store_struct_return (addr,sp)
731 Store the structure value return address for an inferior function
735 mn10300_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
737 /* The structure return address is passed as the first argument. */
738 write_register (0, addr
);
741 /* Function: frame_saved_pc
742 Find the caller of this frame. We do this by seeing if RP_REGNUM
743 is saved in the stack anywhere, otherwise we get it from the
744 registers. If the inner frame is a dummy frame, return its PC
745 instead of RP, because that's where "caller" of the dummy-frame
749 mn10300_frame_saved_pc (struct frame_info
*fi
)
753 adjust
+= (fi
->saved_regs
[D2_REGNUM
] ? 4 : 0);
754 adjust
+= (fi
->saved_regs
[D3_REGNUM
] ? 4 : 0);
755 adjust
+= (fi
->saved_regs
[A2_REGNUM
] ? 4 : 0);
756 adjust
+= (fi
->saved_regs
[A3_REGNUM
] ? 4 : 0);
759 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 5] ? 4 : 0);
760 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 4] ? 4 : 0);
761 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 3] ? 4 : 0);
762 adjust
+= (fi
->saved_regs
[E0_REGNUM
+ 2] ? 4 : 0);
765 return (read_memory_integer (fi
->frame
+ adjust
, REGISTER_SIZE
));
768 /* Function: mn10300_init_extra_frame_info
769 Setup the frame's frame pointer, pc, and frame addresses for saved
770 registers. Most of the work is done in mn10300_analyze_prologue().
772 Note that when we are called for the last frame (currently active frame),
773 that fi->pc and fi->frame will already be setup. However, fi->frame will
774 be valid only if this routine uses FP. For previous frames, fi-frame will
775 always be correct. mn10300_analyze_prologue will fix fi->frame if
778 We can be called with the PC in the call dummy under two circumstances.
779 First, during normal backtracing, second, while figuring out the frame
780 pointer just prior to calling the target function (see run_stack_dummy). */
783 mn10300_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
786 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
788 frame_saved_regs_zalloc (fi
);
789 fi
->extra_info
= (struct frame_extra_info
*)
790 frame_obstack_alloc (sizeof (struct frame_extra_info
));
792 fi
->extra_info
->status
= 0;
793 fi
->extra_info
->stack_size
= 0;
795 mn10300_analyze_prologue (fi
, 0);
799 /* This function's job is handled by init_extra_frame_info. */
801 mn10300_frame_init_saved_regs (struct frame_info
*frame
)
806 /* Function: mn10300_virtual_frame_pointer
807 Return the register that the function uses for a frame pointer,
808 plus any necessary offset to be applied to the register before
809 any frame pointer offsets. */
812 mn10300_virtual_frame_pointer (CORE_ADDR pc
, long *reg
, long *offset
)
814 struct frame_info
*dummy
= analyze_dummy_frame (pc
, 0);
815 /* Set up a dummy frame_info, Analyze the prolog and fill in the
817 /* Results will tell us which type of frame it uses. */
818 if (dummy
->extra_info
->status
& MY_FRAME_IN_SP
)
821 *offset
= -(dummy
->extra_info
->stack_size
);
831 mn10300_reg_struct_has_addr (int gcc_p
, struct type
*type
)
833 return (TYPE_LENGTH (type
) > 8);
837 mn10300_register_virtual_type (int reg
)
839 return builtin_type_int
;
843 mn10300_register_byte (int reg
)
849 mn10300_register_virtual_size (int reg
)
855 mn10300_register_raw_size (int reg
)
861 mn10300_print_register (const char *name
, int regnum
, int reg_width
)
863 char *raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
866 printf_filtered ("%*s: ", reg_width
, name
);
868 printf_filtered ("%s: ", name
);
871 if (read_relative_register_raw_bytes (regnum
, raw_buffer
))
873 printf_filtered ("[invalid]");
879 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
881 for (byte
= REGISTER_RAW_SIZE (regnum
) - REGISTER_VIRTUAL_SIZE (regnum
);
882 byte
< REGISTER_RAW_SIZE (regnum
);
884 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
888 for (byte
= REGISTER_VIRTUAL_SIZE (regnum
) - 1;
891 printf_filtered ("%02x", (unsigned char) raw_buffer
[byte
]);
897 mn10300_do_registers_info (int regnum
, int fpregs
)
901 const char *name
= REGISTER_NAME (regnum
);
902 if (name
== NULL
|| name
[0] == '\0')
903 error ("Not a valid register for the current processor type");
904 mn10300_print_register (name
, regnum
, 0);
905 printf_filtered ("\n");
909 /* print registers in an array 4x8 */
912 const int nr_in_row
= 4;
913 const int reg_width
= 4;
914 for (r
= 0; r
< NUM_REGS
; r
+= nr_in_row
)
919 for (c
= r
; c
< r
+ nr_in_row
; c
++)
921 const char *name
= REGISTER_NAME (c
);
922 if (name
!= NULL
&& *name
!= '\0')
927 printf_filtered (" ");
930 mn10300_print_register (name
, c
, reg_width
);
931 printf_filtered (" ");
935 padding
+= (reg_width
+ 2 + 8 + 1);
939 printf_filtered ("\n");
944 /* Dump out the mn10300 speciic architecture information. */
947 mn10300_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
949 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
950 fprintf_unfiltered (file
, "mn10300_dump_tdep: am33_mode = %d\n",
954 static struct gdbarch
*
955 mn10300_gdbarch_init (struct gdbarch_info info
,
956 struct gdbarch_list
*arches
)
958 static LONGEST mn10300_call_dummy_words
[] = { 0 };
959 struct gdbarch
*gdbarch
;
960 struct gdbarch_tdep
*tdep
= NULL
;
962 gdbarch_register_name_ftype
*register_name
;
966 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
968 return arches
->gdbarch
;
969 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
970 gdbarch
= gdbarch_alloc (&info
, tdep
);
972 if (info
.bfd_arch_info
!= NULL
973 && info
.bfd_arch_info
->arch
== bfd_arch_mn10300
)
974 mach
= info
.bfd_arch_info
->mach
;
980 case bfd_mach_mn10300
:
982 register_name
= mn10300_generic_register_name
;
987 register_name
= am33_register_name
;
991 internal_error (__FILE__
, __LINE__
,
992 "mn10300_gdbarch_init: Unknown mn10300 variant");
993 return NULL
; /* keep GCC happy. */
997 set_gdbarch_num_regs (gdbarch
, num_regs
);
998 set_gdbarch_register_name (gdbarch
, register_name
);
999 set_gdbarch_register_size (gdbarch
, 4);
1000 set_gdbarch_register_bytes (gdbarch
,
1001 num_regs
* gdbarch_register_size (gdbarch
));
1002 set_gdbarch_max_register_raw_size (gdbarch
, 4);
1003 set_gdbarch_register_raw_size (gdbarch
, mn10300_register_raw_size
);
1004 set_gdbarch_register_byte (gdbarch
, mn10300_register_byte
);
1005 set_gdbarch_max_register_virtual_size (gdbarch
, 4);
1006 set_gdbarch_register_virtual_size (gdbarch
, mn10300_register_virtual_size
);
1007 set_gdbarch_register_virtual_type (gdbarch
, mn10300_register_virtual_type
);
1008 set_gdbarch_do_registers_info (gdbarch
, mn10300_do_registers_info
);
1009 set_gdbarch_fp_regnum (gdbarch
, 31);
1012 set_gdbarch_breakpoint_from_pc (gdbarch
, mn10300_breakpoint_from_pc
);
1013 set_gdbarch_function_start_offset (gdbarch
, 0);
1014 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
1016 /* Stack unwinding. */
1017 set_gdbarch_get_saved_register (gdbarch
, generic_get_saved_register
);
1018 set_gdbarch_frame_chain_valid (gdbarch
, generic_file_frame_chain_valid
);
1019 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1020 set_gdbarch_frame_chain_valid (gdbarch
, generic_file_frame_chain_valid
);
1021 set_gdbarch_saved_pc_after_call (gdbarch
, mn10300_saved_pc_after_call
);
1022 set_gdbarch_init_extra_frame_info (gdbarch
, mn10300_init_extra_frame_info
);
1023 set_gdbarch_frame_init_saved_regs (gdbarch
, mn10300_frame_init_saved_regs
);
1024 set_gdbarch_frame_chain (gdbarch
, mn10300_frame_chain
);
1025 set_gdbarch_frame_saved_pc (gdbarch
, mn10300_frame_saved_pc
);
1026 set_gdbarch_extract_return_value (gdbarch
, mn10300_extract_return_value
);
1027 set_gdbarch_extract_struct_value_address
1028 (gdbarch
, mn10300_extract_struct_value_address
);
1029 set_gdbarch_store_return_value (gdbarch
, mn10300_store_return_value
);
1030 set_gdbarch_store_struct_return (gdbarch
, mn10300_store_struct_return
);
1031 set_gdbarch_pop_frame (gdbarch
, mn10300_pop_frame
);
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
);
1040 /* Calling functions in the inferior from GDB. */
1041 set_gdbarch_call_dummy_p (gdbarch
, 1);
1042 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 0);
1043 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1044 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1045 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
1046 set_gdbarch_call_dummy_words (gdbarch
, mn10300_call_dummy_words
);
1047 set_gdbarch_sizeof_call_dummy_words (gdbarch
,
1048 sizeof (mn10300_call_dummy_words
));
1049 set_gdbarch_call_dummy_length (gdbarch
, 0);
1050 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1051 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1052 set_gdbarch_pc_in_call_dummy (gdbarch
, pc_in_call_dummy_at_entry_point
);
1053 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
1054 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1055 set_gdbarch_push_arguments (gdbarch
, mn10300_push_arguments
);
1056 set_gdbarch_reg_struct_has_addr (gdbarch
, mn10300_reg_struct_has_addr
);
1057 set_gdbarch_push_return_address (gdbarch
, mn10300_push_return_address
);
1058 set_gdbarch_save_dummy_frame_tos (gdbarch
, generic_save_dummy_frame_tos
);
1059 set_gdbarch_use_struct_convention (gdbarch
, mn10300_use_struct_convention
);
1061 tdep
->am33_mode
= am33_mode
;
1067 _initialize_mn10300_tdep (void)
1069 /* printf("_initialize_mn10300_tdep\n"); */
1071 tm_print_insn
= print_insn_mn10300
;
1073 register_gdbarch_init (bfd_arch_mn10300
, mn10300_gdbarch_init
);