From: Michael Snyder Date: Sat, 11 Dec 2004 02:02:01 +0000 (+0000) Subject: 2004-12-10 Michael Snyder X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=e02147b10c22073d9ab304ce0a95316e86fa8d1c;p=binutils-gdb.git 2004-12-10 Michael Snyder * mn10300-tdep.c: New file. This is a re-implementation of the mn10300 target back-end using the new frame api etc. * mn10300-tdep.h: New file. * config/mn10300/mn10300.mt: New file (or replace old file). * configure.tgt: Add mn10300 target. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index e95f55d6d4e..5273e4c2629 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,11 @@ +2004-12-10 Michael Snyder + + * mn10300-tdep.c: New file. This is a re-implementation of + the mn10300 target back-end using the new frame api etc. + * mn10300-tdep.h: New file. + * config/mn10300/mn10300.mt: New file (or replace old file). + * configure.tgt: Add mn10300 target. + 2004-12-10 Mark Kettenis * configure.host (hppa*-*-hpux11*): Remove. diff --git a/gdb/config/mn10300/mn10300.mt b/gdb/config/mn10300/mn10300.mt new file mode 100644 index 00000000000..a7d8db2e04b --- /dev/null +++ b/gdb/config/mn10300/mn10300.mt @@ -0,0 +1,4 @@ +# Target: Matsushita mn10300 +TDEPFILES= mn10300-tdep.o +SIM_OBS = remote-sim.o +SIM = ../sim/mn10300/libsim.a diff --git a/gdb/configure.tgt b/gdb/configure.tgt index d19784e8f34..3ffc284c474 100644 --- a/gdb/configure.tgt +++ b/gdb/configure.tgt @@ -134,6 +134,8 @@ mips*-*-netbsd* | mips*-*-knetbsd*-gnu) mips64*-*-openbsd*) gdb_target=obsd64 ;; mips*-*-*) gdb_target=embed ;; +mn10300-*-*) gdb_target=mn10300 ;; + powerpc-*-netbsd* | powerpc-*-knetbsd*-gnu) gdb_target=nbsd ;; powerpc-*-openbsd*) gdb_target=obsd ;; diff --git a/gdb/mn10300-tdep.c b/gdb/mn10300-tdep.c new file mode 100644 index 00000000000..9dbbbc7a805 --- /dev/null +++ b/gdb/mn10300-tdep.c @@ -0,0 +1,522 @@ +/* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger. + + Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free + Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* MVS Notes: + + To get from 1.1 to 1.2, add: + use_struct_convention + store_return_value + extract_return_value + extract_struct_value_address + + Make sure to use regcache. */ + +/* MVS Notes: + + Apparently cannot run without a stub placeholder for unwind_dummy_id. +*/ + +/* MVS Notes: + + To get from 1.2 to 1.3, add: + read_pc, write_pc + frame_unwind_init + struct mn10300_unwind_cache + unwind_pc + unwind_dummy_id + frame_this_id + frame_prev_register + frame_sniffer (struct mn10300_frame_unwind) +*/ + +#include "defs.h" +#include "arch-utils.h" +#include "dis-asm.h" +#include "gdbtypes.h" +#include "regcache.h" +#include "gdb_string.h" +#include "gdb_assert.h" +#include "frame.h" +#include "frame-unwind.h" +#include "frame-base.h" +#include "trad-frame.h" +#include "symtab.h" +#include "dwarf2-frame.h" +#include "regcache.h" + +#include "mn10300-tdep.h" + +enum { + E_D0_REGNUM = 0, + E_D1_REGNUM = 1, + E_D2_REGNUM = 2, + E_D3_REGNUM = 3, + E_A0_REGNUM = 4, + E_A1_REGNUM = 5, + E_A2_REGNUM = 6, + E_A3_REGNUM = 7, + E_SP_REGNUM = 8, + E_PC_REGNUM = 9, + E_MDR_REGNUM = 10, + E_PSW_REGNUM = 11, + E_LIR_REGNUM = 12, + E_LAR_REGNUM = 13, + E_MDRQ_REGNUM = 14, + E_E0_REGNUM = 15, + E_MCRH_REGNUM = 26, + E_MCRL_REGNUM = 27, + E_MCVF_REGNUM = 28, + E_NUM_REGS = 32 +}; + + +/* Compute the alignment required by a type. */ + +static int +mn10300_type_align (struct type *type) +{ + int i, align = 1; + + switch (TYPE_CODE (type)) + { + case TYPE_CODE_INT: + case TYPE_CODE_ENUM: + case TYPE_CODE_SET: + case TYPE_CODE_RANGE: + case TYPE_CODE_CHAR: + case TYPE_CODE_BOOL: + case TYPE_CODE_FLT: + case TYPE_CODE_PTR: + case TYPE_CODE_REF: + return TYPE_LENGTH (type); + + case TYPE_CODE_COMPLEX: + return TYPE_LENGTH (type) / 2; + + case TYPE_CODE_STRUCT: + case TYPE_CODE_UNION: + for (i = 0; i < TYPE_NFIELDS (type); i++) + { + int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i)); + while (align < falign) + align <<= 1; + } + return align; + + case TYPE_CODE_ARRAY: + /* HACK! Structures containing arrays, even small ones, are not + elligible for returning in registers. */ + return 256; + + case TYPE_CODE_TYPEDEF: + return mn10300_type_align (check_typedef (type)); + + default: + internal_error (__FILE__, __LINE__, "bad switch"); + } +} + +/* MVS note this is deprecated. */ +/* Should call_function allocate stack space for a struct return? */ +/* gcc_p unused */ +static int +mn10300_use_struct_convention (int gcc_p, struct type *type) +{ + /* Structures bigger than a pair of words can't be returned in + registers. */ + if (TYPE_LENGTH (type) > 8) + return 1; + + switch (TYPE_CODE (type)) + { + case TYPE_CODE_STRUCT: + case TYPE_CODE_UNION: + /* Structures with a single field are handled as the field + itself. */ + if (TYPE_NFIELDS (type) == 1) + return mn10300_use_struct_convention (gcc_p, + TYPE_FIELD_TYPE (type, 0)); + + /* Structures with word or double-word size are passed in memory, as + long as they require at least word alignment. */ + if (mn10300_type_align (type) >= 4) + return 0; + + return 1; + + /* Arrays are addressable, so they're never returned in + registers. This condition can only hold when the array is + the only field of a struct or union. */ + case TYPE_CODE_ARRAY: + return 1; + + case TYPE_CODE_TYPEDEF: + return mn10300_use_struct_convention (gcc_p, check_typedef (type)); + + default: + return 0; + } +} + +/* MVS note this is deprecated. */ +static void +mn10300_store_return_value (struct type *type, + struct regcache *regcache, const void *valbuf) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + int len = TYPE_LENGTH (type); + int reg, regsz; + + if (TYPE_CODE (type) == TYPE_CODE_PTR) + reg = 4; + else + reg = 0; + + regsz = register_size (gdbarch, reg); + + if (len <= regsz) + regcache_raw_write_part (regcache, reg, 0, len, valbuf); + else if (len <= 2 * regsz) + { + regcache_raw_write (regcache, reg, valbuf); + gdb_assert (regsz == register_size (gdbarch, reg + 1)); + regcache_raw_write_part (regcache, reg+1, 0, + len - regsz, (char *) valbuf + regsz); + } + else + internal_error (__FILE__, __LINE__, + "Cannot store return value %d bytes long.", len); +} + +/* MVS note deprecated. */ +static void +mn10300_extract_return_value (struct type *type, + struct regcache *regcache, void *valbuf) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + char buf[MAX_REGISTER_SIZE]; + int len = TYPE_LENGTH (type); + int reg, regsz; + + if (TYPE_CODE (type) == TYPE_CODE_PTR) + reg = 4; + else + reg = 0; + + regsz = register_size (gdbarch, reg); + if (len <= regsz) + { + regcache_raw_read (regcache, reg, buf); + memcpy (valbuf, buf, len); + } + else if (len <= 2 * regsz) + { + regcache_raw_read (regcache, reg, buf); + memcpy (valbuf, buf, regsz); + gdb_assert (regsz == register_size (gdbarch, reg + 1)); + regcache_raw_read (regcache, reg + 1, buf); + memcpy ((char *) valbuf + regsz, buf, len - regsz); + } + else + internal_error (__FILE__, __LINE__, + "Cannot extract return value %d bytes long.", len); +} + +static char * +register_name (int reg, char **regs, long sizeof_regs) +{ + if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0])) + return NULL; + else + return regs[reg]; +} + +static const char * +mn10300_generic_register_name (int reg) +{ + static char *regs[] = + { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3", + "sp", "pc", "mdr", "psw", "lir", "lar", "", "", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "fp" + }; + return register_name (reg, regs, sizeof regs); +} + + +static const char * +am33_register_name (int reg) +{ + static char *regs[] = + { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3", + "sp", "pc", "mdr", "psw", "lir", "lar", "", + "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", + "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", "" + }; + return register_name (reg, regs, sizeof regs); +} + + +static struct type * +mn10300_register_type (struct gdbarch *gdbarch, int reg) +{ + return builtin_type_int; +} + +static CORE_ADDR +mn10300_read_pc (ptid_t ptid) +{ + return read_register_pid (E_PC_REGNUM, ptid); +} + +static void +mn10300_write_pc (CORE_ADDR val, ptid_t ptid) +{ + return write_register_pid (E_PC_REGNUM, val, ptid); +} + +/* The breakpoint instruction must be the same size as the smallest + instruction in the instruction set. + + The Matsushita mn10x00 processors have single byte instructions + so we need a single byte breakpoint. Matsushita hasn't defined + one, so we defined it ourselves. */ + +const static unsigned char * +mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size) +{ + static char breakpoint[] = {0xff}; + *bp_size = 1; + return breakpoint; +} + +/* Function: skip_prologue + Return the address of the first inst past the prologue of the function. */ + +static CORE_ADDR +mn10300_skip_prologue (CORE_ADDR pc) +{ + /* FIXME: not implemented. */ + /* First approximation, try simply using skip_prologue_using_sal. */ + return skip_prologue_using_sal (pc); +} + +/* Simple frame_unwind_cache. + This finds the "extra info" for the frame. */ +struct trad_frame_cache * +mn10300_frame_unwind_cache (struct frame_info *next_frame, + void **this_prologue_cache) +{ + struct trad_frame_cache *cache; + + if (*this_prologue_cache) + return (*this_prologue_cache); + + cache = trad_frame_cache_zalloc (next_frame); + trad_frame_set_id (cache, + frame_id_build (gdbarch_unwind_sp (current_gdbarch, + next_frame), + gdbarch_unwind_pc (current_gdbarch, + next_frame))); + + /* FIXME: The SP isn't the frame base, so this is 0th approximation. */ + /* FIXME: The A3 reg isn't always the frame register either, so this + is 1st approximation. */ + trad_frame_set_this_base (cache, + frame_unwind_register_signed (next_frame, + E_A3_REGNUM)); + (*this_prologue_cache) = cache; + return cache; +} + +/* Here is a dummy implementation. */ +static struct frame_id +mn10300_dummy_unwind_dummy_id (struct gdbarch *gdbarch, + struct frame_info *next_frame) +{ + return frame_id_build (0, 0); +} + +/* Trad frame implementation. */ +static void +mn10300_frame_this_id (struct frame_info *next_frame, + void **this_prologue_cache, + struct frame_id *this_id) +{ + struct trad_frame_cache *cache = + mn10300_frame_unwind_cache (next_frame, this_prologue_cache); + + trad_frame_get_id (cache, this_id); +} + +static void +mn10300_frame_prev_register (struct frame_info *next_frame, + void **this_prologue_cache, + int regnum, int *optimizedp, + enum lval_type *lvalp, CORE_ADDR *addrp, + int *realnump, void *bufferp) +{ + struct trad_frame_cache *cache = + mn10300_frame_unwind_cache (next_frame, this_prologue_cache); + + trad_frame_get_register (cache, next_frame, regnum, optimizedp, + lvalp, addrp, realnump, bufferp); + /* Or... + trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum, + optimizedp, lvalp, addrp, realnump, bufferp); + */ +} + +static const struct frame_unwind mn10300_frame_unwind = { + NORMAL_FRAME, + mn10300_frame_this_id, + mn10300_frame_prev_register +}; + +static CORE_ADDR +mn10300_frame_base_address (struct frame_info *next_frame, + void **this_prologue_cache) +{ + struct trad_frame_cache *cache = + mn10300_frame_unwind_cache (next_frame, this_prologue_cache); + + return trad_frame_get_this_base (cache); +} + +static const struct frame_unwind * +mn10300_frame_sniffer (struct frame_info *next_frame) +{ + return &mn10300_frame_unwind; +} + +static const struct frame_base mn10300_frame_base = { + &mn10300_frame_unwind, + mn10300_frame_base_address, + mn10300_frame_base_address, + mn10300_frame_base_address +}; + +static CORE_ADDR +mn10300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) +{ + ULONGEST pc; + + frame_unwind_unsigned_register (next_frame, E_PC_REGNUM, &pc); + return pc; +} + +static CORE_ADDR +mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame) +{ + ULONGEST sp; + + frame_unwind_unsigned_register (next_frame, E_SP_REGNUM, &sp); + return sp; +} + +static void +mn10300_frame_unwind_init (struct gdbarch *gdbarch) +{ + frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer); + frame_unwind_append_sniffer (gdbarch, mn10300_frame_sniffer); + frame_base_set_default (gdbarch, &mn10300_frame_base); + set_gdbarch_unwind_dummy_id (gdbarch, mn10300_dummy_unwind_dummy_id); + set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc); + set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp); +} + +/* Dump out the mn10300 specific architecture information. */ + +static void +mn10300_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); + fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n", + tdep->am33_mode); +} + +static struct gdbarch * +mn10300_gdbarch_init (struct gdbarch_info info, + struct gdbarch_list *arches) +{ + struct gdbarch *gdbarch; + struct gdbarch_tdep *tdep; + + arches = gdbarch_list_lookup_by_info (arches, &info); + if (arches != NULL) + return arches->gdbarch; + + tdep = xmalloc (sizeof (struct gdbarch_tdep)); + gdbarch = gdbarch_alloc (&info, tdep); + + switch (info.bfd_arch_info->mach) + { + case 0: + case bfd_mach_mn10300: + set_gdbarch_register_name (gdbarch, mn10300_generic_register_name); + tdep->am33_mode = 0; + break; + case bfd_mach_am33: + set_gdbarch_register_name (gdbarch, am33_register_name); + tdep->am33_mode = 1; + break; + default: + internal_error (__FILE__, __LINE__, + "mn10300_gdbarch_init: Unknown mn10300 variant"); + break; + } + + /* Registers. */ + set_gdbarch_num_regs (gdbarch, E_NUM_REGS); + set_gdbarch_register_type (gdbarch, mn10300_register_type); + set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue); + set_gdbarch_read_pc (gdbarch, mn10300_read_pc); + set_gdbarch_write_pc (gdbarch, mn10300_write_pc); + set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM); + set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM); + + /* Stack unwinding. */ + set_gdbarch_inner_than (gdbarch, core_addr_lessthan); + /* Breakpoints. */ + set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc); + /* decr_pc_after_break? */ + /* Disassembly. */ + set_gdbarch_print_insn (gdbarch, print_insn_mn10300); + + /* Stage 2 */ + /* MVS Note: at least the first one is deprecated! */ + set_gdbarch_deprecated_use_struct_convention (gdbarch, + mn10300_use_struct_convention); + set_gdbarch_store_return_value (gdbarch, mn10300_store_return_value); + set_gdbarch_extract_return_value (gdbarch, mn10300_extract_return_value); + + mn10300_frame_unwind_init (gdbarch); + + return gdbarch; +} + +void +_initialize_mn10300_tdep (void) +{ + gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep); +} + diff --git a/gdb/mn10300-tdep.h b/gdb/mn10300-tdep.h new file mode 100644 index 00000000000..7c699d66378 --- /dev/null +++ b/gdb/mn10300-tdep.h @@ -0,0 +1,31 @@ +/* Target-dependent interface for Matsushita MN10300 for GDB, the GNU debugger. + + Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free + Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* mn10300 private data */ +struct gdbarch_tdep +{ + int am33_mode; +#define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode) +}; + +extern CORE_ADDR mn10300_analyze_prologue (struct frame_info *, void **, CORE_ADDR); +extern struct trad_frame_cache *mn10300_frame_unwind_cache (struct frame_info *, void **);