* gencode.c, interp.c, mn10300_sim.h, simops.c: New files.
Skeleton mn10300 simulator
h8300
h8500
mips
+mn10300
ppc
sh
w65
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
--- /dev/null
+# .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.
--- /dev/null
+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.
+
--- /dev/null
+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
--- /dev/null
+#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");
+}
--- /dev/null
+#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;
+}
--- /dev/null
+#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));
--- /dev/null
+#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
+
+\f
+/* 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 ()
+{
+}
projects / external / binutils.git / commitdiff