1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
3 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
4 Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 To get from 1.1 to 1.2, add:
29 extract_struct_value_address
31 Make sure to use regcache. */
35 Apparently cannot run without a stub placeholder for unwind_dummy_id.
40 To get from 1.2 to 1.3, add:
43 struct mn10300_unwind_cache
48 frame_sniffer (struct mn10300_frame_unwind)
52 #include "arch-utils.h"
56 #include "gdb_string.h"
57 #include "gdb_assert.h"
58 #include "gdbcore.h" /* for write_memory_unsigned_integer */
62 #include "frame-unwind.h"
63 #include "frame-base.h"
64 #include "trad-frame.h"
66 #include "dwarf2-frame.h"
69 #include "mn10300-tdep.h"
72 /* Compute the alignment required by a type. */
75 mn10300_type_align (struct type
*type
)
79 switch (TYPE_CODE (type
))
90 return TYPE_LENGTH (type
);
92 case TYPE_CODE_COMPLEX
:
93 return TYPE_LENGTH (type
) / 2;
95 case TYPE_CODE_STRUCT
:
97 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
99 int falign
= mn10300_type_align (TYPE_FIELD_TYPE (type
, i
));
100 while (align
< falign
)
105 case TYPE_CODE_ARRAY
:
106 /* HACK! Structures containing arrays, even small ones, are not
107 elligible for returning in registers. */
110 case TYPE_CODE_TYPEDEF
:
111 return mn10300_type_align (check_typedef (type
));
114 internal_error (__FILE__
, __LINE__
, _("bad switch"));
118 /* MVS note this is deprecated. */
119 /* Should call_function allocate stack space for a struct return? */
122 mn10300_use_struct_convention (int gcc_p
, struct type
*type
)
124 /* Structures bigger than a pair of words can't be returned in
126 if (TYPE_LENGTH (type
) > 8)
129 switch (TYPE_CODE (type
))
131 case TYPE_CODE_STRUCT
:
132 case TYPE_CODE_UNION
:
133 /* Structures with a single field are handled as the field
135 if (TYPE_NFIELDS (type
) == 1)
136 return mn10300_use_struct_convention (gcc_p
,
137 TYPE_FIELD_TYPE (type
, 0));
139 /* Structures with word or double-word size are passed in memory, as
140 long as they require at least word alignment. */
141 if (mn10300_type_align (type
) >= 4)
146 /* Arrays are addressable, so they're never returned in
147 registers. This condition can only hold when the array is
148 the only field of a struct or union. */
149 case TYPE_CODE_ARRAY
:
152 case TYPE_CODE_TYPEDEF
:
153 return mn10300_use_struct_convention (gcc_p
, check_typedef (type
));
160 /* MVS note this is deprecated. */
162 mn10300_store_return_value (struct type
*type
,
163 struct regcache
*regcache
, const void *valbuf
)
165 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
166 int len
= TYPE_LENGTH (type
);
169 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
174 regsz
= register_size (gdbarch
, reg
);
177 regcache_raw_write_part (regcache
, reg
, 0, len
, valbuf
);
178 else if (len
<= 2 * regsz
)
180 regcache_raw_write (regcache
, reg
, valbuf
);
181 gdb_assert (regsz
== register_size (gdbarch
, reg
+ 1));
182 regcache_raw_write_part (regcache
, reg
+1, 0,
183 len
- regsz
, (char *) valbuf
+ regsz
);
186 internal_error (__FILE__
, __LINE__
,
187 _("Cannot store return value %d bytes long."), len
);
190 /* MVS note deprecated. */
192 mn10300_extract_return_value (struct type
*type
,
193 struct regcache
*regcache
, void *valbuf
)
195 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
196 char buf
[MAX_REGISTER_SIZE
];
197 int len
= TYPE_LENGTH (type
);
200 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
205 regsz
= register_size (gdbarch
, reg
);
208 regcache_raw_read (regcache
, reg
, buf
);
209 memcpy (valbuf
, buf
, len
);
211 else if (len
<= 2 * regsz
)
213 regcache_raw_read (regcache
, reg
, buf
);
214 memcpy (valbuf
, buf
, regsz
);
215 gdb_assert (regsz
== register_size (gdbarch
, reg
+ 1));
216 regcache_raw_read (regcache
, reg
+ 1, buf
);
217 memcpy ((char *) valbuf
+ regsz
, buf
, len
- regsz
);
220 internal_error (__FILE__
, __LINE__
,
221 _("Cannot extract return value %d bytes long."), len
);
225 register_name (int reg
, char **regs
, long sizeof_regs
)
227 if (reg
< 0 || reg
>= sizeof_regs
/ sizeof (regs
[0]))
234 mn10300_generic_register_name (int reg
)
236 static char *regs
[] =
237 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
238 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
239 "", "", "", "", "", "", "", "",
240 "", "", "", "", "", "", "", "fp"
242 return register_name (reg
, regs
, sizeof regs
);
247 am33_register_name (int reg
)
249 static char *regs
[] =
250 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
251 "sp", "pc", "mdr", "psw", "lir", "lar", "",
252 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
253 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
255 return register_name (reg
, regs
, sizeof regs
);
260 mn10300_register_type (struct gdbarch
*gdbarch
, int reg
)
262 return builtin_type_int
;
266 mn10300_read_pc (ptid_t ptid
)
268 return read_register_pid (E_PC_REGNUM
, ptid
);
272 mn10300_write_pc (CORE_ADDR val
, ptid_t ptid
)
274 return write_register_pid (E_PC_REGNUM
, val
, ptid
);
277 /* The breakpoint instruction must be the same size as the smallest
278 instruction in the instruction set.
280 The Matsushita mn10x00 processors have single byte instructions
281 so we need a single byte breakpoint. Matsushita hasn't defined
282 one, so we defined it ourselves. */
284 const static unsigned char *
285 mn10300_breakpoint_from_pc (CORE_ADDR
*bp_addr
, int *bp_size
)
287 static char breakpoint
[] = {0xff};
292 /* Function: skip_prologue
293 Return the address of the first inst past the prologue of the function. */
296 mn10300_skip_prologue (CORE_ADDR pc
)
298 /* FIXME: not implemented. */
299 /* First approximation, try simply using skip_prologue_using_sal. */
300 return skip_prologue_using_sal (pc
);
303 /* Simple frame_unwind_cache.
304 This finds the "extra info" for the frame. */
305 struct trad_frame_cache
*
306 mn10300_frame_unwind_cache (struct frame_info
*next_frame
,
307 void **this_prologue_cache
)
309 struct trad_frame_cache
*cache
;
312 if (*this_prologue_cache
)
313 return (*this_prologue_cache
);
315 cache
= trad_frame_cache_zalloc (next_frame
);
316 pc
= gdbarch_unwind_pc (current_gdbarch
, next_frame
);
317 mn10300_analyze_prologue (next_frame
, (void **) &cache
, pc
);
319 trad_frame_set_id (cache
,
320 frame_id_build (trad_frame_get_this_base (cache
), pc
));
322 (*this_prologue_cache
) = cache
;
326 /* Here is a dummy implementation. */
327 static struct frame_id
328 mn10300_unwind_dummy_id (struct gdbarch
*gdbarch
,
329 struct frame_info
*next_frame
)
331 return frame_id_build (frame_sp_unwind (next_frame
),
332 frame_pc_unwind (next_frame
));
335 /* Trad frame implementation. */
337 mn10300_frame_this_id (struct frame_info
*next_frame
,
338 void **this_prologue_cache
,
339 struct frame_id
*this_id
)
341 struct trad_frame_cache
*cache
=
342 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
344 trad_frame_get_id (cache
, this_id
);
348 mn10300_frame_prev_register (struct frame_info
*next_frame
,
349 void **this_prologue_cache
,
350 int regnum
, int *optimizedp
,
351 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
352 int *realnump
, void *bufferp
)
354 struct trad_frame_cache
*cache
=
355 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
357 trad_frame_get_register (cache
, next_frame
, regnum
, optimizedp
,
358 lvalp
, addrp
, realnump
, bufferp
);
360 trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum,
361 optimizedp, lvalp, addrp, realnump, bufferp);
365 static const struct frame_unwind mn10300_frame_unwind
= {
367 mn10300_frame_this_id
,
368 mn10300_frame_prev_register
372 mn10300_frame_base_address (struct frame_info
*next_frame
,
373 void **this_prologue_cache
)
375 struct trad_frame_cache
*cache
=
376 mn10300_frame_unwind_cache (next_frame
, this_prologue_cache
);
378 return trad_frame_get_this_base (cache
);
381 static const struct frame_unwind
*
382 mn10300_frame_sniffer (struct frame_info
*next_frame
)
384 return &mn10300_frame_unwind
;
387 static const struct frame_base mn10300_frame_base
= {
388 &mn10300_frame_unwind
,
389 mn10300_frame_base_address
,
390 mn10300_frame_base_address
,
391 mn10300_frame_base_address
395 mn10300_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
399 frame_unwind_unsigned_register (next_frame
, E_PC_REGNUM
, &pc
);
404 mn10300_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
408 frame_unwind_unsigned_register (next_frame
, E_SP_REGNUM
, &sp
);
413 mn10300_frame_unwind_init (struct gdbarch
*gdbarch
)
415 frame_unwind_append_sniffer (gdbarch
, dwarf2_frame_sniffer
);
416 frame_unwind_append_sniffer (gdbarch
, mn10300_frame_sniffer
);
417 frame_base_set_default (gdbarch
, &mn10300_frame_base
);
418 set_gdbarch_unwind_dummy_id (gdbarch
, mn10300_unwind_dummy_id
);
419 set_gdbarch_unwind_pc (gdbarch
, mn10300_unwind_pc
);
420 set_gdbarch_unwind_sp (gdbarch
, mn10300_unwind_sp
);
423 /* Function: push_dummy_call
425 * Set up machine state for a target call, including
426 * function arguments, stack, return address, etc.
431 mn10300_push_dummy_call (struct gdbarch
*gdbarch
,
432 struct value
*target_func
,
433 struct regcache
*regcache
,
435 int nargs
, struct value
**args
,
438 CORE_ADDR struct_addr
)
440 const int push_size
= register_size (gdbarch
, E_PC_REGNUM
);
441 int regs_used
= struct_return
? 1 : 0;
443 int stack_offset
= 0;
447 /* FIXME temp, don't handle struct args at all. */
449 error ("Target doesn't handle struct return");
451 /* This should be a nop, but align the stack just in case something
452 went wrong. Stacks are four byte aligned on the mn10300. */
455 /* Now make space on the stack for the args.
457 XXX This doesn't appear to handle pass-by-invisible reference
459 for (len
= 0, argnum
= 0; argnum
< nargs
; argnum
++)
461 arg_len
= (TYPE_LENGTH (value_type (args
[argnum
])) + 3) & ~3;
462 if (TYPE_CODE (value_type (args
[argnum
])) == TYPE_CODE_STRUCT
)
463 error ("Target does not handle struct args");
464 while (regs_used
< 2 && arg_len
> 0)
467 arg_len
-= push_size
;
472 /* Allocate stack space. */
475 regs_used
= struct_return
? 1 : 0;
476 /* Push all arguments onto the stack. */
477 for (argnum
= 0; argnum
< nargs
; argnum
++)
479 /* FIXME what about structs? */
480 arg_len
= TYPE_LENGTH (value_type (*args
));
481 val
= (char *) value_contents (*args
);
483 while (regs_used
< 2 && arg_len
> 0)
485 write_register (regs_used
, extract_unsigned_integer (val
,
488 arg_len
-= push_size
;
494 write_memory (sp
+ stack_offset
, val
, push_size
);
495 arg_len
-= push_size
;
497 stack_offset
+= push_size
;
503 /* Make space for the flushback area. */
506 /* Push the return address that contains the magic breakpoint. */
508 write_memory_unsigned_integer (sp
, push_size
, bp_addr
);
510 regcache_cooked_write_unsigned (regcache
, E_SP_REGNUM
, sp
);
515 static struct gdbarch
*
516 mn10300_gdbarch_init (struct gdbarch_info info
,
517 struct gdbarch_list
*arches
)
519 struct gdbarch
*gdbarch
;
520 struct gdbarch_tdep
*tdep
;
522 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
524 return arches
->gdbarch
;
526 tdep
= xmalloc (sizeof (struct gdbarch_tdep
));
527 gdbarch
= gdbarch_alloc (&info
, tdep
);
529 switch (info
.bfd_arch_info
->mach
)
532 case bfd_mach_mn10300
:
533 set_gdbarch_register_name (gdbarch
, mn10300_generic_register_name
);
537 set_gdbarch_register_name (gdbarch
, am33_register_name
);
541 internal_error (__FILE__
, __LINE__
,
542 _("mn10300_gdbarch_init: Unknown mn10300 variant"));
547 set_gdbarch_num_regs (gdbarch
, E_NUM_REGS
);
548 set_gdbarch_register_type (gdbarch
, mn10300_register_type
);
549 set_gdbarch_skip_prologue (gdbarch
, mn10300_skip_prologue
);
550 set_gdbarch_read_pc (gdbarch
, mn10300_read_pc
);
551 set_gdbarch_write_pc (gdbarch
, mn10300_write_pc
);
552 set_gdbarch_pc_regnum (gdbarch
, E_PC_REGNUM
);
553 set_gdbarch_sp_regnum (gdbarch
, E_SP_REGNUM
);
555 /* Stack unwinding. */
556 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
558 set_gdbarch_breakpoint_from_pc (gdbarch
, mn10300_breakpoint_from_pc
);
559 /* decr_pc_after_break? */
561 set_gdbarch_print_insn (gdbarch
, print_insn_mn10300
);
564 /* MVS Note: at least the first one is deprecated! */
565 set_gdbarch_deprecated_use_struct_convention (gdbarch
,
566 mn10300_use_struct_convention
);
567 set_gdbarch_store_return_value (gdbarch
, mn10300_store_return_value
);
568 set_gdbarch_extract_return_value (gdbarch
, mn10300_extract_return_value
);
570 /* Stage 3 -- get target calls working. */
571 set_gdbarch_push_dummy_call (gdbarch
, mn10300_push_dummy_call
);
572 /* set_gdbarch_return_value (store, extract) */
575 mn10300_frame_unwind_init (gdbarch
);
580 /* Dump out the mn10300 specific architecture information. */
583 mn10300_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
585 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
586 fprintf_unfiltered (file
, "mn10300_dump_tdep: am33_mode = %d\n",
591 _initialize_mn10300_tdep (void)
593 gdbarch_register (bfd_arch_mn10300
, mn10300_gdbarch_init
, mn10300_dump_tdep
);