diff options
| -rw-r--r-- | sim/.Sanitize | 1 | ||||
| -rw-r--r-- | sim/configure.in | 5 | ||||
| -rw-r--r-- | sim/mn10300/.Sanitize | 40 | ||||
| -rw-r--r-- | sim/mn10300/ChangeLog | 5 | ||||
| -rw-r--r-- | sim/mn10300/configure.in | 9 | ||||
| -rw-r--r-- | sim/mn10300/gencode.c | 143 | ||||
| -rw-r--r-- | sim/mn10300/interp.c | 394 | ||||
| -rw-r--r-- | sim/mn10300/mn10300_sim.h | 131 | ||||
| -rw-r--r-- | sim/mn10300/simops.c | 1228 |
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 () +{ +} |