2004-12-10 Michael Snyder <msnyder@redhat.com>

	* 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.

1 files changed, 522 insertions, 0 deletions

diff --git a/gdb/mn10300-tdep.c b/gdb/mn10300-tdep.c
new file mode 100644
index 0000000..9dbbbc7
--- /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);

+}

+