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

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

Skeleton mn10300 simulator

9 files changed, 1956 insertions, 0 deletions

diff --git a/sim/.Sanitize b/sim/.Sanitize
index c2e6077..2e1fcc0 100644
--- a/sim/.Sanitize
+++ b/sim/.Sanitize
@@ -54,6 +54,7 @@ erc32
 h8300
 h8500
 mips
+mn10300
 ppc
 sh
 w65
diff --git a/sim/configure.in b/sim/configure.in
index bb5635c..620d0b0 100644
--- a/sim/configure.in
+++ b/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
diff --git a/sim/mn10300/.Sanitize b/sim/mn10300/.Sanitize
new file mode 100644
index 0000000..a6fa34f
--- /dev/null
+++ b/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.
diff --git a/sim/mn10300/ChangeLog b/sim/mn10300/ChangeLog
new file mode 100644
index 0000000..7f66829
--- /dev/null
+++ b/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.
+	
diff --git a/sim/mn10300/configure.in b/sim/mn10300/configure.in
new file mode 100644
index 0000000..b31f21c
--- /dev/null
+++ b/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
diff --git a/sim/mn10300/gencode.c b/sim/mn10300/gencode.c
new file mode 100644
index 0000000..d2f5e3b
--- /dev/null
+++ b/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");
+}
diff --git a/sim/mn10300/interp.c b/sim/mn10300/interp.c
new file mode 100644
index 0000000..cf0d713
--- /dev/null
+++ b/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;
+} 
diff --git a/sim/mn10300/mn10300_sim.h b/sim/mn10300/mn10300_sim.h
new file mode 100644
index 0000000..b18dee8
--- /dev/null
+++ b/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));
diff --git a/sim/mn10300/simops.c b/sim/mn10300/simops.c
new file mode 100644
index 0000000..3615bea
--- /dev/null
+++ b/sim/mn10300/simops.c
@@ -0,0 +1,1228 @@
+#include "config.h"
+
+#include <signal.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include "mn10300_sim.h"
+#include "simops.h"
+#include "sys/syscall.h"
+#include "bfd.h"
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/times.h>
+#include <sys/time.h>
+
+enum op_types {
+  OP_UNKNOWN,
+};
+
+#ifdef DEBUG
+static void trace_input PARAMS ((char *name, enum op_types type, int size));
+static void trace_output PARAMS ((enum op_types result));
+static int init_text_p = 0;
+static asection *text;
+static bfd_vma text_start;
+static bfd_vma text_end;
+extern bfd *exec_bfd;
+
+#ifndef SIZE_INSTRUCTION
+#define SIZE_INSTRUCTION 6
+#endif
+
+#ifndef SIZE_OPERANDS
+#define SIZE_OPERANDS 16
+#endif
+
+#ifndef SIZE_VALUES
+#define SIZE_VALUES 11
+#endif
+
+#ifndef SIZE_LOCATION
+#define SIZE_LOCATION 40
+#endif
+
+static void
+trace_input (name, type, size)
+     char *name;
+     enum op_types type;
+     int size;
+{
+}
+
+static void
+trace_output (result)
+     enum op_types result;
+{
+}
+
+#else
+#define trace_input(NAME, IN1, IN2)
+#define trace_output(RESULT)
+#endif
+
+
+/* mov */
+void OP_8000 ()
+{
+}
+
+/* mov */
+void OP_80 ()
+{
+}
+
+/* mov */
+void OP_F1E0 ()
+{
+}
+
+/* mov */
+void OP_F1D0 ()
+{
+}
+
+/* mov */
+void OP_9000 ()
+{
+}
+
+/* mov */
+void OP_90 ()
+{
+}
+
+/* mov */
+void OP_3C ()
+{
+}
+
+/* mov */
+void OP_F2F0 ()
+{
+}
+
+/* mov */
+void OP_F2E4 ()
+{
+}
+
+/* mov */
+void OP_F2F3 ()
+{
+}
+
+/* mov */
+void OP_F2E0 ()
+{
+}
+
+/* mov */
+void OP_F2F2 ()
+{
+}
+
+/* mov */
+void OP_70 ()
+{
+}
+
+/* mov */
+void OP_F80000 ()
+{
+}
+
+/* mov */
+void OP_FA000000 ()
+{
+}
+
+/* mov */
+void OP_FC000000 ()
+{
+}
+
+/* mov */
+void OP_5800 ()
+{
+}
+
+/* mov */
+void OP_FAB40000 ()
+{
+}
+
+/* mov */
+void OP_FCB40000 ()
+{
+}
+
+/* mov */
+void OP_F300 ()
+{
+}
+
+/* mov */
+void OP_300000 ()
+{
+}
+
+/* mov */
+void OP_FCA40000 ()
+{
+}
+
+/* mov */
+void OP_F000 ()
+{
+}
+
+/* mov */
+void OP_F82000 ()
+{
+}
+
+/* mov */
+void OP_FA200000 ()
+{
+}
+
+/* mov */
+void OP_FC200000 ()
+{
+}
+
+/* mov */
+void OP_5C00 ()
+{
+}
+
+/* mov */
+void OP_FAB00000 ()
+{
+}
+
+/* mov */
+void OP_FCB00000 ()
+{
+}
+
+/* mov */
+void OP_F380 ()
+{
+}
+
+/* mov */
+void OP_FAA00000 ()
+{
+}
+
+/* mov */
+void OP_FCA00000 ()
+{
+}
+
+/* mov */
+void OP_F8F000 ()
+{
+}
+
+/* mov */
+void OP_60 ()
+{
+}
+
+/* mov */
+void OP_F81000 ()
+{
+}
+
+/* mov */
+void OP_FA100000 ()
+{
+}
+
+/* mov */
+void OP_FC100000 ()
+{
+}
+
+/* mov */
+void OP_4200 ()
+{
+}
+
+/* mov */
+void OP_FA910000 ()
+{
+}
+
+/* mov */
+void OP_FC910000 ()
+{
+}
+
+/* mov */
+void OP_F340 ()
+{
+}
+
+/* mov */
+void OP_10000 ()
+{
+}
+
+/* mov */
+void OP_FC810000 ()
+{
+}
+
+/* mov */
+void OP_F010 ()
+{
+}
+
+/* mov */
+void OP_F83000 ()
+{
+}
+
+/* mov */
+void OP_FA300000 ()
+{
+}
+
+/* mov */
+void OP_FC300000 ()
+{
+}
+
+/* mov */
+void OP_4300 ()
+{
+}
+
+/* mov */
+void OP_FA900000 ()
+{
+}
+
+/* mov */
+void OP_FC900000 ()
+{
+}
+
+/* mov */
+void OP_F3C0 ()
+{
+}
+
+/* mov */
+void OP_FA800000 ()
+{
+}
+
+/* mov */
+void OP_FC800000 ()
+{
+}
+
+/* mov */
+void OP_F8F400 ()
+{
+}
+
+/* mov */
+void OP_2C0000 ()
+{
+}
+
+/* mov */
+void OP_FCCC0000 ()
+{
+}
+
+/* mov */
+void OP_240000 ()
+{
+}
+
+/* mov */
+void OP_FCDC0000 ()
+{
+}
+
+/* movbu */
+void OP_F040 ()
+{
+}
+
+/* movbu */
+void OP_F84000 ()
+{
+}
+
+/* movbu */
+void OP_FA400000 ()
+{
+}
+
+/* movbu */
+void OP_FC400000 ()
+{
+}
+
+/* movbu */
+void OP_F8B800 ()
+{
+}
+
+/* movbu */
+void OP_FAB80000 ()
+{
+}
+
+/* movbu */
+void OP_FCB80000 ()
+{
+}
+
+/* movbu */
+void OP_F400 ()
+{
+}
+
+/* movbu */
+void OP_340000 ()
+{
+}
+
+/* movbu */
+void OP_FCA80000 ()
+{
+}
+
+/* movbu */
+void OP_F050 ()
+{
+}
+
+/* movbu */
+void OP_F85000 ()
+{
+}
+
+/* movbu */
+void OP_FA500000 ()
+{
+}
+
+/* movbu */
+void OP_FC500000 ()
+{
+}
+
+/* movbu */
+void OP_F89200 ()
+{
+}
+
+/* movbu */
+void OP_FA920000 ()
+{
+}
+
+/* movbu */
+void OP_FC920000 ()
+{
+}
+
+/* movbu */
+void OP_F440 ()
+{
+}
+
+/* movbu */
+void OP_20000 ()
+{
+}
+
+/* movbu */
+void OP_FC820000 ()
+{
+}
+
+/* movhu */
+void OP_F060 ()
+{
+}
+
+/* movhu */
+void OP_F86000 ()
+{
+}
+
+/* movhu */
+void OP_FA600000 ()
+{
+}
+
+/* movhu */
+void OP_FC600000 ()
+{
+}
+
+/* movhu */
+void OP_F8BC00 ()
+{
+}
+
+/* movhu */
+void OP_FABC0000 ()
+{
+}
+
+/* movhu */
+void OP_FCBC0000 ()
+{
+}
+
+/* movhu */
+void OP_F480 ()
+{
+}
+
+/* movhu */
+void OP_380000 ()
+{
+}
+
+/* movhu */
+void OP_FCAC0000 ()
+{
+}
+
+/* movhu */
+void OP_F070 ()
+{
+}
+
+/* movhu */
+void OP_F87000 ()
+{
+}
+
+/* movhu */
+void OP_FA700000 ()
+{
+}
+
+/* movhu */
+void OP_FC700000 ()
+{
+}
+
+/* movhu */
+void OP_F89300 ()
+{
+}
+
+/* movhu */
+void OP_FA930000 ()
+{
+}
+
+/* movhu */
+void OP_FC930000 ()
+{
+}
+
+/* movhu */
+void OP_F4C0 ()
+{
+}
+
+/* movhu */
+void OP_30000 ()
+{
+}
+
+/* movhu */
+void OP_FC830000 ()
+{
+}
+
+/* ext */
+void OP_F2D0 ()
+{
+}
+
+/* extb */
+void OP_10 ()
+{
+}
+
+/* extbu */
+void OP_14 ()
+{
+}
+
+/* exth */
+void OP_18 ()
+{
+}
+
+/* exthu */
+void OP_1C ()
+{
+}
+
+/* movm */
+void OP_CE00 ()
+{
+}
+
+/* movm */
+void OP_CF00 ()
+{
+}
+
+/* clr */
+void OP_0 ()
+{
+}
+
+/* add */
+void OP_E0 ()
+{
+}
+
+/* add */
+void OP_F160 ()
+{
+}
+
+/* add */
+void OP_F150 ()
+{
+}
+
+/* add */
+void OP_F170 ()
+{
+}
+
+/* add */
+void OP_2800 ()
+{
+}
+
+/* add */
+void OP_FAC00000 ()
+{
+}
+
+/* add */
+void OP_FCC00000 ()
+{
+}
+
+/* add */
+void OP_2000 ()
+{
+}
+
+/* add */
+void OP_FAD00000 ()
+{
+}
+
+/* add */
+void OP_FCD00000 ()
+{
+}
+
+/* add */
+void OP_F8FE00 ()
+{
+}
+
+/* add */
+void OP_FAFE0000 ()
+{
+}
+
+/* add */
+void OP_FCFE0000 ()
+{
+}
+
+/* addc */
+void OP_F140 ()
+{
+}
+
+/* sub */
+void OP_F100 ()
+{
+}
+
+/* sub */
+void OP_F120 ()
+{
+}
+
+/* sub */
+void OP_F110 ()
+{
+}
+
+/* sub */
+void OP_F130 ()
+{
+}
+
+/* sub */
+void OP_FCC40000 ()
+{
+}
+
+/* sub */
+void OP_FCD40000 ()
+{
+}
+
+/* subc */
+void OP_F180 ()
+{
+}
+
+/* mul */
+void OP_F240 ()
+{
+}
+
+/* mulu */
+void OP_F250 ()
+{
+}
+
+/* div */
+void OP_F260 ()
+{
+}
+
+/* divu */
+void OP_F270 ()
+{
+}
+
+/* inc */
+void OP_40 ()
+{
+}
+
+/* inc */
+void OP_41 ()
+{
+}
+
+/* inc4 */
+void OP_50 ()
+{
+}
+
+/* cmp */
+void OP_A000 ()
+{
+}
+
+/* cmp */
+void OP_A0 ()
+{
+}
+
+/* cmp */
+void OP_F1A0 ()
+{
+}
+
+/* cmp */
+void OP_F190 ()
+{
+}
+
+/* cmp */
+void OP_B000 ()
+{
+}
+
+/* cmp */
+void OP_B0 ()
+{
+}
+
+/* cmp */
+void OP_FAC80000 ()
+{
+}
+
+/* cmp */
+void OP_FCC80000 ()
+{
+}
+
+/* cmp */
+void OP_FAD80000 ()
+{
+}
+
+/* cmp */
+void OP_FCD80000 ()
+{
+}
+
+/* and */
+void OP_F200 ()
+{
+}
+
+/* and */
+void OP_F8E000 ()
+{
+}
+
+/* and */
+void OP_FAE00000 ()
+{
+}
+
+/* and */
+void OP_FCE00000 ()
+{
+}
+
+/* and */
+void OP_FAFC0000 ()
+{
+}
+
+/* or */
+void OP_F210 ()
+{
+}
+
+/* or */
+void OP_F8E400 ()
+{
+}
+
+/* or */
+void OP_FAE40000 ()
+{
+}
+
+/* or */
+void OP_FCE40000 ()
+{
+}
+
+/* or */
+void OP_FAFD0000 ()
+{
+}
+
+/* xor */
+void OP_F220 ()
+{
+}
+
+/* xor */
+void OP_FAE80000 ()
+{
+}
+
+/* xor */
+void OP_FCE80000 ()
+{
+}
+
+/* not */
+void OP_F230 ()
+{
+}
+
+/* btst */
+void OP_F8EC00 ()
+{
+}
+
+/* btst */
+void OP_FAEC0000 ()
+{
+}
+
+/* btst */
+void OP_FCEC0000 ()
+{
+}
+
+/* btst */
+void OP_FE020000 ()
+{
+}
+
+/* btst */
+void OP_FAF80000 ()
+{
+}
+
+/* btst */
+void OP_F080 ()
+{
+}
+
+/* btst */
+void OP_FE000000 ()
+{
+}
+
+/* btst */
+void OP_FAF00000 ()
+{
+}
+
+/* bclr */
+void OP_F090 ()
+{
+}
+
+/* bclr */
+void OP_FE010000 ()
+{
+}
+
+/* bclr */
+void OP_FAF40000 ()
+{
+}
+
+/* asr */
+void OP_F2B0 ()
+{
+}
+
+/* asr */
+void OP_F8C800 ()
+{
+}
+
+/* lsr */
+void OP_F2A0 ()
+{
+}
+
+/* lsr */
+void OP_F8C400 ()
+{
+}
+
+/* asl */
+void OP_F290 ()
+{
+}
+
+/* asl */
+void OP_F8C000 ()
+{
+}
+
+/* asl2 */
+void OP_54 ()
+{
+}
+
+/* ror */
+void OP_F284 ()
+{
+}
+
+/* rol */
+void OP_F280 ()
+{
+}
+
+/* beq */
+void OP_C800 ()
+{
+}
+
+/* bne */
+void OP_C900 ()
+{
+}
+
+/* bgt */
+void OP_C100 ()
+{
+}
+
+/* bge */
+void OP_C200 ()
+{
+}
+
+/* ble */
+void OP_C300 ()
+{
+}
+
+/* blt */
+void OP_C000 ()
+{
+}
+
+/* bhi */
+void OP_C500 ()
+{
+}
+
+/* bcc */
+void OP_C600 ()
+{
+}
+
+/* bls */
+void OP_C700 ()
+{
+}
+
+/* bcs */
+void OP_C400 ()
+{
+}
+
+/* bvc */
+void OP_F8E800 ()
+{
+}
+
+/* bvs */
+void OP_F8E900 ()
+{
+}
+
+/* bnc */
+void OP_F8EA00 ()
+{
+}
+
+/* bns */
+void OP_F8EB00 ()
+{
+}
+
+/* bra */
+void OP_CA00 ()
+{
+}
+
+/* leq */
+void OP_D8 ()
+{
+}
+
+/* lne */
+void OP_D9 ()
+{
+}
+
+/* lgt */
+void OP_D1 ()
+{
+}
+
+/* lge */
+void OP_D2 ()
+{
+}
+
+/* lle */
+void OP_D3 ()
+{
+}
+
+/* llt */
+void OP_D0 ()
+{
+}
+
+/* lhi */
+void OP_D5 ()
+{
+}
+
+/* lcc */
+void OP_D6 ()
+{
+}
+
+/* lls */
+void OP_D7 ()
+{
+}
+
+/* lcs */
+void OP_D4 ()
+{
+}
+
+/* lra */
+void OP_DA ()
+{
+}
+
+/* setlb */
+void OP_DB ()
+{
+}
+
+/* jmp */
+void OP_F0F4 ()
+{
+}
+
+/* jmp */
+void OP_CC0000 ()
+{
+}
+
+/* jmp */
+void OP_DC000000 ()
+{
+}
+
+/* call */
+void OP_CD000000 ()
+{
+}
+
+/* call */
+void OP_DD000000 ()
+{
+}
+
+/* calls */
+void OP_F0F0 ()
+{
+}
+
+/* calls */
+void OP_FAFF0000 ()
+{
+}
+
+/* calls */
+void OP_FCFF0000 ()
+{
+}
+
+/* ret */
+void OP_DF0000 ()
+{
+}
+
+/* retf */
+void OP_DE0000 ()
+{
+}
+
+/* rets */
+void OP_F0FC ()
+{
+}
+
+/* rti */
+void OP_F0FD ()
+{
+}
+
+/* trap */
+void OP_F0FE ()
+{
+}
+
+/* rtm */
+void OP_F0FF ()
+{
+}
+
+/* nop */
+void OP_CB ()
+{
+}
+
+/* putx */
+void OP_F500 ()
+{
+}
+
+/* getx */
+void OP_F6F0 ()
+{
+}
+
+/* mulq */
+void OP_F600 ()
+{
+}
+
+/* mulq */
+void OP_F90000 ()
+{
+}
+
+/* mulq */
+void OP_FB000000 ()
+{
+}
+
+/* mulq */
+void OP_FD000000 ()
+{
+}
+
+/* mulqu */
+void OP_F610 ()
+{
+}
+
+/* mulqu */
+void OP_F91400 ()
+{
+}
+
+/* mulqu */
+void OP_FB140000 ()
+{
+}
+
+/* mulqu */
+void OP_FD140000 ()
+{
+}
+
+/* sat16 */
+void OP_F640 ()
+{
+}
+
+/* sat24 */
+void OP_F650 ()
+{
+}
+
+/* bsch */
+void OP_F670 ()
+{
+}