* Makefile.in, config.in, configure, configure.in: New files.

* gencode.c, interp.c, mn10300_sim.h, simops.c: New files.

Skeleton mn10300 simulator

sim/.Sanitize

@@ -54,6 +54,7 @@ erc32
 h8300
 h8500
 mips
+mn10300
 ppc
 sh
 w65

sim/configure.in

@@ -56,6 +56,11 @@ case "${target}" in
 	sim_target=mips
 	only_if_gcc=yes
 	;;
+  mn10300*-*-*)
+	# The mn10300 simulator can only be compiled by gcc.
+	sim_target=mn10300
+	only_if_gcc=yes
+	;;
   sh*-*-*)		sim_target=sh ;;
   powerpc*-*-eabi* | powerpc*-*-solaris* | powerpc*-*-sysv4* | powerpc*-*-elf* | powerpc*-*-linux* )
 	# The PowerPC simulator uses the GCC extension long long as well as

sim/mn10300/.Sanitize

@@ -0,0 +1,40 @@
+# .Sanitize for devo/sim/mn10300.
+
+# Each directory to survive its way into a release will need a file
+# like this one called "./.Sanitize".  All keyword lines must exist,
+# and must exist in the order specified by this file.  Each directory
+# in the tree will be processed, top down, in the following order.
+
+# Hash started lines like this one are comments and will be deleted
+# before anything else is done.  Blank lines will also be squashed
+# out.
+
+# The lines between the "Do-first:" line and the "Things-to-keep:"
+# line are executed as a /bin/sh shell script before anything else is
+# done in this directory.
+
+Do-first:
+
+# All files listed between the "Things-to-keep:" line and the
+# "Files-to-sed:" line will be kept.  All other files will be removed.
+# Directories listed in this section will have their own Sanitize
+# called.  Directories not listed will be removed in their entirety
+# with rm -rf.
+
+Things-to-keep:
+
+ChangeLog
+Makefile.in
+config.in
+configure
+configure.in
+mn10300_sim.h
+gencode.c
+interp.c
+simops.c
+
+Things-to-lose:
+
+Do-last:
+
+# End of file.

sim/mn10300/ChangeLog

@@ -0,0 +1,5 @@
+Mon Nov 25 12:46:38 1996  Jeffrey A Law  (law@cygnus.com)
+
+	* Makefile.in, config.in, configure, configure.in: New files.
+	* gencode.c, interp.c, mn10300_sim.h, simops.c: New files.
+	

sim/mn10300/configure.in

@@ -0,0 +1,9 @@
+dnl Process this file with autoconf to produce a configure script.
+AC_PREREQ(2.5)dnl
+AC_INIT(Makefile.in)
+
+SIM_AC_COMMON
+
+AC_CHECK_HEADERS(unistd.h)
+
+SIM_AC_OUTPUT

sim/mn10300/gencode.c

@@ -0,0 +1,143 @@
+#include "mn10300_sim.h"
+
+static void write_header PARAMS ((void));
+static void write_opcodes PARAMS ((void));
+static void write_template PARAMS ((void));
+
+long Opcodes[512];
+static int curop=0;
+
+int
+main (argc, argv)
+     int argc;
+     char *argv[];
+{
+  if ((argc > 1) && (strcmp (argv[1], "-h") == 0))
+    write_header();
+  else if ((argc > 1) && (strcmp (argv[1], "-t") == 0))
+    write_template ();
+  else
+    write_opcodes();
+  return 0;
+}
+
+
+static void
+write_header ()
+{
+  struct mn10300_opcode *opcode;
+
+  for (opcode = (struct mn10300_opcode *)mn10300_opcodes; opcode->name; opcode++)
+    printf("void OP_%X PARAMS ((void));\t\t/* %s */\n",
+	   opcode->opcode, opcode->name);
+}
+
+
+/* write_template creates a file all required functions, ready */
+/* to be filled out */
+
+static void
+write_template ()
+{
+  struct mn10300_opcode *opcode;
+  int i,j;
+
+  printf ("#include \"mn10300_sim.h\"\n");
+  printf ("#include \"simops.h\"\n");
+
+  for (opcode = (struct mn10300_opcode *)mn10300_opcodes; opcode->name; opcode++)
+    {
+      printf("/* %s */\nvoid\nOP_%X ()\n{\n", opcode->name, opcode->opcode);
+	  
+      /* count operands */
+      j = 0;
+      for (i = 0; i < 6; i++)
+	{
+	  int flags = mn10300_operands[opcode->operands[i]].flags;
+
+	  if (flags)
+	    j++;
+	}
+      switch (j)
+	{
+	case 0:
+	  printf ("printf(\"   %s\\n\");\n", opcode->name);
+	  break;
+	case 1:
+	  printf ("printf(\"   %s\\t%%x\\n\", OP[0]);\n", opcode->name);
+	  break;
+	case 2:
+	  printf ("printf(\"   %s\\t%%x,%%x\\n\",OP[0],OP[1]);\n",
+		  opcode->name);
+	  break;
+	case 3:
+	  printf ("printf(\"   %s\\t%%x,%%x,%%x\\n\",OP[0],OP[1],OP[2]);\n",
+		  opcode->name);
+	  break;
+	default:
+	  fprintf (stderr,"Too many operands: %d\n", j);
+	}
+      printf ("}\n\n");
+    }
+}
+
+static void
+write_opcodes ()
+{
+  struct mn10300_opcode *opcode;
+  int i, j;
+  int numops;
+  
+  /* write out opcode table */
+  printf ("#include \"mn10300_sim.h\"\n");
+  printf ("#include \"simops.h\"\n\n");
+  printf ("struct simops Simops[] = {\n");
+  
+  for (opcode = (struct mn10300_opcode *)mn10300_opcodes; opcode->name; opcode++)
+    {
+      printf ("  { 0x%x,0x%x,OP_%X,",
+	      opcode->opcode, opcode->mask, opcode->opcode);
+      
+      Opcodes[curop++] = opcode->opcode;
+
+      /* count operands */
+      j = 0;
+      for (i = 0; i < 6; i++)
+	{
+	  int flags = mn10300_operands[opcode->operands[i]].flags;
+
+	  if (flags)
+	    j++;
+	}
+      printf ("%d,{",j);
+	  
+      j = 0;
+      numops = 0;
+      for (i = 0; i < 6; i++)
+	{
+	  int flags = mn10300_operands[opcode->operands[i]].flags;
+	  int shift = mn10300_operands[opcode->operands[i]].shift;
+
+	  if (flags)
+	    {
+	      if (j)
+		printf (", ");
+	      printf ("%d,%d,%d", shift,
+		      mn10300_operands[opcode->operands[i]].bits,flags);
+	      j = 1;
+	      numops++;
+	    }
+	}
+
+      switch (numops)
+	{
+	case 0:
+	  printf ("0,0,0");
+	case 1:
+	  printf (",0,0,0");
+	}
+
+      printf ("}},\n");
+    }
+  printf ("{ 0,0,NULL,0,{0,0,0,0,0,0}},\n};\n");
+}

sim/mn10300/interp.c

@@ -0,0 +1,394 @@
+#include <signal.h>
+#include "sysdep.h"
+#include "bfd.h"
+
+#include "mn10300_sim.h"
+
+#ifndef INLINE
+#ifdef __GNUC__
+#define INLINE inline
+#else
+#define INLINE
+#endif
+#endif
+
+host_callback *mn10300_callback;
+int mn10300_debug;
+
+uint32 OP[4];
+
+static struct hash_entry *lookup_hash PARAMS ((uint32 ins));
+static long hash PARAMS ((long));
+static void init_system PARAMS ((void));
+
+#define MAX_HASH  63
+
+struct hash_entry
+{
+  struct hash_entry *next;
+  long opcode;
+  long mask;
+  struct simops *ops;
+};
+
+struct hash_entry hash_table[MAX_HASH+1];
+
+
+static INLINE long 
+hash(insn)
+     long insn;
+{
+/* XXX */
+}
+
+static struct hash_entry *
+lookup_hash (ins)
+     uint32 ins;
+{
+  struct hash_entry *h;
+
+  h = &hash_table[hash(ins)];
+
+  while ((ins & h->mask) != h->opcode)
+    {
+      if (h->next == NULL)
+	{
+	  (*mn10300_callback->printf_filtered) (mn10300_callback, "ERROR looking up hash for 0x%x, PC=0x%x\n", ins, PC);
+	  exit(1);
+	}
+      h = h->next;
+    }
+  return (h);
+}
+
+/* FIXME These would more efficient to use than load_mem/store_mem,
+   but need to be changed to use the memory map.  */
+
+uint8
+get_byte (x)
+     uint8 *x;
+{
+  return *x;
+}
+
+uint16
+get_half (x)
+     uint8 *x;
+{
+  uint8 *a = x;
+  return (a[1] << 8) + (a[0]);
+}
+
+uint32
+get_word (x)
+      uint8 *x;
+{
+  uint8 *a = x;
+  return (a[3]<<24) + (a[2]<<16) + (a[1]<<8) + (a[0]);
+}
+
+void
+put_byte (addr, data)
+     uint8 *addr;
+     uint8 data;
+{
+  uint8 *a = addr;
+  a[0] = data;
+}
+
+void
+put_half (addr, data)
+     uint8 *addr;
+     uint16 data;
+{
+  uint8 *a = addr;
+  a[0] = data & 0xff;
+  a[1] = (data >> 8) & 0xff;
+}
+
+void
+put_word (addr, data)
+     uint8 *addr;
+     uint32 data;
+{
+  uint8 *a = addr;
+  a[0] = data & 0xff;
+  a[1] = (data >> 8) & 0xff;
+  a[2] = (data >> 16) & 0xff;
+  a[3] = (data >> 24) & 0xff;
+}
+
+
+uint32
+load_mem (addr, len)
+     SIM_ADDR addr;
+     int len;
+{
+  uint8 *p = addr + State.mem;
+
+  switch (len)
+    {
+    case 1:
+      return p[0];
+    case 2:
+      return p[1] << 8 | p[0];
+    case 4:
+      return p[3] << 24 | p[2] << 16 | p[1] << 8 | p[0];
+    default:
+      abort ();
+    }
+}
+
+void
+store_mem (addr, len, data)
+     SIM_ADDR addr;
+     int len;
+     uint32 data;
+{
+  uint8 *p = addr + State.mem;
+
+  switch (len)
+    {
+    case 1:
+      p[0] = data;
+      return;
+    case 2:
+      p[0] = data;
+      p[1] = data >> 8;
+      return;
+    case 4:
+      p[0] = data;
+      p[1] = data >> 8;
+      p[2] = data >> 16;
+      p[3] = data >> 24;
+      return;
+    default:
+      abort ();
+    }
+}
+
+void
+sim_size (power)
+     int power;
+
+{
+  if (State.mem)
+    free (State.mem);
+
+  State.mem = (uint8 *) calloc (1,  1 << power);
+  if (!State.mem)
+    {
+      (*mn10300_callback->printf_filtered) (mn10300_callback, "Allocation of main memory failed.\n");
+      exit (1);
+    }
+}
+
+static void
+init_system ()
+{
+  if (!State.mem)
+    sim_size(18);
+}
+
+int
+sim_write (addr, buffer, size)
+     SIM_ADDR addr;
+     unsigned char *buffer;
+     int size;
+{
+  int i;
+
+  init_system ();
+
+  for (i = 0; i < size; i++)
+    store_mem (addr + i, 1, buffer[i]);
+
+  return size;
+}
+
+void
+sim_open (args)
+     char *args;
+{
+  struct simops *s;
+  struct hash_entry *h;
+  if (args != NULL)
+    {
+#ifdef DEBUG
+      if (strcmp (args, "-t") == 0)
+	mn10300_debug = DEBUG;
+      else
+#endif
+	(*mn10300_callback->printf_filtered) (mn10300_callback, "ERROR: unsupported option(s): %s\n",args);
+    }
+
+  /* put all the opcodes in the hash table */
+  for (s = Simops; s->func; s++)
+    {
+      h = &hash_table[hash(s->opcode)];
+      
+      /* go to the last entry in the chain */
+      while (h->next)
+	  h = h->next;
+
+      if (h->ops)
+	{
+	  h->next = calloc(1,sizeof(struct hash_entry));
+	  h = h->next;
+	}
+      h->ops = s;
+      h->mask = s->mask;
+      h->opcode = s->opcode;
+    }
+}
+
+
+void
+sim_close (quitting)
+     int quitting;
+{
+  /* nothing to do */
+}
+
+void
+sim_set_profile (n)
+     int n;
+{
+  (*mn10300_callback->printf_filtered) (mn10300_callback, "sim_set_profile %d\n", n);
+}
+
+void
+sim_set_profile_size (n)
+     int n;
+{
+  (*mn10300_callback->printf_filtered) (mn10300_callback, "sim_set_profile_size %d\n", n);
+}
+
+void
+sim_resume (step, siggnal)
+     int step, siggnal;
+{
+  uint32 inst, opcode;
+  reg_t oldpc;
+  struct interrupt_generator *intgen;
+
+  if (step)
+    State.exception = SIGTRAP;
+  else
+    State.exception = 0;
+
+  do
+    {
+      /* Fetch the current instruction.  */
+      inst = RLW (PC);
+      oldpc = PC;
+      opcode = (inst & 0x07e0) >> 5;
+
+      /* Decode the opcode field. */
+      if ((opcode & 0x30) == 0
+	  || (opcode & 0x38) == 0x10)
+	{
+	}
+    }
+  while (!State.exception);
+}
+
+int
+sim_trace ()
+{
+#ifdef DEBUG
+  mn10300_debug = DEBUG;
+#endif
+  sim_resume (0, 0);
+  return 1;
+}
+
+void
+sim_info (verbose)
+     int verbose;
+{
+  (*mn10300_callback->printf_filtered) (mn10300_callback, "sim_info\n");
+}
+
+void
+sim_create_inferior (start_address, argv, env)
+     SIM_ADDR start_address;
+     char **argv;
+     char **env;
+{
+  PC = start_address;
+}
+
+void
+sim_kill ()
+{
+  /* nothing to do */
+}
+
+void
+sim_set_callbacks (p)
+     host_callback *p;
+{
+  mn10300_callback = p;
+}
+
+/* All the code for exiting, signals, etc needs to be revamped.
+
+   This is enough to get c-torture limping though.  */
+
+void
+sim_stop_reason (reason, sigrc)
+     enum sim_stop *reason;
+     int *sigrc;
+{
+  *reason = sim_stopped;
+  if (State.exception == SIGQUIT)
+    *sigrc = 0;
+  else
+    *sigrc = State.exception;
+}
+
+void
+sim_fetch_register (rn, memory)
+     int rn;
+     unsigned char *memory;
+{
+  put_word (memory, State.regs[rn]);
+}
+ 
+void
+sim_store_register (rn, memory)
+     int rn;
+     unsigned char *memory;
+{
+  State.regs[rn] = get_word (memory);
+}
+
+int
+sim_read (addr, buffer, size)
+     SIM_ADDR addr;
+     unsigned char *buffer;
+     int size;
+{
+  int i;
+  for (i = 0; i < size; i++)
+    buffer[i] = load_mem (addr + i, 1);
+
+  return size;
+} 
+
+void
+sim_do_command (cmd)
+     char *cmd;
+{
+  (*mn10300_callback->printf_filtered) (mn10300_callback, "\"%s\" is not a valid mn10300 simulator command.\n", cmd);
+}
+
+int
+sim_load (prog, from_tty)
+     char *prog;
+     int from_tty;
+{
+  /* Return nonzero so GDB will handle it.  */
+  return 1;
+} 

sim/mn10300/mn10300_sim.h

@@ -0,0 +1,131 @@
+#include <stdio.h>
+#include <ctype.h>
+#include "ansidecl.h"
+#include "callback.h"
+#include "opcode/mn10300.h"
+#include <limits.h>
+#include "remote-sim.h"
+
+extern host_callback *mn10300_callback;
+
+#define DEBUG_TRACE		0x00000001
+#define DEBUG_VALUES		0x00000002
+
+extern int mn10300_debug;
+
+#if UCHAR_MAX == 255
+typedef unsigned char uint8;
+typedef signed char int8;
+#else
+#error "Char is not an 8-bit type"
+#endif
+
+#if SHRT_MAX == 32767
+typedef unsigned short uint16;
+typedef signed short int16;
+#else
+#error "Short is not a 16-bit type"
+#endif
+
+#if INT_MAX == 2147483647
+
+typedef unsigned int uint32;
+typedef signed int int32;
+
+#else
+#  if LONG_MAX == 2147483647
+
+typedef unsigned long uint32;
+typedef signed long int32;
+
+#  else
+#  error "Neither int nor long is a 32-bit type"
+#  endif
+#endif
+
+typedef uint32 reg_t;
+
+struct simops 
+{
+  long opcode;
+  long mask;
+  void (*func)();
+  int numops;
+  int operands[16];
+};
+
+/* The current state of the processor; registers, memory, etc.  */
+
+struct _state
+{
+  reg_t regs[9];		/* registers, d0-d3, a0-a3, sp */
+  reg_t sregs[8];		/* system registers, including psw */
+  reg_t pc;
+  uint8 *mem;			/* main memory */
+  int exception;
+} State;
+
+extern uint32 OP[4];
+extern struct simops Simops[];
+
+#define PC	(State.pc)
+
+#define PSW (State.sregs[0])
+
+#define SEXT3(x)	((((x)&0x7)^(~0x3))+0x4)	
+
+/* sign-extend a 4-bit number */
+#define SEXT4(x)	((((x)&0xf)^(~0x7))+0x8)	
+
+/* sign-extend a 5-bit number */
+#define SEXT5(x)	((((x)&0x1f)^(~0xf))+0x10)	
+
+/* sign-extend an 8-bit number */
+#define SEXT8(x)	((((x)&0xff)^(~0x7f))+0x80)
+
+/* sign-extend a 9-bit number */
+#define SEXT9(x)	((((x)&0x1ff)^(~0xff))+0x100)
+
+/* sign-extend a 16-bit number */
+#define SEXT16(x)	((((x)&0xffff)^(~0x7fff))+0x8000)
+
+/* sign-extend a 22-bit number */
+#define SEXT22(x)	((((x)&0x3fffff)^(~0x1fffff))+0x200000)
+
+/* sign-extend a 32-bit number */
+#define SEXT32(x)	((((x)&0xffffffffLL)^(~0x7fffffffLL))+0x80000000LL)
+
+/* sign extend a 40 bit number */
+#define SEXT40(x)	((((x)&0xffffffffffLL)^(~0x7fffffffffLL))+0x8000000000LL)
+
+/* sign extend a 44 bit number */
+#define SEXT44(x)	((((x)&0xfffffffffffLL)^(~0x7ffffffffffLL))+0x80000000000LL)
+
+/* sign extend a 60 bit number */
+#define SEXT60(x)	((((x)&0xfffffffffffffffLL)^(~0x7ffffffffffffffLL))+0x800000000000000LL)
+
+#define MAX32	0x7fffffffLL
+#define MIN32	0xff80000000LL
+#define MASK32	0xffffffffLL
+#define MASK40	0xffffffffffLL
+
+#define RLW(x) load_mem (x, 4)
+
+#ifdef _WIN32
+#define SIGTRAP 5
+#define SIGQUIT 3
+#endif
+
+/* Function declarations.  */
+
+uint32 get_word PARAMS ((uint8 *));
+uint16 get_half PARAMS ((uint8 *));
+uint8 get_byte PARAMS ((uint8 *));
+void put_word PARAMS ((uint8 *, uint32));
+void put_half PARAMS ((uint8 *, uint16));
+void put_byte PARAMS ((uint8 *, uint8));
+
+extern uint32 load_mem PARAMS ((SIM_ADDR addr, int len));
+extern void store_mem PARAMS ((SIM_ADDR addr, int len, uint32 data));
+
+extern uint8 *map PARAMS ((SIM_ADDR addr));