[RFA]: port to Sanyo XStormy16 CPU

[RFA]: port to Sanyo XStormy16 CPU

[Corinna Vinschen]

Hi,

the following patch allows to build GDB for a xstormy16-elf target.
I tested the patch by performing a full build and testsuite run for
a i686-pc-linux-x-xstormy16-elf cross GDB.

Corinna

gdb ChangeLog:

2001-12-10  Corinna Vinschen  <vinschen@redhat.com>

	* Makefile.in: Add support for xstormy16.
	* configure.tgt: Ditto.
	* xstormy16-tdep.c: New file.
	* config/xstormy16/xstormy16.mt: New file.

gdb/testsuite ChangeLog:

2001-12-10  Corinna Vinschen  <vinschen@redhat.com>

	* gdb.asm/asm-source.exp: Add support for xstormy16.
	* gdb.asm/configure.in: Ditto.
	* gdb.asm/configure: Rebuild.
	* gdb.asm/xstormy16.inc: New file.

Index: gdb/Makefile.in
===================================================================
RCS file: /cvs/src/src/gdb/Makefile.in,v
retrieving revision 1.138
diff -u -p -r1.138 Makefile.in
--- Makefile.in	2001/12/08 20:28:44	1.138
+++ Makefile.in	2001/12/10 10:51:30
@@ -1217,7 +1217,9 @@ ALLDEPFILES = 29k-share/udi/udip2soc.c 2
 	vax-tdep.c \
 	vx-share/xdr_ld.c vx-share/xdr_ptrace.c vx-share/xdr_rdb.c \
 	win32-nat.c \
-	xcoffread.c xcoffsolib.c z8k-tdep.c
+	xcoffread.c xcoffsolib.c \
+	xstormy16-tdep.c \
+	z8k-tdep.c
 
 udip2soc.o: $(srcdir)/29k-share/udi/udip2soc.c $(udiheaders)
 	$(CC) -c $(INTERNAL_CFLAGS) $(srcdir)/29k-share/udi/udip2soc.c
@@ -2037,6 +2039,9 @@ sparc-tdep.o: sparc-tdep.c $(floatformat
 	$(arch_utils_h) $(regcache_h)
 
 sparcl-tdep.o: sparcl-tdep.c $(defs_h) $(gdbcore_h) $(target_h) $(regcache_h)
+
+xstormy16-tdep.o: xstormy16-tdep.c $(defs_h) $(value_h) $(inferior_h) \
+	$(symfile_h) $(arch_utils_h) $(regcache_h) $(gdbcore_h)
 
 dsrec.o: dsrec.c $(defs_h) srec.h
 
Index: gdb/configure.tgt
===================================================================
RCS file: /cvs/src/src/gdb/configure.tgt,v
retrieving revision 1.44
diff -u -p -r1.44 configure.tgt
--- configure.tgt	2001/12/01 23:06:46	1.44
+++ configure.tgt	2001/12/10 10:51:30
@@ -278,6 +278,8 @@ sparc86x-*-*)		gdb_target=sparclite ;;
 sparc64-*-linux*)	gdb_target=sp64linux ;;
 sparc64-*-*)		gdb_target=sp64 ;;
 
+xstormy16-*-*)          gdb_target=xstormy16 ;;
+
 vax-*-*)		gdb_target=vax ;;
 
 fr30-*-*)		gdb_target=fr30
@@ -303,4 +305,5 @@ cris)		gdb_multi_arch=yes ;;
 d10v)		gdb_multi_arch=yes ;;
 m68hc11)	gdb_multi_arch=yes ;;
 mn10300)	gdb_multi_arch=yes ;;
+xstormy16)      gdb_multi_arch=yes ;;
 esac
Index: gdb/xstormy16-tdep.c
===================================================================
RCS file: xstormy16-tdep.c
diff -N xstormy16-tdep.c
--- /dev/null	Tue May  5 13:32:27 1998
+++ xstormy16-tdep.c	Mon Dec 10 02:51:31 2001
@@ -0,0 +1,1117 @@
+/* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
+   Copyright 2001, 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.  */
+
+#include "defs.h"
+#include "value.h"
+#include "inferior.h"
+#include "symfile.h"
+#include "arch-utils.h"
+#include "regcache.h"
+#include "gdbcore.h"
+#include "objfiles.h"
+
+#define TYPE_IS_SCALAR(t)	(TYPE_CODE(t) != TYPE_CODE_STRUCT \
+				 && TYPE_CODE(t) != TYPE_CODE_UNION \
+				 && TYPE_CODE(t) != TYPE_CODE_ARRAY)
+
+struct gdbarch_tdep {
+  /* gdbarch target dependent data here. Currently unused for Xstormy16. */
+};
+
+/* Extra info which is saved in each frame_info. */
+struct frame_extra_info {
+  int framesize;
+  int frameless_p;
+};
+
+enum gdb_regnum {
+  /* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
+     Functions will return their values in register R2-R7 as they fit.
+     Otherwise a hidden pointer to an big enough area is given as argument
+     to the function in r2. Further arguments are beginning in r3 then.
+     R13 is used as frame pointer when GCC compiles w/o optimization
+     R14 is used as "PSW", displaying the CPU status.
+     R15 is used implicitely as stack pointer. */
+  E_R0_REGNUM,
+  E_R1_REGNUM,
+  E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM,
+  E_R3_REGNUM, 
+  E_R4_REGNUM,
+  E_R5_REGNUM,
+  E_R6_REGNUM,
+  E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM, 
+  E_R8_REGNUM,
+  E_R9_REGNUM,
+  E_R10_REGNUM,
+  E_R11_REGNUM, 
+  E_R12_REGNUM,
+  E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM,
+  E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM,
+  E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM,
+  E_PC_REGNUM,
+  E_NUM_REGS
+};
+
+/* Size of instructions, registers, etc. */
+enum {
+  xstormy16_inst_size = 2,
+  xstormy16_reg_size = 2,
+  xstormy16_pc_size = 4
+};
+
+/* Size of return datatype which fits into the remaining return registers. */
+#define E_MAX_RETTYPE_SIZE(regnum)	((E_LST_ARG_REGNUM - (regnum) + 1) \
+					* xstormy16_reg_size)
+
+/* Size of return datatype which fits into all return registers. */
+enum {
+  E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE(E_R2_REGNUM)
+};
+
+
+/* Size of all registers as a whole. */
+enum {
+  E_ALL_REGS_SIZE = (E_NUM_REGS - 1) * xstormy16_reg_size + xstormy16_pc_size
+};
+
+/* Function: xstormy16_register_name
+   Returns the name of the standard Xstormy16 register N. */
+
+static char *
+xstormy16_register_name (int regnum)
+{
+  static char *register_names[] = {
+    "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
+    "r8",  "r9",  "r10",  "r11",  "r12",  "r13",
+    "psw", "sp", "pc"
+  };
+
+  if (regnum < 0 ||
+      regnum >= sizeof (register_names) / sizeof (register_names[0]))
+    internal_error (__FILE__, __LINE__,
+		    "xstormy16_register_name: illegal register number %d",
+		    regnum);
+  else
+    return register_names[regnum];
+
+}
+
+/* Function: xstormy16_register_byte 
+   Returns the byte position in the register cache for register N. */
+
+static int
+xstormy16_register_byte (int regnum)
+{
+  if (regnum < 0 || regnum >= E_NUM_REGS)
+    internal_error (__FILE__, __LINE__, 
+		    "xstormy16_register_byte: illegal register number %d",
+		    regnum);
+  else
+    /* All registers occupy 2 bytes in the regcache except for PC
+       which is the last one. Therefore the byte position is still
+       simply a multiple of 2. */
+    return regnum * xstormy16_reg_size;
+}
+
+/* Function: xstormy16_register_raw_size
+   Returns the number of bytes occupied by the register on the target. */
+
+static int 
+xstormy16_register_raw_size (int regnum)
+{
+  if (regnum < 0 || regnum >= E_NUM_REGS)
+    internal_error (__FILE__, __LINE__, 
+		    "xstormy16_register_raw_size: illegal register number %d",
+		    regnum);
+  /* Only the PC has 4 Byte, all other registers 2 Byte. */
+  else if (regnum == E_PC_REGNUM)
+    return xstormy16_pc_size;
+  else
+    return xstormy16_reg_size;
+}
+
+/* Function: xstormy16_register_virtual_size
+   Returns the number of bytes occupied by the register as represented
+   internally by gdb. */
+
+static int 
+xstormy16_register_virtual_size (int regnum)
+{
+  return xstormy16_register_raw_size (regnum);
+}
+
+/* Function: xstormy16_reg_virtual_type 
+   Returns the default type for register N. */
+
+static struct type *
+xstormy16_reg_virtual_type (int regnum)
+{
+  if (regnum < 0 || regnum >= E_NUM_REGS)
+    internal_error (__FILE__, __LINE__, 
+		    "xstormy16_register_virtual_type: illegal register number %d",
+		    regnum);
+  else if (regnum == E_PC_REGNUM)
+    return builtin_type_uint32;
+  else
+    return builtin_type_uint16;
+}
+
+/* Function: xstormy16_get_saved_register
+   Find a register's saved value on the call stack. */
+
+static void
+xstormy16_get_saved_register (char *raw_buffer, 
+			      int *optimized, 
+			      CORE_ADDR *addrp,
+			      struct frame_info *fi, 
+			      int regnum,
+			      enum lval_type *lval)
+{
+  generic_get_saved_register (raw_buffer, optimized, addrp, 
+			      fi, regnum, lval);
+}
+
+/* Function: xstormy16_extract_return_value
+   Copy the function's return value into VALBUF. 
+   This function is called only in the context of "target function calls",
+   ie. when the debugger forces a function to be called in the child, and
+   when the debugger forces a function to return prematurely via the
+   "return" command. */
+
+static void
+xstormy16_extract_return_value (struct type *type, char *regbuf, char *valbuf)
+{
+  CORE_ADDR return_buffer;
+  int offset = 0;
+
+  if (TYPE_IS_SCALAR (type)
+      && TYPE_LENGTH (type) <= E_MAX_RETTYPE_SIZE_IN_REGS)
+    {
+      /* Scalar return values of <= 12 bytes are returned in 
+	 E_1ST_ARG_REGNUM to E_LST_ARG_REGNUM. */
+      memcpy (valbuf, 
+	      &regbuf[REGISTER_BYTE (E_1ST_ARG_REGNUM)] + offset,
+	      TYPE_LENGTH (type));
+    }
+  else
+    {
+      /* Aggregates and return values > 12 bytes are returned in memory,
+         pointed to by R2. */
+      return_buffer = 
+	extract_address (regbuf + REGISTER_BYTE (E_PTR_RET_REGNUM), 
+			 REGISTER_RAW_SIZE (E_PTR_RET_REGNUM));
+
+      read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
+    }
+}
+
+/* Function: xstormy16_push_arguments
+   Setup the function arguments for GDB to call a function in the inferior.
+   Called only in the context of a target function call from the debugger.
+   Returns the value of the SP register after the args are pushed.
+*/
+
+static CORE_ADDR
+xstormy16_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
+			  int struct_return, CORE_ADDR struct_addr)
+{
+  CORE_ADDR stack_dest = sp;
+  int argreg = E_1ST_ARG_REGNUM;
+  int i, j;
+  int typelen, slacklen;
+  char *val;
+
+  /* If struct_return is true, then the struct return address will
+     consume one argument-passing register.  */
+  if (struct_return)
+    argreg++;
+
+  /* Arguments are passed in R2-R7 as they fit. If an argument doesn't
+     fit in the remaining registers we're switching over to the stack.
+     No argument is put on stack partially and as soon as we switched
+     over to stack no further argument is put in a register even if it
+     would fit in the remaining unused registers. */
+  for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
+    {
+      typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
+      if (typelen > E_MAX_RETTYPE_SIZE (argreg))
+        break;
+
+      /* Put argument into registers wordwise. */
+      val = VALUE_CONTENTS (args[i]);
+      for (j = 0; j < typelen; j += xstormy16_reg_size)
+	write_register (argreg++,
+			extract_unsigned_integer (val + j,
+			typelen - j == 1 ? 1 : xstormy16_reg_size));
+    }
+
+  /* Align SP */
+  if (stack_dest & 1)
+    ++stack_dest;
+
+  /* Loop backwards through remaining arguments and push them on the stack,
+     wordaligned. */
+  for (j = nargs - 1; j >= i; j--)
+    {
+      typelen  = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[j]));
+      slacklen = typelen & 1;
+      val = alloca (typelen + slacklen);
+      memcpy (val, VALUE_CONTENTS (args[j]), typelen);
+      memset (val + typelen, 0, slacklen);
+
+      /* Now write this data to the stack. The stack grows upwards. */
+      write_memory (stack_dest, val, typelen + slacklen);
+      stack_dest += typelen + slacklen;
+    }
+  
+  /* And that should do it.  Return the new stack pointer. */
+  return stack_dest;
+}
+
+/* Function: xstormy16_push_return_address (pc)
+   Setup the return address for GDB to call a function in the inferior.
+   Called only in the context of a target function call from the debugger.
+   Returns the value of the SP register when the operation is finished
+   (which may or may not be the same as before).
+*/
+
+CORE_ADDR
+xstormy16_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
+{
+  unsigned char buf[xstormy16_pc_size];
+
+  store_unsigned_integer (buf, xstormy16_pc_size, CALL_DUMMY_ADDRESS ());
+  write_memory (sp, buf, xstormy16_pc_size);
+  return sp + xstormy16_pc_size;
+}
+
+/* Function: xstormy16_pop_frame
+   Destroy the innermost (Top-Of-Stack) stack frame, restoring the 
+   machine state that was in effect before the frame was created. 
+   Used in the contexts of the "return" command, and of 
+   target function calls from the debugger.
+*/
+
+static void
+xstormy16_pop_frame (void)
+{
+  struct frame_info *fi = get_current_frame ();
+  int i;
+
+  if (fi == NULL)
+    return;					/* paranoia */
+
+  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+    {
+      generic_pop_dummy_frame ();
+    }
+  else
+    {
+      /* Restore the saved regs. */
+      for (i = 0; i < NUM_REGS; i++)
+	if (fi->saved_regs[i])
+	  {
+	    if (i == SP_REGNUM)
+	      write_register (i, fi->saved_regs[i]);
+	    else if (i == E_PC_REGNUM)
+	      write_register (i, read_memory_integer (fi->saved_regs[i], 
+						      xstormy16_pc_size));
+	    else
+	      write_register (i, read_memory_integer (fi->saved_regs[i], 
+						      xstormy16_reg_size));
+	  }
+      /* Restore the PC */
+      write_register (PC_REGNUM, FRAME_SAVED_PC (fi));
+      flush_cached_frames ();
+    }
+  return;
+}
+
+/* Function: xstormy16_store_struct_return
+   Copy the (struct) function return value to its destined location. 
+   Called only in the context of a target function call from the debugger.
+*/
+
+static void
+xstormy16_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
+{
+  write_register (E_PTR_RET_REGNUM, addr);
+}
+
+/* Function: xstormy16_store_return_value
+   Copy the function return value from VALBUF into the 
+   proper location for a function return. 
+   Called only in the context of the "return" command.
+*/
+
+static void
+xstormy16_store_return_value (struct type *type, char *valbuf)
+{
+  CORE_ADDR return_buffer;
+  char buf[xstormy16_reg_size];
+
+  if (TYPE_IS_SCALAR (type) && TYPE_LENGTH (type) == 1)
+    {
+      /* Add leading zeros to the value. */
+      memset (buf, 0, xstormy16_reg_size);
+      memcpy (buf, valbuf, 1);
+      write_register_gen (E_1ST_ARG_REGNUM, buf);
+    }
+  else if (TYPE_IS_SCALAR (type) &&
+           TYPE_LENGTH (type) <= E_MAX_RETTYPE_SIZE_IN_REGS)
+    write_register_bytes (REGISTER_BYTE (E_1ST_ARG_REGNUM), 
+			  valbuf, TYPE_LENGTH (type));
+  else
+    {
+      return_buffer = read_register (E_PTR_RET_REGNUM);
+      write_memory (return_buffer, valbuf, TYPE_LENGTH (type));
+    }
+}
+
+/* Function: xstormy16_extract_struct_value_address
+   Returns the address in which a function should return a struct value. 
+   Used in the contexts of the "return" command, and of 
+   target function calls from the debugger.
+*/
+
+static CORE_ADDR
+xstormy16_extract_struct_value_address (char *regbuf)
+{
+  return extract_address (regbuf +
+                          xstormy16_register_byte (E_PTR_RET_REGNUM),
+			  xstormy16_reg_size);
+}
+
+/* Function: xstormy16_use_struct_convention 
+   Returns non-zero if the given struct type will be returned using
+   a special convention, rather than the normal function return method. 
+   7sed in the contexts of the "return" command, and of 
+   target function calls from the debugger.
+*/
+
+static int
+xstormy16_use_struct_convention (int gcc_p, struct type *type)
+{
+  return !TYPE_IS_SCALAR (type)
+  	 || TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
+}
+
+/* Function: frame_saved_register
+   Returns the value that regnum had in frame fi
+   (saved in fi or in one of its children).  
+*/
+
+static CORE_ADDR
+xstormy16_frame_saved_register (struct frame_info *fi, int regnum)
+{
+  int size = xstormy16_register_raw_size (regnum);
+  char *buf = (char *) alloca (size);
+
+  generic_get_saved_register (buf, NULL, NULL, fi, regnum, NULL);
+  return (CORE_ADDR) extract_unsigned_integer (buf, size);
+}
+
+/* Function: xstormy16_scan_prologue
+   Decode the instructions within the given address range.
+   Decide when we must have reached the end of the function prologue.
+   If a frame_info pointer is provided, fill in its saved_regs etc.
+
+   Returns the address of the first instruction after the prologue. 
+*/
+
+static CORE_ADDR
+xstormy16_scan_prologue (CORE_ADDR start_addr, 
+			 CORE_ADDR end_addr, 
+			 struct frame_info *fi)
+{
+  CORE_ADDR sp = 0, fp = 0;
+  CORE_ADDR next_addr;
+  ULONGEST inst, inst2;
+  LONGEST offset;
+  int regnum;
+
+  if (fi)
+    {
+      /* In a call dummy, don't touch the frame. */
+      if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+        return start_addr;
+
+      /* Grab the frame-relative values of SP and FP, needed below. 
+         The frame_saved_register function will find them on the
+         stack or in the registers as appropriate. */
+      sp = xstormy16_frame_saved_register (fi, E_SP_REGNUM);
+      fp = xstormy16_frame_saved_register (fi, E_FP_REGNUM);
+
+      /* Initialize framesize with size of PC put on stack by CALLF inst. */
+      fi->extra_info->framesize = xstormy16_pc_size;
+    }
+  for (next_addr = start_addr;
+       next_addr < end_addr;
+       next_addr += xstormy16_inst_size)
+    {
+      inst = read_memory_unsigned_integer (next_addr, xstormy16_inst_size);
+      inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
+					    xstormy16_inst_size);
+
+      if (inst >= 0x0082 && inst <= 0x008d)	/* push r2 .. push r13 */
+	{
+	  if (fi)
+	    {
+	      regnum = inst & 0x000f;
+	      fi->saved_regs[regnum] = fi->extra_info->framesize;
+	      fi->extra_info->framesize += xstormy16_reg_size;
+	    }
+	}
+
+      /* optional stack allocation for args and local vars <= 4 byte */
+      else if (inst == 0x301f || inst == 0x303f)	/* inc r15, #0x1/#0x3 */
+	{
+	  if (fi)	/* Record the frame size. */
+	    fi->extra_info->framesize += ((inst & 0x0030) >> 4) + 1;
+	}
+
+      /* optional stack allocation for args and local vars > 4 && < 16 byte */
+      else if ((inst & 0xff0f) == 0x510f)	/* 51Hf   add r15, #0xH */
+	{
+	  if (fi)	/* Record the frame size. */
+	    fi->extra_info->framesize += (inst & 0x00f0) >> 4;
+	}
+
+      /* optional stack allocation for args and local vars >= 16 byte */
+      else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH  add r15, #0xH */
+	{
+	  if (fi)	/* Record the frame size. */
+	    fi->extra_info->framesize += inst2;
+	  next_addr += xstormy16_inst_size;
+	}
+
+      else if (inst == 0x46fd)	/* mov r13, r15 */
+	{
+	  if (fi)	/* Record that the frame pointer is in use. */
+	    fi->extra_info->frameless_p = 0;
+	}
+
+      /* optional copying of args in r2-r7 to r10-r13 */
+      /* Probably only in optimized case but legal action for prologue */
+      else if ((inst & 0xff00) == 0x4600 /* 46SD   mov rD, rS */
+	       && (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
+	       && (inst & 0x000f) >= 0x00a0 && (inst & 0x000f) <= 0x000d)
+	;
+
+      /* optional copying of args in r2-r7 to stack */
+      /* 72DS HHHH   mov.b (rD, 0xHHHH), r(S-8) (bit3 always 1, bit2-0 = reg) */
+      /* 73DS HHHH   mov.w (rD, 0xHHHH), r(S-8) */
+      else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
+	{
+	  if (fi)
+	    {
+	      regnum = inst & 0x0007;
+	      /* Only 12 of 16 bits of the argument are used for the
+	         signed offset. */
+	      offset = (LONGEST) (inst2 & 0x0fff);
+	      if (offset & 0x0800)
+	        offset -= 0x1000;
+
+	      fi->saved_regs[regnum] = fi->extra_info->framesize + offset;
+	    }
+	  next_addr += xstormy16_inst_size;
+	}
+
+#if 0
+      /* 2001-08-10: Not part of the prologue anymore due to change in
+         ABI. r8 and r9 are not used for argument passing anymore. */
+
+      /* optional copying of r8, r9 to stack */
+      /* 46S7; 73Df HHHH   mov.w r7,rS; mov.w (rD, 0xHHHH), r7 D=8,9; S=13,15 */
+      /* 46S7; 72df HHHH   mov.w r7,rS; mov.b (rD, 0xHHHH), r7 D=8,9; S=13,15 */
+      else if ((inst & 0xffef) == 0x4687 && (inst2 & 0xfedf) == 0x72df)
+	{
+	  next_addr += xstormy16_inst_size;
+	  if (fi)
+	    {
+	      regnum = (inst & 0x00f0) >> 4;
+	      inst = inst2;
+	      inst2 = read_memory_unsigned_integer (next_addr
+						    + xstormy16_inst_size,
+						    xstormy16_inst_size);
+	      /* Only 12 of 16 bits of the argument are used for the
+	         signed offset. */
+	      offset = (LONGEST) (inst2 & 0x0fff);
+	      if (offset & 0x0800)
+	        offset -= 0x1000;
+
+	      fi->saved_regs[regnum] = fi->extra_info->framesize + offset;
+	    }
+	  next_addr += xstormy16_inst_size;
+	}
+#endif
+
+      else		/* Not a prologue instruction. */
+        break;
+    }
+
+  if (fi)
+    {
+      /* Special handling for the "saved" address of the SP:
+         The SP is of course never saved on the stack at all, so
+         by convention what we put here is simply the previous 
+         _value_ of the SP (as opposed to an address where the
+         previous value would have been pushed).  */
+      if (fi->extra_info->frameless_p)
+        {
+	  fi->saved_regs[E_SP_REGNUM] = sp - fi->extra_info->framesize;
+	  fi->frame = sp;
+	}
+      else
+        {
+	  fi->saved_regs[E_SP_REGNUM] = fp - fi->extra_info->framesize;
+	  fi->frame = fp;
+	}
+
+      /* So far only offsets to the beginning of the frame are
+         saved in the saved_regs. Now we now the relation between
+	 sp, fp and framesize. We know the beginning of the frame
+	 so we can translate the register offsets to real addresses. */
+      for (regnum = 0; regnum < E_SP_REGNUM; ++regnum)
+	if (fi->saved_regs[regnum])
+	  fi->saved_regs[regnum] += fi->saved_regs[E_SP_REGNUM];
+
+      /* Save address of PC on stack. */
+      fi->saved_regs[E_PC_REGNUM] = fi->saved_regs[E_SP_REGNUM];
+    }
+
+  return next_addr;
+}
+
+/* Function: xstormy16_skip_prologue
+   If the input address is in a function prologue, 
+   returns the address of the end of the prologue;
+   else returns the input address.
+
+   Note: the input address is likely to be the function start, 
+   since this function is mainly used for advancing a breakpoint
+   to the first line, or stepping to the first line when we have
+   stepped into a function call.  */
+
+static CORE_ADDR
+xstormy16_skip_prologue (CORE_ADDR pc)
+{
+  CORE_ADDR func_addr = 0, func_end = 0;
+  char *func_name;
+
+  if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
+    {
+      struct symtab_and_line sal;
+      struct symbol *sym;
+
+      /* Found a function.  */
+      sym = lookup_symbol (func_name, NULL, VAR_NAMESPACE, NULL, NULL);
+      if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
+        {
+	  /* Don't use this trick for assembly source files. */
+	  sal = find_pc_line (func_addr, 0);
+	  if (sal.end && sal.end < func_end)
+	    {
+	      /* Found a line number, use it as end of prologue.  */
+	      return sal.end;
+	    }
+	}
+      /* No useable line symbol.  Use prologue parsing method. */
+      return xstormy16_scan_prologue (func_addr, func_end, NULL);
+    }
+
+  /* No function symbol -- just return the PC. */
+
+  return (CORE_ADDR) pc;
+}
+
+/* The epilogue is defined here as the area at the end of a function,
+   either on the `ret' instruction itself or after an instruction which
+   destroys the function's stack frame. */
+static int
+xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
+{
+  CORE_ADDR addr, func_addr = 0, func_end = 0;
+
+  if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
+    {
+      ULONGEST inst, inst2;
+      CORE_ADDR addr = func_end - xstormy16_inst_size;
+
+      /* The Xstormy16 epilogue is max. 14 bytes long. */
+      if (pc < func_end - 7 * xstormy16_inst_size)
+        return 0;
+
+      /* Check if we're on a `ret' instruction.  Otherwise it's
+         too dangerous to proceed. */
+      inst = read_memory_unsigned_integer (addr, xstormy16_inst_size);
+      if (inst != 0x0003)
+        return 0;
+
+      while ((addr -= xstormy16_inst_size) >= func_addr)
+	{
+	  inst = read_memory_unsigned_integer (addr, xstormy16_inst_size);
+	  if (inst >= 0x009a && inst <= 0x009d)	/* pop r10...r13 */
+	    continue;
+	  if (inst == 0x305f || inst == 0x307f)	/* dec r15, #0x1/#0x3 */
+	    break;
+	  inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
+	  					xstormy16_inst_size);
+	  if (inst2 == 0x314f && inst >= 0x8000) /* add r15, neg. value */
+	    {
+	      addr -= xstormy16_inst_size;
+	      break;
+	    }
+	  return 0;
+	}
+      if (pc > addr)
+        return 1;
+    }
+  return 0;
+}
+
+/* Function: xstormy16_frame_init_saved_regs
+   Set up the 'saved_regs' array.
+   This is a data structure containing the addresses on the stack 
+   where each register has been saved, for each stack frame.  
+   Registers that have not been saved will have zero here.
+   The stack register is special: rather than the address where the 
+   stack register has been saved, saved_regs[SP_REGNUM] will have the
+   actual value of the previous frame's stack register. 
+
+   This function may be called in any context where the saved register
+   values may be needed (backtrace, frame_info, get_saved_register).
+   On many targets, it is called directly by init_extra_frame_info, 
+   in part because the information may be needed immediately by 
+   frame_chain.
+*/
+
+static void
+xstormy16_frame_init_saved_regs (struct frame_info *fi)
+{
+  CORE_ADDR func_addr, func_end;
+
+  if (!fi->saved_regs)
+    {
+      frame_saved_regs_zalloc (fi);
+
+      /* Find the beginning of this function, so we can analyze its
+         prologue. */
+      if (find_pc_partial_function (fi->pc, NULL, &func_addr, &func_end))
+        xstormy16_scan_prologue (func_addr, fi->pc, fi);
+      /* Else we're out of luck (can't debug completely stripped code). 
+         FIXME. */
+    }
+}
+
+/* Function: xstormy16_frame_saved_pc
+   Returns the return address for the selected frame. 
+   Called by frame_info, frame_chain_valid, and sometimes by
+   get_prev_frame.
+*/
+
+static CORE_ADDR
+xstormy16_frame_saved_pc (struct frame_info *fi)
+{
+  CORE_ADDR saved_pc;
+
+  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+    {
+      saved_pc = generic_read_register_dummy (fi->pc, fi->frame, E_PC_REGNUM);
+    }
+  else
+    {
+      saved_pc = read_memory_unsigned_integer (fi->saved_regs[E_PC_REGNUM],
+					       xstormy16_pc_size);
+    }
+
+  return saved_pc;
+}
+
+/* Function: xstormy16_init_extra_frame_info
+   This is the constructor function for the frame_info struct, 
+   called whenever a new frame_info is created (from create_new_frame,
+   and from get_prev_frame).
+*/
+
+static void
+xstormy16_init_extra_frame_info (int fromleaf, struct frame_info *fi)
+{
+  if (!fi->extra_info)
+    {
+      fi->extra_info = (struct frame_extra_info *)
+        frame_obstack_alloc (sizeof (struct frame_extra_info));
+      fi->extra_info->framesize = 0;
+      fi->extra_info->frameless_p = 1;  /* Default frameless, detect framed */
+
+      /* By default, the fi->frame is set to the value of the FP reg by gdb.
+         This may not always be right; we may be in a frameless function,
+         or we may be in the prologue, before the FP has been set up.
+         Unfortunately, we can't make this determination without first
+         calling scan_prologue, and we can't do that unles we know the
+         fi->pc.  */
+
+      if (!fi->pc)
+        {
+          /* Sometimes we are called from get_prev_frame without
+             the PC being set up first.  Long history, don't ask.
+             Fortunately this will never happen from the outermost
+             frame, so we should be able to get the saved pc from
+             the next frame. */
+          if (fi->next)
+            fi->pc = xstormy16_frame_saved_pc (fi->next);
+        }
+
+      /* Take care of the saved_regs right here (non-lazy). */
+      xstormy16_frame_init_saved_regs (fi);
+    }
+}
+
+/* Function: xstormy16_frame_chain
+   Returns a pointer to the stack frame of the calling function.
+   Called only from get_prev_frame.  Needed for backtrace, "up", etc.
+*/
+
+static CORE_ADDR
+xstormy16_frame_chain (struct frame_info *fi)
+{
+  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+    {
+      /* Call dummy's frame is the same as caller's.  */
+      return fi->frame;
+    }
+  else
+    {
+      /* Return computed offset from this frame's fp. */
+      return fi->frame - fi->extra_info->framesize;
+    }
+}
+
+static int
+xstormy16_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
+{
+  return chain < 0x8000 && FRAME_SAVED_PC (thisframe) >= 0x8000 &&
+	 (thisframe->extra_info->frameless_p ||
+	  thisframe->frame - thisframe->extra_info->framesize == chain);
+}
+
+/* Function: xstormy16_saved_pc_after_call
+   Returns the previous PC immediately after a function call.
+   This function is meant to bypass the regular get_saved_register
+   mechanism, ie. it is meant to work even if the frame isn't complete. 
+   Called by step_over_function, and sometimes by get_prev_frame.
+*/
+
+static CORE_ADDR
+xstormy16_saved_pc_after_call (struct frame_info *ignore)
+{
+  CORE_ADDR sp, pc, tmp;
+
+  sp = read_register (E_SP_REGNUM) - xstormy16_pc_size;
+  pc = read_memory_integer (sp, xstormy16_pc_size);
+
+  /* Skip over jump table entry if necessary.  */
+  if ((tmp = SKIP_TRAMPOLINE_CODE (pc)))
+    pc = tmp;
+
+  return pc;
+}
+
+static unsigned char *
+xstormy16_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+{
+  static unsigned char breakpoint[] = {0x06, 0x0};
+  *lenptr = sizeof (breakpoint);
+  return breakpoint;
+}
+
+/* Given a pointer to a jump table entry, return the address
+   of the function it jumps to.  Return 0 if not found. */
+static CORE_ADDR
+xstormy16_resolve_jmp_table_entry (CORE_ADDR faddr)
+{
+  struct obj_section *faddr_sect = find_pc_section (faddr);
+
+  if (faddr_sect)
+    {
+      LONGEST inst, inst2, addr;
+      char buf[2 * xstormy16_inst_size];
+
+      /* Return faddr if it's not pointing into the jump table. */
+      if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
+	return faddr;
+
+      if (!target_read_memory (faddr, buf, sizeof buf))
+	{
+	  inst = extract_unsigned_integer (buf, xstormy16_inst_size);
+	  inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
+					    xstormy16_inst_size);
+	  addr = inst2 << 8 | (inst & 0xff);
+	  return addr;
+	}
+    }
+  return 0;
+}
+
+/* Given a function's address, attempt to find (and return) the
+   address of the corresponding jump table entry.  Return 0 if
+   not found. */
+static CORE_ADDR
+xstormy16_find_jmp_table_entry (CORE_ADDR faddr)
+{
+  struct obj_section *faddr_sect = find_pc_section (faddr);
+
+  if (faddr_sect)
+    {
+      struct obj_section *osect;
+
+      /* Return faddr if it's already a pointer to a jump table entry. */
+      if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
+	return faddr;
+
+      ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
+	{
+	  if (!strcmp (osect->the_bfd_section->name, ".plt"))
+	    break;
+	}
+
+      if (osect < faddr_sect->objfile->sections_end)
+	{
+	  CORE_ADDR addr;
+	  for (addr = osect->addr;
+	       addr < osect->endaddr;
+	       addr += 2 * xstormy16_inst_size)
+	    {
+	      int status;
+	      LONGEST inst, inst2, faddr2;
+	      char buf[2 * xstormy16_inst_size];
+
+	      if (target_read_memory (addr, buf, sizeof buf))
+		return 0;
+	      inst = extract_unsigned_integer (buf, xstormy16_inst_size);
+	      inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
+						xstormy16_inst_size);
+	      faddr2 = inst2 << 8 | (inst & 0xff);
+	      if (faddr == faddr2)
+		return addr;
+	    }
+	}
+    }
+  return 0;
+}
+
+static CORE_ADDR
+xstormy16_skip_trampoline_code (CORE_ADDR pc)
+{
+  int tmp = xstormy16_resolve_jmp_table_entry (pc);
+
+  if (tmp && tmp != pc)
+    return tmp;
+  return 0;
+}
+
+static int
+xstormy16_in_solib_call_trampoline (CORE_ADDR pc, char *name)
+{
+  return xstormy16_skip_trampoline_code (pc) != 0;
+}
+
+static CORE_ADDR
+xstormy16_pointer_to_address (struct type *type, void *buf)
+{
+  enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
+  CORE_ADDR addr = extract_address (buf, TYPE_LENGTH (type));
+
+  if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
+    {
+      CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (addr);
+      if (addr2)
+        addr = addr2;
+    }
+
+  return addr;
+}
+
+static void
+xstormy16_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
+{
+  enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
+
+  if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
+    {
+      CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (addr);
+      if (addr2)
+	addr = addr2;
+    }
+  store_address (buf, TYPE_LENGTH (type), addr);
+}
+
+static CORE_ADDR
+xstormy16_stack_align (CORE_ADDR addr)
+{
+  if (addr & 1)
+    ++addr;
+  return addr;
+}
+
+void
+xstormy16_save_dummy_frame_tos (CORE_ADDR sp)
+{
+  generic_save_dummy_frame_tos (sp - xstormy16_pc_size);
+}
+
+/* Function: xstormy16_gdbarch_init
+   Initializer function for the xstormy16 gdbarch vector.
+   Called by gdbarch.  Sets up the gdbarch vector(s) for this target. */
+
+static struct gdbarch *
+xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
+{
+  static LONGEST call_dummy_words[1] = {0};
+  struct gdbarch_tdep *tdep = NULL;
+  struct gdbarch *gdbarch;
+
+  /* find a candidate among the list of pre-declared architectures. */
+  arches = gdbarch_list_lookup_by_info (arches, &info);
+  if (arches != NULL)
+    return (arches->gdbarch);
+
+#if 0
+  tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
+#endif
+
+  gdbarch = gdbarch_alloc (&info, 0);
+
+  /*
+   * Basic register fields and methods.
+   */
+
+  set_gdbarch_num_regs        (gdbarch, E_NUM_REGS);
+  set_gdbarch_num_pseudo_regs (gdbarch, 0);
+  set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
+  set_gdbarch_fp_regnum (gdbarch, E_FP_REGNUM);
+  set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
+  set_gdbarch_register_name         (gdbarch, xstormy16_register_name);
+  set_gdbarch_register_size         (gdbarch, xstormy16_reg_size);
+  set_gdbarch_register_bytes        (gdbarch, E_ALL_REGS_SIZE);
+  set_gdbarch_register_byte         (gdbarch, xstormy16_register_byte);
+  set_gdbarch_register_raw_size     (gdbarch, xstormy16_register_raw_size);
+  set_gdbarch_max_register_raw_size (gdbarch, xstormy16_pc_size);
+  set_gdbarch_register_virtual_size (gdbarch, xstormy16_register_raw_size);
+  set_gdbarch_max_register_virtual_size (gdbarch, 4);
+  set_gdbarch_register_virtual_type (gdbarch, xstormy16_reg_virtual_type);
+
+  /*
+   * Frame Info
+   */
+  set_gdbarch_init_extra_frame_info (gdbarch, xstormy16_init_extra_frame_info);
+  set_gdbarch_frame_init_saved_regs (gdbarch, xstormy16_frame_init_saved_regs);
+  set_gdbarch_frame_chain (gdbarch, xstormy16_frame_chain);
+  set_gdbarch_get_saved_register (gdbarch, xstormy16_get_saved_register);
+  set_gdbarch_saved_pc_after_call (gdbarch, xstormy16_saved_pc_after_call);
+  set_gdbarch_frame_saved_pc (gdbarch, xstormy16_frame_saved_pc);
+  set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
+  set_gdbarch_frame_chain_valid (gdbarch, xstormy16_frame_chain_valid);
+  set_gdbarch_frame_args_address (gdbarch, default_frame_address);
+  set_gdbarch_frame_locals_address (gdbarch, default_frame_address);
+
+  set_gdbarch_in_function_epilogue_p (gdbarch, xstormy16_in_function_epilogue_p);
+
+  /* 
+   * Miscelany
+   */
+  /* Stack grows up. */
+  set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
+  /* PC stops zero byte after a trap instruction
+     (which means: exactly on trap instruction). */
+  set_gdbarch_decr_pc_after_break (gdbarch, 0);
+  /* This value is almost never non-zero... */
+  set_gdbarch_function_start_offset (gdbarch, 0);
+  /* This value is almost never non-zero... */
+  set_gdbarch_frame_args_skip (gdbarch, 0);
+  /* OK to default this value to 'unknown'. */
+  set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
+
+  /* W/o prototype, coerce float args to double. */
+  set_gdbarch_coerce_float_to_double (gdbarch,
+				      standard_coerce_float_to_double);
+
+  /*
+   * Call Dummies
+   * 
+   * These values and methods are used when gdb calls a target function.  */
+  set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
+  set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
+  set_gdbarch_push_return_address (gdbarch, xstormy16_push_return_address);
+  set_gdbarch_extract_return_value (gdbarch, xstormy16_extract_return_value);
+  set_gdbarch_push_arguments (gdbarch, xstormy16_push_arguments);
+  set_gdbarch_pop_frame (gdbarch, xstormy16_pop_frame);
+  set_gdbarch_store_struct_return (gdbarch, xstormy16_store_struct_return);
+  set_gdbarch_store_return_value (gdbarch, xstormy16_store_return_value);
+  set_gdbarch_extract_struct_value_address (gdbarch, 
+				    xstormy16_extract_struct_value_address);
+  set_gdbarch_use_struct_convention (gdbarch, xstormy16_use_struct_convention);
+  set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
+  set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
+  set_gdbarch_call_dummy_start_offset (gdbarch, 0);
+  set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
+  set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
+  set_gdbarch_call_dummy_length (gdbarch, 0);
+  set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
+  set_gdbarch_call_dummy_p (gdbarch, 1);
+  set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
+  set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+  set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
+  /* set_gdbarch_call_dummy_stack_adjust */
+  set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
+  set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
+
+  set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+  set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
+  set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
+  set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
+
+  set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
+  set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
+
+  set_gdbarch_stack_align (gdbarch, xstormy16_stack_align);
+  set_gdbarch_extra_stack_alignment_needed (gdbarch, 0);
+
+  set_gdbarch_save_dummy_frame_tos (gdbarch, xstormy16_save_dummy_frame_tos);
+
+  set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
+
+  set_gdbarch_in_solib_call_trampoline (gdbarch, xstormy16_in_solib_call_trampoline);
+
+  return gdbarch;
+}
+
+/* Function: _initialize_xstormy16_tdep
+   Initializer function for the Sanyo Xstormy16a module.
+   Called by gdb at start-up. */
+
+void 
+_initialize_xstormy16_tdep (void)
+{
+  extern int print_insn_xstormy16 ();
+
+  register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
+  tm_print_insn = print_insn_xstormy16;
+}
Index: gdb/config/xstormy16/xstormy16.mt
===================================================================
RCS file: xstormy16.mt
diff -N xstormy16.mt
--- /dev/null	Tue May  5 13:32:27 1998
+++ xstormy16.mt	Mon Dec 10 02:51:31 2001
@@ -0,0 +1,5 @@
+# Target: Sanyo Xstormy16a processor
+TDEPFILES = xstormy16-tdep.o
+# No simulator objects or libraries are needed -- target uses SID.
+# SIM_OBS = remote-sim.o
+# SIM = ../sim/xstormy16/libsim.a
Index: gdb/testsuite/gdb.asm/asm-source.exp
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.asm/asm-source.exp,v
retrieving revision 1.12
diff -u -p -r1.12 asm-source.exp
--- asm-source.exp	2001/12/07 02:50:02	1.12
+++ asm-source.exp	2001/12/10 10:51:33
@@ -50,6 +50,11 @@ if [istarget "m32r*-*"] then {
 if [istarget "sparc-*-*"] then {
     set asm-arch sparc
 }
+if [istarget "xstormy16-*-*"] then {
+    set asm-arch xstormy16
+    set asm-flags "-gdwarf2 -I${srcdir}/${subdir} -I${objdir}/${subdir}"
+    set link-flags "-L${objdir}/../../gcc"
+}
 if { "${asm-arch}" == "" } {
     gdb_suppress_entire_file "Assembly source test -- not implemented for this target."
 }
Index: gdb/testsuite/gdb.asm/configure
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.asm/configure,v
retrieving revision 1.6
diff -u -p -r1.6 configure
--- configure	2001/12/01 01:13:27	1.6
+++ configure	2001/12/10 10:51:33
@@ -28,7 +28,6 @@ program_suffix=NONE
 program_transform_name=s,x,x,
 silent=
 site=
-sitefile=
 srcdir=
 target=NONE
 verbose=
@@ -143,7 +142,6 @@ Configuration:
   --help                  print this message
   --no-create             do not create output files
   --quiet, --silent       do not print \`checking...' messages
-  --site-file=FILE        use FILE as the site file
   --version               print the version of autoconf that created configure
 Directory and file names:
   --prefix=PREFIX         install architecture-independent files in PREFIX
@@ -314,11 +312,6 @@ EOF
   -site=* | --site=* | --sit=*)
     site="$ac_optarg" ;;
 
-  -site-file | --site-file | --site-fil | --site-fi | --site-f)
-    ac_prev=sitefile ;;
-  -site-file=* | --site-file=* | --site-fil=* | --site-fi=* | --site-f=*)
-    sitefile="$ac_optarg" ;;
-
   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
     ac_prev=srcdir ;;
   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
@@ -484,16 +477,12 @@ fi
 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 
 # Prefer explicitly selected file to automatically selected ones.
-if test -z "$sitefile"; then
-  if test -z "$CONFIG_SITE"; then
-    if test "x$prefix" != xNONE; then
-      CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
-    else
-      CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
-    fi
+if test -z "$CONFIG_SITE"; then
+  if test "x$prefix" != xNONE; then
+    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+  else
+    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
   fi
-else
-  CONFIG_SITE="$sitefile"
 fi
 for ac_site_file in $CONFIG_SITE; do
   if test -r "$ac_site_file"; then
@@ -582,7 +571,7 @@ else { echo "configure: error: can not r
 fi
 
 echo $ac_n "checking host system type""... $ac_c" 1>&6
-echo "configure:586: checking host system type" >&5
+echo "configure:575: checking host system type" >&5
 
 host_alias=$host
 case "$host_alias" in
@@ -603,7 +592,7 @@ host_os=`echo $host | sed 's/^\([^-]*\)-
 echo "$ac_t""$host" 1>&6
 
 echo $ac_n "checking target system type""... $ac_c" 1>&6
-echo "configure:607: checking target system type" >&5
+echo "configure:596: checking target system type" >&5
 
 target_alias=$target
 case "$target_alias" in
@@ -621,7 +610,7 @@ target_os=`echo $target | sed 's/^\([^-]
 echo "$ac_t""$target" 1>&6
 
 echo $ac_n "checking build system type""... $ac_c" 1>&6
-echo "configure:625: checking build system type" >&5
+echo "configure:614: checking build system type" >&5
 
 build_alias=$build
 case "$build_alias" in
@@ -651,6 +640,7 @@ s390-*-*) archinc=s390.inc ;;
 i[3456]86*) archinc=i386.inc ;;
 m32r*-*) archinc=m32r.inc ;;
 sparc-*-*) archinc=sparc.inc ;;
+xstormy16-*-*) archinc=xstormy16.inc ;;
 esac
 
 
Index: gdb/testsuite/gdb.asm/configure.in
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.asm/configure.in,v
retrieving revision 1.6
diff -u -p -r1.6 configure.in
--- configure.in	2001/12/01 01:13:27	1.6
+++ configure.in	2001/12/10 10:51:33
@@ -20,6 +20,7 @@ s390-*-*) archinc=s390.inc ;;
 i[[3456]]86*) archinc=i386.inc ;;
 m32r*-*) archinc=m32r.inc ;;
 sparc-*-*) archinc=sparc.inc ;;
+xstormy16-*-*) archinc=xstormy16.inc ;;
 esac
 AC_LINK_FILES($archinc,arch.inc)
 
Index: gdb/testsuite/gdb.asm/xstormy16.inc
===================================================================
RCS file: xstormy16.inc
diff -N xstormy16.inc
--- /dev/null	Tue May  5 13:32:27 1998
+++ xstormy16.inc	Mon Dec 10 02:51:33 2001
@@ -0,0 +1,34 @@
+	comment "subroutine prologue"
+	.macro gdbasm_enter
+	push r13
+	mov r13,r15
+	.endm
+
+	comment "subroutine epilogue"
+	.macro gdbasm_leave
+	pop r13
+	ret
+	.endm
+
+	.macro gdbasm_call subr
+	callf \subr
+	.endm
+
+	.macro gdbasm_several_nops
+	add r0,#0
+	add r0,#0
+	add r0,#0
+	add r0,#0
+	.endm
+
+	comment "exit (0)"
+	.macro gdbasm_exit0
+	mov.w r2,#0
+	halt
+	.endm
+
+	comment "crt0 startup"
+	.macro gdbasm_startup
+	mov r15,#2
+	.endm
+

-- 
Corinna Vinschen
Cygwin Developer
Red Hat, Inc.
mailto:vinschen@redhat.com

Re: [RFA]: port to Sanyo XStormy16 CPU

[Andrew Cagney]

> Corinna
> 
> gdb ChangeLog:
> 
> 2001-12-10  Corinna Vinschen  <vinschen@redhat.com>
> 
> * Makefile.in: Add support for xstormy16.
> 	* configure.tgt: Ditto.
> 	* xstormy16-tdep.c: New file.
> 	* config/xstormy16/xstormy16.mt: New file.
> 
> gdb/testsuite ChangeLog:


Yes.  Your code is fine.  The comments are very much appreciated.

Just the usual style things:  can I suggest making macro's like 
TYPE_IS_SCALAR functions; can you please put the .c files through 
gdb/gdb_indent.sh so it matches GDB's indentation style.


> 2001-12-10  Corinna Vinschen  <vinschen@redhat.com>
> 
> * gdb.asm/asm-source.exp: Add support for xstormy16.
> 	* gdb.asm/configure.in: Ditto.
> 	* gdb.asm/configure: Rebuild.
> 	* gdb.asm/xstormy16.inc: New file.
> 


This bit would follow on as obvious.  Nice to see a target including its 
assembler test case!

Andrew

Re: [RFA]: port to Sanyo XStormy16 CPU

[Corinna Vinschen]

On Tue, Dec 11, 2001 at 03:16:19PM -0800, Andrew Cagney wrote:
> > Corinna
> > 
> > gdb ChangeLog:
> > 
> > 2001-12-10  Corinna Vinschen  <vinschen@redhat.com>
> > 
> > * Makefile.in: Add support for xstormy16.
> > 	* configure.tgt: Ditto.
> > 	* xstormy16-tdep.c: New file.
> > 	* config/xstormy16/xstormy16.mt: New file.
> > 
> > gdb/testsuite ChangeLog:
> 
> 
> Yes.  Your code is fine.  The comments are very much appreciated.
> 
> Just the usual style things:  can I suggest making macro's like 
> TYPE_IS_SCALAR functions; can you please put the .c files through 
> gdb/gdb_indent.sh so it matches GDB's indentation style.

I've rearranged the macro TYPE_IS_SCALAR() to be a function called
xstormy16_type_is_scalar and I ran gdb_indent.sh on xstormy16-tdep.c.

Thanks for the approval, I've applied everything.

Corinna

-- 
Corinna Vinschen
Cygwin Developer
Red Hat, Inc.
mailto:vinschen@redhat.com

Re: [RFA]: port to Sanyo XStormy16 CPU

[Corinna Vinschen]

On Thu, Dec 13, 2001 at 02:44:37PM +0100, Corinna Vinschen wrote:
> On Tue, Dec 11, 2001 at 03:16:19PM -0800, Andrew Cagney wrote:
> > > Corinna
> > > 
> > > gdb ChangeLog:
> > > 
> > > 2001-12-10  Corinna Vinschen  <vinschen@redhat.com>
> > > 
> > > * Makefile.in: Add support for xstormy16.
> > > 	* configure.tgt: Ditto.
> > > 	* xstormy16-tdep.c: New file.
> > > 	* config/xstormy16/xstormy16.mt: New file.
> > > 
> > > gdb/testsuite ChangeLog:
> > 
> > 
> > Yes.  Your code is fine.  The comments are very much appreciated.
> > 
> > Just the usual style things:  can I suggest making macro's like 
> > TYPE_IS_SCALAR functions; can you please put the .c files through 
> > gdb/gdb_indent.sh so it matches GDB's indentation style.
> 
> I've rearranged the macro TYPE_IS_SCALAR() to be a function called
> xstormy16_type_is_scalar and I ran gdb_indent.sh on xstormy16-tdep.c.
> 
> Thanks for the approval, I've applied everything.

Uh, careful question:  Do I have to add myself as XStormy16 maintainer
to the MAINTAINERS file now?

Corinna

Re: [RFA]: port to Sanyo XStormy16 CPU

[Andrew Cagney]

> Just the usual style things:  can I suggest making macro's like 
>> TYPE_IS_SCALAR functions; can you please put the .c files through 
>> gdb/gdb_indent.sh so it matches GDB's indentation style.
> 
> 
> I've rearranged the macro TYPE_IS_SCALAR() to be a function called
> xstormy16_type_is_scalar and I ran gdb_indent.sh on xstormy16-tdep.c.
> 
> Thanks for the approval, I've applied everything.


Corinna, thanks.

The next thing is to keep an eye on http://sources.redhat.com/gdb/ari/ 
to see if the files cause any regressions (any should show up tomorrow).

One thing that has already appeared is some file name problems in the 
opcodes directory.  They can be fixed by tweeking 
gdb/config/djgpp/fnchange.lst (?) - the tweek is considered obvious.

enjoy,
Andrew

Re: [RFA]: port to Sanyo XStormy16 CPU

[Corinna Vinschen]

On Thu, Dec 13, 2001 at 12:38:58PM -0800, Andrew Cagney wrote:
> One thing that has already appeared is some file name problems in the 
> opcodes directory.  They can be fixed by tweeking 
> gdb/config/djgpp/fnchange.lst (?) - the tweek is considered obvious.

Done.

Corinna