2005-02-11 Andrew Cagney <cagney@gnu.org>

[deliverable/binutils-gdb.git] / gdb / mn10300-tdep.c

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