[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 "gdbcore.h"	/* for write_memory_unsigned_integer */\r
#include "value.h"\r
#include "gdbtypes.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
\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
  CORE_ADDR pc;\r
\r
  if (*this_prologue_cache)\r
    return (*this_prologue_cache);\r
\r
  cache = trad_frame_cache_zalloc (next_frame);\r
  pc = gdbarch_unwind_pc (current_gdbarch, next_frame);\r
  mn10300_analyze_prologue (next_frame, (void **) &cache, pc);\r
\r
  trad_frame_set_id (cache, \r
		     frame_id_build (trad_frame_get_this_base (cache), pc));\r
\r
  (*this_prologue_cache) = cache;\r
  return cache;\r
}\r
\r
/* Here is a dummy implementation.  */\r
static struct frame_id\r
mn10300_unwind_dummy_id (struct gdbarch *gdbarch,\r
			 struct frame_info *next_frame)\r
{\r
  return frame_id_build (frame_sp_unwind (next_frame), \r
			 frame_pc_unwind (next_frame));\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_unwind_dummy_id);\r
  set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc);\r
  set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp);\r
}\r
\r
/* Function: push_dummy_call\r
 *\r
 * Set up machine state for a target call, including\r
 * function arguments, stack, return address, etc.\r
 *\r
 */\r
\r
static CORE_ADDR\r
mn10300_push_dummy_call (struct gdbarch *gdbarch, \r
			 struct value *target_func,\r
			 struct regcache *regcache,\r
			 CORE_ADDR bp_addr, \r
			 int nargs, struct value **args,\r
			 CORE_ADDR sp, \r
			 int struct_return,\r
			 CORE_ADDR struct_addr)\r
{\r
  const int push_size = register_size (gdbarch, E_PC_REGNUM);\r
  int regs_used = struct_return ? 1 : 0;\r
  int len, arg_len; \r
  int stack_offset = 0;\r
  int argnum;\r
  char *val;\r
\r
  /* FIXME temp, don't handle struct args at all.  */\r
  if (struct_return)\r
    error ("Target doesn't handle struct return");\r
\r
  /* This should be a nop, but align the stack just in case something\r
     went wrong.  Stacks are four byte aligned on the mn10300.  */\r
  sp &= ~3;\r
\r
  /* Now make space on the stack for the args.\r
\r
     XXX This doesn't appear to handle pass-by-invisible reference\r
     arguments.  */\r
  for (len = 0, argnum = 0; argnum < nargs; argnum++)\r
    {\r
      arg_len = (TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3;\r
      if (TYPE_CODE (value_type (args[argnum])) == TYPE_CODE_STRUCT)\r
	error ("Target does not handle struct args");\r
      while (regs_used < 2 && arg_len > 0)\r
	{\r
	  regs_used++;\r
	  arg_len -= push_size;\r
	}\r
      len += arg_len;\r
    }\r
\r
  /* Allocate stack space.  */\r
  sp -= len;\r
\r
  regs_used = struct_return ? 1 : 0;\r
  /* Push all arguments onto the stack. */\r
  for (argnum = 0; argnum < nargs; argnum++)\r
    {\r
      /* FIXME what about structs?  */\r
      arg_len = TYPE_LENGTH (value_type (*args));\r
      val = (char *) value_contents (*args);\r
\r
      while (regs_used < 2 && arg_len > 0)\r
	{\r
	  write_register (regs_used, extract_unsigned_integer (val, \r
							       push_size));\r
	  val += push_size;\r
	  arg_len -= push_size;\r
	  regs_used++;\r
	}\r
\r
      while (arg_len > 0)\r
	{\r
	  write_memory (sp + stack_offset, val, push_size);\r
	  arg_len -= push_size;\r
	  val += push_size;\r
	  stack_offset += push_size;\r
	}\r
\r
      args++;\r
    }\r
\r
  /* Make space for the flushback area.  */\r
  sp -= 8;\r
\r
  /* Push the return address that contains the magic breakpoint.  */\r
  sp -= 4;\r
  write_memory_unsigned_integer (sp, push_size, bp_addr);\r
  /* Update $sp.  */\r
  regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);\r
  return sp;\r
}\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
  /* Stage 3 -- get target calls working.  */\r
  set_gdbarch_push_dummy_call (gdbarch, mn10300_push_dummy_call);\r
  /* set_gdbarch_return_value (store, extract) */\r
\r
\r
  mn10300_frame_unwind_init (gdbarch);\r
\r
  return gdbarch;\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
void\r
_initialize_mn10300_tdep (void)\r
{\r
  gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep);\r
}\r
\r
Commit	Line	Data
e02147b1 MS	1	/* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.\r
	2	\r
	3	Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free\r
	4	Software Foundation, Inc.\r
	5	\r
	6	This file is part of GDB.\r
	7	\r
	8	This program is free software; you can redistribute it and/or modify\r
	9	it under the terms of the GNU General Public License as published by\r
	10	the Free Software Foundation; either version 2 of the License, or\r
	11	(at your option) any later version.\r
	12	\r
	13	This program is distributed in the hope that it will be useful,\r
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of\r
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
	16	GNU General Public License for more details.\r
	17	\r
	18	You should have received a copy of the GNU General Public License\r
	19	along with this program; if not, write to the Free Software\r
	20	Foundation, Inc., 59 Temple Place - Suite 330,\r
	21	Boston, MA 02111-1307, USA. */\r
	22	\r
	23	/* MVS Notes:\r
	24	\r
	25	To get from 1.1 to 1.2, add:\r
	26	use_struct_convention\r
	27	store_return_value\r
	28	extract_return_value\r
	29	extract_struct_value_address\r
	30	\r
	31	Make sure to use regcache. */\r
	32	\r
	33	/* MVS Notes:\r
	34	\r
	35	Apparently cannot run without a stub placeholder for unwind_dummy_id. \r
	36	*/\r
	37	\r
	38	/* MVS Notes:\r
	39	\r
	40	To get from 1.2 to 1.3, add:\r
	41	read_pc, write_pc\r
	42	frame_unwind_init\r
	43	struct mn10300_unwind_cache\r
	44	unwind_pc\r
	45	unwind_dummy_id\r
	46	frame_this_id\r
	47	frame_prev_register\r
	48	frame_sniffer (struct mn10300_frame_unwind)\r
	49	*/\r
	50	\r
	51	#include "defs.h"\r
	52	#include "arch-utils.h"\r
	53	#include "dis-asm.h"\r
	54	#include "gdbtypes.h"\r
	55	#include "regcache.h"\r
	56	#include "gdb_string.h"\r
	57	#include "gdb_assert.h"\r
b80b83f3 MS	58	#include "gdbcore.h" /* for write_memory_unsigned_integer */\r
	59	#include "value.h"\r
	60	#include "gdbtypes.h"\r
e02147b1 MS	61	#include "frame.h"\r
	62	#include "frame-unwind.h"\r
	63	#include "frame-base.h"\r
	64	#include "trad-frame.h"\r
	65	#include "symtab.h"\r
	66	#include "dwarf2-frame.h"\r
	67	#include "regcache.h"\r
	68	\r
	69	#include "mn10300-tdep.h"\r
	70	\r
e02147b1 MS	71	\r
	72	/* Compute the alignment required by a type. */\r
	73	\r
	74	static int\r
	75	mn10300_type_align (struct type *type)\r
	76	{\r
	77	int i, align = 1;\r
	78	\r
	79	switch (TYPE_CODE (type))\r
	80	{\r
	81	case TYPE_CODE_INT:\r
	82	case TYPE_CODE_ENUM:\r
	83	case TYPE_CODE_SET:\r
	84	case TYPE_CODE_RANGE:\r
	85	case TYPE_CODE_CHAR:\r
	86	case TYPE_CODE_BOOL:\r
	87	case TYPE_CODE_FLT:\r
	88	case TYPE_CODE_PTR:\r
	89	case TYPE_CODE_REF:\r
	90	return TYPE_LENGTH (type);\r
	91	\r
	92	case TYPE_CODE_COMPLEX:\r
	93	return TYPE_LENGTH (type) / 2;\r
	94	\r
	95	case TYPE_CODE_STRUCT:\r
	96	case TYPE_CODE_UNION:\r
	97	for (i = 0; i < TYPE_NFIELDS (type); i++)\r
	98	{\r
	99	int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));\r
	100	while (align < falign)\r
	101	align <<= 1;\r
	102	}\r
	103	return align;\r
	104	\r
	105	case TYPE_CODE_ARRAY:\r
	106	/* HACK! Structures containing arrays, even small ones, are not\r
	107	elligible for returning in registers. */\r
	108	return 256;\r
	109	\r
	110	case TYPE_CODE_TYPEDEF:\r
	111	return mn10300_type_align (check_typedef (type));\r
	112	\r
	113	default:\r
e2e0b3e5	114	internal_error (__FILE__, __LINE__, _("bad switch"));\r
e02147b1 MS	115	}\r
	116	}\r
	117	\r
	118	/* MVS note this is deprecated. */\r
	119	/* Should call_function allocate stack space for a struct return? */\r
	120	/* gcc_p unused */\r
	121	static int\r
	122	mn10300_use_struct_convention (int gcc_p, struct type *type)\r
	123	{\r
	124	/* Structures bigger than a pair of words can't be returned in\r
	125	registers. */\r
	126	if (TYPE_LENGTH (type) > 8)\r
	127	return 1;\r
	128	\r
	129	switch (TYPE_CODE (type))\r
	130	{\r
	131	case TYPE_CODE_STRUCT:\r
	132	case TYPE_CODE_UNION:\r
	133	/* Structures with a single field are handled as the field\r
	134	itself. */\r
	135	if (TYPE_NFIELDS (type) == 1)\r
	136	return mn10300_use_struct_convention (gcc_p, \r
	137	TYPE_FIELD_TYPE (type, 0));\r
	138	\r
	139	/* Structures with word or double-word size are passed in memory, as\r
	140	long as they require at least word alignment. */\r
	141	if (mn10300_type_align (type) >= 4)\r
	142	return 0;\r
	143	\r
	144	return 1;\r
	145	\r
	146	/* Arrays are addressable, so they're never returned in\r
	147	registers. This condition can only hold when the array is\r
	148	the only field of a struct or union. */\r
	149	case TYPE_CODE_ARRAY:\r
	150	return 1;\r
	151	\r
	152	case TYPE_CODE_TYPEDEF:\r
	153	return mn10300_use_struct_convention (gcc_p, check_typedef (type));\r
	154	\r
	155	default:\r
	156	return 0;\r
	157	}\r
	158	}\r
	159	\r
	160	/* MVS note this is deprecated. */\r
	161	static void\r
	162	mn10300_store_return_value (struct type *type,\r
	163	struct regcache regcache, const void valbuf)\r
	164	{\r
	165	struct gdbarch *gdbarch = get_regcache_arch (regcache);\r
	166	int len = TYPE_LENGTH (type);\r
	167	int reg, regsz;\r
	168	\r
	169	if (TYPE_CODE (type) == TYPE_CODE_PTR)\r
	170	reg = 4;\r
	171	else\r
	172	reg = 0;\r
	173	\r
	174	regsz = register_size (gdbarch, reg);\r
	175	\r
	176	if (len <= regsz)\r
	177	regcache_raw_write_part (regcache, reg, 0, len, valbuf);\r
	178	else if (len <= 2 * regsz)\r
179	{\r
180	regcache_raw_write (regcache, reg, valbuf);\r
181	gdb_assert (regsz == register_size (gdbarch, reg + 1));\r
182	regcache_raw_write_part (regcache, reg+1, 0,\r
183	len - regsz, (char *) valbuf + regsz);\r
184	}\r
185	else\r
186	internal_error (__FILE__, __LINE__,\r
e2e0b3e5	187	_("Cannot store return value %d bytes long."), len);\r
e02147b1 MS	188	}\r
	189	\r
	190	/* MVS note deprecated. */\r
	191	static void\r
	192	mn10300_extract_return_value (struct type *type,\r
	193	struct regcache regcache, void valbuf)\r
	194	{\r
	195	struct gdbarch *gdbarch = get_regcache_arch (regcache);\r
	196	char buf[MAX_REGISTER_SIZE];\r
	197	int len = TYPE_LENGTH (type);\r
	198	int reg, regsz;\r
	199	\r
	200	if (TYPE_CODE (type) == TYPE_CODE_PTR)\r
	201	reg = 4;\r
	202	else\r
	203	reg = 0;\r
	204	\r
	205	regsz = register_size (gdbarch, reg);\r
	206	if (len <= regsz)\r
	207	{\r
	208	regcache_raw_read (regcache, reg, buf);\r
	209	memcpy (valbuf, buf, len);\r
	210	}\r
	211	else if (len <= 2 * regsz)\r
	212	{\r
	213	regcache_raw_read (regcache, reg, buf);\r
	214	memcpy (valbuf, buf, regsz);\r
	215	gdb_assert (regsz == register_size (gdbarch, reg + 1));\r
	216	regcache_raw_read (regcache, reg + 1, buf);\r
	217	memcpy ((char *) valbuf + regsz, buf, len - regsz);\r
	218	}\r
	219	else\r
	220	internal_error (__FILE__, __LINE__,\r
e2e0b3e5	221	_("Cannot extract return value %d bytes long."), len);\r
e02147b1 MS	222	}\r
	223	\r
	224	static char *\r
	225	register_name (int reg, char **regs, long sizeof_regs)\r
	226	{\r
	227	if (reg < 0 \|\| reg >= sizeof_regs / sizeof (regs[0]))\r
	228	return NULL;\r
	229	else\r
	230	return regs[reg];\r
	231	}\r
	232	\r
	233	static const char *\r
	234	mn10300_generic_register_name (int reg)\r
	235	{\r
	236	static char *regs[] =\r
	237	{ "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",\r
	238	"sp", "pc", "mdr", "psw", "lir", "lar", "", "",\r
	239	"", "", "", "", "", "", "", "",\r
	240	"", "", "", "", "", "", "", "fp"\r
	241	};\r
	242	return register_name (reg, regs, sizeof regs);\r
	243	}\r
	244	\r
	245	\r
	246	static const char *\r
	247	am33_register_name (int reg)\r
	248	{\r
	249	static char *regs[] =\r
	250	{ "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",\r
	251	"sp", "pc", "mdr", "psw", "lir", "lar", "",\r
	252	"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",\r
	253	"ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""\r
	254	};\r
	255	return register_name (reg, regs, sizeof regs);\r
	256	}\r
	257	\r
	258	\r
	259	static struct type *\r
	260	mn10300_register_type (struct gdbarch *gdbarch, int reg)\r
	261	{\r
	262	return builtin_type_int;\r
	263	}\r
	264	\r
	265	static CORE_ADDR\r
	266	mn10300_read_pc (ptid_t ptid)\r
	267	{\r
	268	return read_register_pid (E_PC_REGNUM, ptid);\r
	269	}\r
	270	\r
	271	static void\r
	272	mn10300_write_pc (CORE_ADDR val, ptid_t ptid)\r
	273	{\r
	274	return write_register_pid (E_PC_REGNUM, val, ptid);\r
	275	}\r
	276	\r
	277	/* The breakpoint instruction must be the same size as the smallest\r
	278	instruction in the instruction set.\r
	279	\r
	280	The Matsushita mn10x00 processors have single byte instructions\r
	281	so we need a single byte breakpoint. Matsushita hasn't defined\r
	282	one, so we defined it ourselves. */\r
	283	\r
	284	const static unsigned char *\r
	285	mn10300_breakpoint_from_pc (CORE_ADDR bp_addr, int bp_size)\r
286	{\r
287	static char breakpoint[] = {0xff};\r
288	*bp_size = 1;\r
289	return breakpoint;\r
290	}\r
291	\r
292	/* Function: skip_prologue\r
293	Return the address of the first inst past the prologue of the function. */\r
294	\r
295	static CORE_ADDR\r
296	mn10300_skip_prologue (CORE_ADDR pc)\r
297	{\r
298	/* FIXME: not implemented. */\r
299	/* First approximation, try simply using skip_prologue_using_sal. */\r
300	return skip_prologue_using_sal (pc);\r
301	}\r
302	\r
303	/* Simple frame_unwind_cache. \r
304	This finds the "extra info" for the frame. */\r
305	struct trad_frame_cache *\r
306	mn10300_frame_unwind_cache (struct frame_info *next_frame,\r
307	void **this_prologue_cache)\r
308	{\r
309	struct trad_frame_cache *cache;\r
aac71672	310	CORE_ADDR pc;\r
e02147b1 MS	311	\r
	312	if (*this_prologue_cache)\r
	313	return (*this_prologue_cache);\r
	314	\r
	315	cache = trad_frame_cache_zalloc (next_frame);\r
aac71672	316	pc = gdbarch_unwind_pc (current_gdbarch, next_frame);\r
b80b83f3	317	mn10300_analyze_prologue (next_frame, (void **) &cache, pc);\r
aac71672	318	\r
e02147b1	319	trad_frame_set_id (cache, \r
aac71672 MS	320	frame_id_build (trad_frame_get_this_base (cache), pc));\r
aac71672 MS	321	\r
e02147b1 MS	322	(*this_prologue_cache) = cache;\r
	323	return cache;\r
	324	}\r
	325	\r
	326	/* Here is a dummy implementation. */\r
	327	static struct frame_id\r
b80b83f3 MS	328	mn10300_unwind_dummy_id (struct gdbarch *gdbarch,\r
b80b83f3 MS	329	struct frame_info *next_frame)\r
e02147b1	330	{\r
b80b83f3 MS	331	return frame_id_build (frame_sp_unwind (next_frame), \r
b80b83f3 MS	332	frame_pc_unwind (next_frame));\r
e02147b1 MS	333	}\r
	334	\r
	335	/* Trad frame implementation. */\r
	336	static void\r
	337	mn10300_frame_this_id (struct frame_info *next_frame,\r
	338	void **this_prologue_cache,\r
	339	struct frame_id *this_id)\r
	340	{\r
	341	struct trad_frame_cache *cache = \r
	342	mn10300_frame_unwind_cache (next_frame, this_prologue_cache);\r
	343	\r
	344	trad_frame_get_id (cache, this_id);\r
	345	}\r
	346	\r
	347	static void\r
	348	mn10300_frame_prev_register (struct frame_info *next_frame,\r
	349	void **this_prologue_cache,\r
	350	int regnum, int *optimizedp,\r
	351	enum lval_type lvalp, CORE_ADDR addrp,\r
	352	int realnump, void bufferp)\r
	353	{\r
	354	struct trad_frame_cache *cache =\r
	355	mn10300_frame_unwind_cache (next_frame, this_prologue_cache);\r
	356	\r
	357	trad_frame_get_register (cache, next_frame, regnum, optimizedp, \r
	358	lvalp, addrp, realnump, bufferp);\r
	359	/* Or...\r
	360	trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum, \r
	361	optimizedp, lvalp, addrp, realnump, bufferp);\r
	362	*/\r
	363	}\r
	364	\r
	365	static const struct frame_unwind mn10300_frame_unwind = {\r
	366	NORMAL_FRAME,\r
	367	mn10300_frame_this_id, \r
	368	mn10300_frame_prev_register\r
	369	};\r
	370	\r
	371	static CORE_ADDR\r
	372	mn10300_frame_base_address (struct frame_info *next_frame,\r
	373	void **this_prologue_cache)\r
	374	{\r
	375	struct trad_frame_cache *cache = \r
	376	mn10300_frame_unwind_cache (next_frame, this_prologue_cache);\r
	377	\r
	378	return trad_frame_get_this_base (cache);\r
	379	}\r
	380	\r
	381	static const struct frame_unwind *\r
	382	mn10300_frame_sniffer (struct frame_info *next_frame)\r
	383	{\r
	384	return &mn10300_frame_unwind;\r
	385	}\r
	386	\r
	387	static const struct frame_base mn10300_frame_base = {\r
	388	&mn10300_frame_unwind, \r
	389	mn10300_frame_base_address, \r
	390	mn10300_frame_base_address,\r
	391	mn10300_frame_base_address\r
	392	};\r
	393	\r
	394	static CORE_ADDR\r
	395	mn10300_unwind_pc (struct gdbarch gdbarch, struct frame_info next_frame)\r
	396	{\r
397	ULONGEST pc;\r
398	\r
399	frame_unwind_unsigned_register (next_frame, E_PC_REGNUM, &pc);\r
400	return pc;\r
401	}\r
402	\r
403	static CORE_ADDR\r
404	mn10300_unwind_sp (struct gdbarch gdbarch, struct frame_info next_frame)\r
405	{\r
406	ULONGEST sp;\r
407	\r
408	frame_unwind_unsigned_register (next_frame, E_SP_REGNUM, &sp);\r
409	return sp;\r
410	}\r
411	\r
412	static void\r
413	mn10300_frame_unwind_init (struct gdbarch *gdbarch)\r
414	{\r
415	frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);\r
416	frame_unwind_append_sniffer (gdbarch, mn10300_frame_sniffer);\r
417	frame_base_set_default (gdbarch, &mn10300_frame_base);\r
b80b83f3	418	set_gdbarch_unwind_dummy_id (gdbarch, mn10300_unwind_dummy_id);\r
e02147b1 MS	419	set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc);\r
	420	set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp);\r
	421	}\r
	422	\r
b80b83f3 MS	423	/* Function: push_dummy_call\r
	424	*\r
	425	* Set up machine state for a target call, including\r
	426	* function arguments, stack, return address, etc.\r
	427	*\r
	428	*/\r
e02147b1	429	\r
b80b83f3 MS	430	static CORE_ADDR\r
	431	mn10300_push_dummy_call (struct gdbarch *gdbarch, \r
	432	struct value *target_func,\r
	433	struct regcache *regcache,\r
	434	CORE_ADDR bp_addr, \r
	435	int nargs, struct value **args,\r
	436	CORE_ADDR sp, \r
	437	int struct_return,\r
	438	CORE_ADDR struct_addr)\r
e02147b1	439	{\r
b80b83f3 MS	440	const int push_size = register_size (gdbarch, E_PC_REGNUM);\r
	441	int regs_used = struct_return ? 1 : 0;\r
	442	int len, arg_len; \r
	443	int stack_offset = 0;\r
	444	int argnum;\r
	445	char *val;\r
	446	\r
	447	/* FIXME temp, don't handle struct args at all. */\r
	448	if (struct_return)\r
	449	error ("Target doesn't handle struct return");\r
	450	\r
	451	/* This should be a nop, but align the stack just in case something\r
	452	went wrong. Stacks are four byte aligned on the mn10300. */\r
	453	sp &= ~3;\r
	454	\r
	455	/* Now make space on the stack for the args.\r
	456	\r
	457	XXX This doesn't appear to handle pass-by-invisible reference\r
	458	arguments. */\r
	459	for (len = 0, argnum = 0; argnum < nargs; argnum++)\r
	460	{\r
	461	arg_len = (TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3;\r
	462	if (TYPE_CODE (value_type (args[argnum])) == TYPE_CODE_STRUCT)\r
	463	error ("Target does not handle struct args");\r
	464	while (regs_used < 2 && arg_len > 0)\r
	465	{\r
	466	regs_used++;\r
	467	arg_len -= push_size;\r
	468	}\r
	469	len += arg_len;\r
	470	}\r
	471	\r
	472	/* Allocate stack space. */\r
	473	sp -= len;\r
	474	\r
	475	regs_used = struct_return ? 1 : 0;\r
	476	/* Push all arguments onto the stack. */\r
	477	for (argnum = 0; argnum < nargs; argnum++)\r
	478	{\r
	479	/* FIXME what about structs? */\r
	480	arg_len = TYPE_LENGTH (value_type (*args));\r
	481	val = (char ) value_contents (args);\r
	482	\r
	483	while (regs_used < 2 && arg_len > 0)\r
	484	{\r
	485	write_register (regs_used, extract_unsigned_integer (val, \r
	486	push_size));\r
	487	val += push_size;\r
	488	arg_len -= push_size;\r
	489	regs_used++;\r
	490	}\r
	491	\r
	492	while (arg_len > 0)\r
	493	{\r
	494	write_memory (sp + stack_offset, val, push_size);\r
	495	arg_len -= push_size;\r
	496	val += push_size;\r
	497	stack_offset += push_size;\r
	498	}\r
	499	\r
	500	args++;\r
	501	}\r
	502	\r
	503	/* Make space for the flushback area. */\r
504	sp -= 8;\r
505	\r
506	/* Push the return address that contains the magic breakpoint. */\r
507	sp -= 4;\r
508	write_memory_unsigned_integer (sp, push_size, bp_addr);\r
509	/* Update $sp. */\r
510	regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);\r
511	return sp;\r
e02147b1 MS	512	}\r
e02147b1 MS	513	\r
b80b83f3	514	\r
e02147b1 MS	515	static struct gdbarch *\r
	516	mn10300_gdbarch_init (struct gdbarch_info info,\r
	517	struct gdbarch_list *arches)\r
	518	{\r
	519	struct gdbarch *gdbarch;\r
	520	struct gdbarch_tdep *tdep;\r
	521	\r
	522	arches = gdbarch_list_lookup_by_info (arches, &info);\r
	523	if (arches != NULL)\r
	524	return arches->gdbarch;\r
	525	\r
	526	tdep = xmalloc (sizeof (struct gdbarch_tdep));\r
	527	gdbarch = gdbarch_alloc (&info, tdep);\r
	528	\r
	529	switch (info.bfd_arch_info->mach)\r
	530	{\r
	531	case 0:\r
	532	case bfd_mach_mn10300:\r
	533	set_gdbarch_register_name (gdbarch, mn10300_generic_register_name);\r
	534	tdep->am33_mode = 0;\r
	535	break;\r
	536	case bfd_mach_am33:\r
	537	set_gdbarch_register_name (gdbarch, am33_register_name);\r
	538	tdep->am33_mode = 1;\r
	539	break;\r
	540	default:\r
	541	internal_error (__FILE__, __LINE__,\r
e2e0b3e5	542	_("mn10300_gdbarch_init: Unknown mn10300 variant"));\r
e02147b1 MS	543	break;\r
	544	}\r
	545	\r
	546	/* Registers. */\r
	547	set_gdbarch_num_regs (gdbarch, E_NUM_REGS);\r
	548	set_gdbarch_register_type (gdbarch, mn10300_register_type);\r
	549	set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);\r
	550	set_gdbarch_read_pc (gdbarch, mn10300_read_pc);\r
	551	set_gdbarch_write_pc (gdbarch, mn10300_write_pc);\r
	552	set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);\r
	553	set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);\r
	554	\r
	555	/* Stack unwinding. */\r
	556	set_gdbarch_inner_than (gdbarch, core_addr_lessthan);\r
	557	/* Breakpoints. */\r
	558	set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);\r
	559	/* decr_pc_after_break? */\r
	560	/* Disassembly. */\r
	561	set_gdbarch_print_insn (gdbarch, print_insn_mn10300);\r
	562	\r
	563	/* Stage 2 */\r
	564	/* MVS Note: at least the first one is deprecated! */\r
	565	set_gdbarch_deprecated_use_struct_convention (gdbarch, \r
	566	mn10300_use_struct_convention);\r
	567	set_gdbarch_store_return_value (gdbarch, mn10300_store_return_value);\r
	568	set_gdbarch_extract_return_value (gdbarch, mn10300_extract_return_value);\r
b80b83f3 MS	569	\r
	570	/* Stage 3 -- get target calls working. */\r
	571	set_gdbarch_push_dummy_call (gdbarch, mn10300_push_dummy_call);\r
	572	/* set_gdbarch_return_value (store, extract) */\r
	573	\r
e02147b1 MS	574	\r
	575	mn10300_frame_unwind_init (gdbarch);\r
	576	\r
	577	return gdbarch;\r
	578	}\r
	579	\r
b80b83f3 MS	580	/* Dump out the mn10300 specific architecture information. */\r
	581	\r
	582	static void\r
	583	mn10300_dump_tdep (struct gdbarch current_gdbarch, struct ui_file file)\r
	584	{\r
	585	struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);\r
	586	fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",\r
	587	tdep->am33_mode);\r
	588	}\r
	589	\r
e02147b1 MS	590	void\r
	591	_initialize_mn10300_tdep (void)\r
	592	{\r
	593	gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep);\r
	594	}\r
	595	\r