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"
59 #include "frame-unwind.h"
60 #include "frame-base.h"
61 #include "trad-frame.h"
63 #include "dwarf2-frame.h"
90 /* Compute the alignment required by a type. */
93 mn10300_type_align (struct type *type)
97 switch (TYPE_CODE (type))
102 case TYPE_CODE_RANGE:
108 return TYPE_LENGTH (type);
110 case TYPE_CODE_COMPLEX:
111 return TYPE_LENGTH (type) / 2;
113 case TYPE_CODE_STRUCT:
114 case TYPE_CODE_UNION:
115 for (i = 0; i < TYPE_NFIELDS (type); i++)
117 int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
118 while (align < falign)
123 case TYPE_CODE_ARRAY:
124 /* HACK! Structures containing arrays, even small ones, are not
125 elligible for returning in registers. */
128 case TYPE_CODE_TYPEDEF:
129 return mn10300_type_align (check_typedef (type));
132 internal_error (__FILE__, __LINE__, "bad switch");
136 /* MVS note this is deprecated. */
137 /* Should call_function allocate stack space for a struct return? */
140 mn10300_use_struct_convention (int gcc_p, struct type *type)
142 /* Structures bigger than a pair of words can't be returned in
144 if (TYPE_LENGTH (type) > 8)
147 switch (TYPE_CODE (type))
149 case TYPE_CODE_STRUCT:
150 case TYPE_CODE_UNION:
151 /* Structures with a single field are handled as the field
153 if (TYPE_NFIELDS (type) == 1)
154 return mn10300_use_struct_convention (gcc_p,
155 TYPE_FIELD_TYPE (type, 0));
157 /* Structures with word or double-word size are passed in memory, as
158 long as they require at least word alignment. */
159 if (mn10300_type_align (type) >= 4)
164 /* Arrays are addressable, so they're never returned in
165 registers. This condition can only hold when the array is
166 the only field of a struct or union. */
167 case TYPE_CODE_ARRAY:
170 case TYPE_CODE_TYPEDEF:
171 return mn10300_use_struct_convention (gcc_p, check_typedef (type));
178 /* MVS note this is deprecated. */
180 mn10300_store_return_value (struct type *type,
181 struct regcache *regcache, const void *valbuf)
183 struct gdbarch *gdbarch = get_regcache_arch (regcache);
184 int len = TYPE_LENGTH (type);
187 if (TYPE_CODE (type) == TYPE_CODE_PTR)
192 regsz = register_size (gdbarch, reg);
195 regcache_raw_write_part (regcache, reg, 0, len, valbuf);
196 else if (len <= 2 * regsz)
198 regcache_raw_write (regcache, reg, valbuf);
199 gdb_assert (regsz == register_size (gdbarch, reg + 1));
200 regcache_raw_write_part (regcache, reg+1, 0,
201 len - regsz, (char *) valbuf + regsz);
204 internal_error (__FILE__, __LINE__,
205 "Cannot store return value %d bytes long.", len);
208 /* MVS note deprecated. */
210 mn10300_extract_return_value (struct type *type,
211 struct regcache *regcache, void *valbuf)
213 struct gdbarch *gdbarch = get_regcache_arch (regcache);
214 char buf[MAX_REGISTER_SIZE];
215 int len = TYPE_LENGTH (type);
218 if (TYPE_CODE (type) == TYPE_CODE_PTR)
223 regsz = register_size (gdbarch, reg);
226 regcache_raw_read (regcache, reg, buf);
227 memcpy (valbuf, buf, len);
229 else if (len <= 2 * regsz)
231 regcache_raw_read (regcache, reg, buf);
232 memcpy (valbuf, buf, regsz);
233 gdb_assert (regsz == register_size (gdbarch, reg + 1));
234 regcache_raw_read (regcache, reg + 1, buf);
235 memcpy ((char *) valbuf + regsz, buf, len - regsz);
238 internal_error (__FILE__, __LINE__,
239 "Cannot extract return value %d bytes long.", len);
243 register_name (int reg, char **regs, long sizeof_regs)
245 if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
252 mn10300_generic_register_name (int reg)
254 static char *regs[] =
255 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
256 "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
257 "", "", "", "", "", "", "", "",
258 "", "", "", "", "", "", "", "fp"
260 return register_name (reg, regs, sizeof regs);
265 am33_register_name (int reg)
267 static char *regs[] =
268 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
269 "sp", "pc", "mdr", "psw", "lir", "lar", "",
270 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
271 "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
273 return register_name (reg, regs, sizeof regs);
278 mn10300_register_type (struct gdbarch *gdbarch, int reg)
280 return builtin_type_int;
284 mn10300_read_pc (ptid_t ptid)
286 return read_register_pid (E_PC_REGNUM, ptid);
290 mn10300_write_pc (CORE_ADDR val, ptid_t ptid)
292 return write_register_pid (E_PC_REGNUM, val, ptid);
295 /* The breakpoint instruction must be the same size as the smallest
296 instruction in the instruction set.
298 The Matsushita mn10x00 processors have single byte instructions
299 so we need a single byte breakpoint. Matsushita hasn't defined
300 one, so we defined it ourselves. */
302 const static unsigned char *
303 mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
305 static char breakpoint[] = {0xff};
310 /* Function: skip_prologue
311 Return the address of the first inst past the prologue of the function. */
314 mn10300_skip_prologue (CORE_ADDR pc)
316 /* FIXME: not implemented. */
317 /* First approximation, try simply using scan_prologue_using_sal. */
318 return skip_prologue_using_sal (pc);
321 /* Simple frame_unwind_cache.
322 This finds the "extra info" for the frame. */
323 static struct trad_frame_cache *
324 mn10300_frame_unwind_cache (struct frame_info *next_frame,
325 void **this_prologue_cache)
327 struct trad_frame_cache *cache;
329 if (*this_prologue_cache)
330 return (*this_prologue_cache);
332 cache = trad_frame_cache_zalloc (next_frame);
333 trad_frame_set_id (cache,
334 frame_id_build (gdbarch_unwind_sp (current_gdbarch,
336 gdbarch_unwind_pc (current_gdbarch,
339 /* FIXME: The SP isn't the frame base, so this is 0th approximation. */
340 /* FIXME: The A3 reg isn't always the frame register either, so this
341 is 1st approximation. */
342 trad_frame_set_this_base (cache,
343 frame_unwind_register_signed (next_frame,
345 (*this_prologue_cache) = cache;
349 /* Here is a dummy implementation. */
350 static struct frame_id
351 mn10300_dummy_unwind_dummy_id (struct gdbarch *gdbarch,
352 struct frame_info *next_frame)
354 return frame_id_build (0, 0);
357 /* Trad frame implementation. */
359 mn10300_frame_this_id (struct frame_info *next_frame,
360 void **this_prologue_cache,
361 struct frame_id *this_id)
363 struct trad_frame_cache *cache =
364 mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
366 trad_frame_get_id (cache, this_id);
370 mn10300_frame_prev_register (struct frame_info *next_frame,
371 void **this_prologue_cache,
372 int regnum, int *optimizedp,
373 enum lval_type *lvalp, CORE_ADDR *addrp,
374 int *realnump, void *bufferp)
376 struct trad_frame_cache *cache =
377 mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
379 trad_frame_get_register (cache, next_frame, regnum, optimizedp,
380 lvalp, addrp, realnump, bufferp);
382 trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum,
383 optimizedp, lvalp, addrp, realnump, bufferp);
387 static const struct frame_unwind mn10300_frame_unwind = {
389 mn10300_frame_this_id,
390 mn10300_frame_prev_register
394 mn10300_frame_base_address (struct frame_info *next_frame,
395 void **this_prologue_cache)
397 struct trad_frame_cache *cache =
398 mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
400 return trad_frame_get_this_base (cache);
403 static const struct frame_unwind *
404 mn10300_frame_sniffer (struct frame_info *next_frame)
406 return &mn10300_frame_unwind;
409 static const struct frame_base mn10300_frame_base = {
410 &mn10300_frame_unwind,
411 mn10300_frame_base_address,
412 mn10300_frame_base_address,
413 mn10300_frame_base_address
417 mn10300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
421 frame_unwind_unsigned_register (next_frame, E_PC_REGNUM, &pc);
426 mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
430 frame_unwind_unsigned_register (next_frame, E_SP_REGNUM, &sp);
435 mn10300_frame_unwind_init (struct gdbarch *gdbarch)
437 frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
438 frame_unwind_append_sniffer (gdbarch, mn10300_frame_sniffer);
439 frame_base_set_default (gdbarch, &mn10300_frame_base);
440 set_gdbarch_unwind_dummy_id (gdbarch, mn10300_dummy_unwind_dummy_id);
441 set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc);
442 set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp);
445 static struct gdbarch *
446 mn10300_gdbarch_init (struct gdbarch_info info,
447 struct gdbarch_list *arches)
449 struct gdbarch *gdbarch;
451 arches = gdbarch_list_lookup_by_info (arches, &info);
453 return arches->gdbarch;
454 gdbarch = gdbarch_alloc (&info, NULL);
456 switch (info.bfd_arch_info->mach)
459 case bfd_mach_mn10300:
460 set_gdbarch_register_name (gdbarch, mn10300_generic_register_name);
463 set_gdbarch_register_name (gdbarch, am33_register_name);
466 internal_error (__FILE__, __LINE__,
467 "mn10300_gdbarch_init: Unknown mn10300 variant");
472 set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
473 set_gdbarch_register_type (gdbarch, mn10300_register_type);
474 set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
475 set_gdbarch_read_pc (gdbarch, mn10300_read_pc);
476 set_gdbarch_write_pc (gdbarch, mn10300_write_pc);
477 set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
478 set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
480 /* Stack unwinding. */
481 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
483 set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
484 /* decr_pc_after_break? */
486 set_gdbarch_print_insn (gdbarch, print_insn_mn10300);
489 /* MVS Note: at least the first one is deprecated! */
490 set_gdbarch_deprecated_use_struct_convention (gdbarch,
491 mn10300_use_struct_convention);
492 set_gdbarch_store_return_value (gdbarch, mn10300_store_return_value);
493 set_gdbarch_extract_return_value (gdbarch, mn10300_extract_return_value);
495 mn10300_frame_unwind_init (gdbarch);
501 _initialize_mn10300_tdep (void)
503 register_gdbarch_init (bfd_arch_mn10300, mn10300_gdbarch_init);